LogicMonitor REST API

LM

ackAlertById

ack alert by id


/alert/alerts/{id}/ack

Usage and SDK Samples

curl -X POST -H "Authorization: [[apiKey]]" "https://localhost/santaba/rest/alert/alerts/{id}/ack"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LMApi;

import java.io.File;
import java.util.*;

public class LMApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: LMv1
        ApiKeyAuth LMv1 = (ApiKeyAuth) defaultClient.getAuthentication("LMv1");
        LMv1.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //LMv1.setApiKeyPrefix("Token");

        LMApi apiInstance = new LMApi();
        AlertAck body = ; // AlertAck | 
        String id = id_example; // String | 
        try {
            Object result = apiInstance.ackAlertById(body, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#ackAlertById");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        AlertAck body = ; // AlertAck | 
        String id = id_example; // String | 
        try {
            Object result = apiInstance.ackAlertById(body, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#ackAlertById");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: LMv1)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

AlertAck *body = ; // 
String *id = id_example; // 

LMApi *apiInstance = [[LMApi alloc] init];

// ack alert by id
[apiInstance ackAlertByIdWith:body
    id:id
              completionHandler: ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LogicMonitorRestApi = require('logic_monitor_rest_api');
var defaultClient = LogicMonitorRestApi.ApiClient.instance;

// Configure API key authorization: LMv1
var LMv1 = defaultClient.authentications['LMv1'];
LMv1.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//LMv1.apiKeyPrefix['Authorization'] = "Token"

var api = new LogicMonitorRestApi.LMApi()

var body = ; // {AlertAck} 

var id = id_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.ackAlertById(body, id, callback);
using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class ackAlertByIdExample
    {
        public void main()
        {
            
            // Configure API key authorization: LMv1
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new LMApi();
            var body = new AlertAck(); // AlertAck | 
            var id = id_example;  // String | 

            try
            {
                // ack alert by id
                Object result = apiInstance.ackAlertById(body, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.ackAlertById: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: LMv1
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\LMApi();
$body = ; // AlertAck | 
$id = id_example; // String | 

try {
    $result = $api_instance->ackAlertById($body, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->ackAlertById: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LMApi;

# Configure API key authorization: LMv1
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::LMApi->new();
my $body = WWW::SwaggerClient::Object::AlertAck->new(); # AlertAck | 
my $id = id_example; # String | 

eval { 
    my $result = $api_instance->ackAlertById(body => $body, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->ackAlertById: $@\n";
}
from __future__ import print_function
import time
import logicmonitor_sdk
from logicmonitor_sdk.rest import ApiException
from pprint import pprint


# Configure API key authorization: LMv1
configuration = logicmonitor_sdk.Configuration()
configuration.company = 'YOUR_COMPANY'
configuration.access_id = 'YOUR_ACCESS_ID'
configuration.access_key = 'YOUR_ACCESS_KEY'

# create an instance of the API class
api_instance = logicmonitor_sdk.LMApi(logicmonitor_sdk.ApiClient(configuration))
body =  # AlertAck | 
id = id_example # String | 

try:
    # ack alert by id
    api_response = api_instance.ack_alert_by_id(body, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->ackAlertById: %s\n" % e)
package main

import (
    "fmt"
    "github.com/logicmonitor/lm-sdk-go/client"
    "github.com/logicmonitor/lm-sdk-go/client/lm"
)
func main() {
    // Configure API key authorization: LMv1
    domain := "YOUR_COMPANY.logicmonitor.com"
    accessID := "YOUR_ACCESS_ID"
    accessKey := "YOUR_ACCESS_KEY"

    config := client.NewConfig()
    config.SetAccountDomain(&domain)
    config.SetAccessID(&accessID)
    config.SetAccessKey(&accessKey)
    
    // create an instance of the API class
    client := client.New(config)
    params := lm.NewAckAlertByIDParams()
    params.Body =  // AlertAck | 
    params.ID = id_example // String | 

    // ack alert by id
    resp, err := client.LM.AckAlertByID(params)
    if err != nil {
        fmt.Printf("Exception when calling client.LM.AckAlertByID: %v", err.Error())
    }
    fmt.Print(resp)
}

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
body *

Responses

Status: 200 - successful operation

Status: default - Error


ackCollectorDownAlertById

ack collector down alert


/setting/collector/collectors/{id}/ackdown

Usage and SDK Samples

curl -X POST -H "Authorization: [[apiKey]]" "https://localhost/santaba/rest/setting/collector/collectors/{id}/ackdown"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LMApi;

import java.io.File;
import java.util.*;

public class LMApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: LMv1
        ApiKeyAuth LMv1 = (ApiKeyAuth) defaultClient.getAuthentication("LMv1");
        LMv1.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //LMv1.setApiKeyPrefix("Token");

        LMApi apiInstance = new LMApi();
        Integer id = 56; // Integer | 
        AckCollectorDown body = ; // AckCollectorDown | 
        try {
            Object result = apiInstance.ackCollectorDownAlertById(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#ackCollectorDownAlertById");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        Integer id = 56; // Integer | 
        AckCollectorDown body = ; // AckCollectorDown | 
        try {
            Object result = apiInstance.ackCollectorDownAlertById(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#ackCollectorDownAlertById");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: LMv1)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

Integer *id = 56; // 
AckCollectorDown *body = ; // 

LMApi *apiInstance = [[LMApi alloc] init];

// ack collector down alert
[apiInstance ackCollectorDownAlertByIdWith:id
    body:body
              completionHandler: ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LogicMonitorRestApi = require('logic_monitor_rest_api');
var defaultClient = LogicMonitorRestApi.ApiClient.instance;

// Configure API key authorization: LMv1
var LMv1 = defaultClient.authentications['LMv1'];
LMv1.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//LMv1.apiKeyPrefix['Authorization'] = "Token"

var api = new LogicMonitorRestApi.LMApi()

var id = 56; // {Integer} 

var body = ; // {AckCollectorDown} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.ackCollectorDownAlertById(id, body, callback);
using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class ackCollectorDownAlertByIdExample
    {
        public void main()
        {
            
            // Configure API key authorization: LMv1
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new LMApi();
            var id = 56;  // Integer | 
            var body = new AckCollectorDown(); // AckCollectorDown | 

            try
            {
                // ack collector down alert
                Object result = apiInstance.ackCollectorDownAlertById(id, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.ackCollectorDownAlertById: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: LMv1
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\LMApi();
$id = 56; // Integer | 
$body = ; // AckCollectorDown | 

try {
    $result = $api_instance->ackCollectorDownAlertById($id, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->ackCollectorDownAlertById: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LMApi;

# Configure API key authorization: LMv1
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::LMApi->new();
my $id = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::AckCollectorDown->new(); # AckCollectorDown | 

eval { 
    my $result = $api_instance->ackCollectorDownAlertById(id => $id, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->ackCollectorDownAlertById: $@\n";
}
from __future__ import print_function
import time
import logicmonitor_sdk
from logicmonitor_sdk.rest import ApiException
from pprint import pprint


# Configure API key authorization: LMv1
configuration = logicmonitor_sdk.Configuration()
configuration.company = 'YOUR_COMPANY'
configuration.access_id = 'YOUR_ACCESS_ID'
configuration.access_key = 'YOUR_ACCESS_KEY'

# create an instance of the API class
api_instance = logicmonitor_sdk.LMApi(logicmonitor_sdk.ApiClient(configuration))
id = 56 # Integer | 
body =  # AckCollectorDown | 

try:
    # ack collector down alert
    api_response = api_instance.ack_collector_down_alert_by_id(id, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->ackCollectorDownAlertById: %s\n" % e)
package main

import (
    "fmt"
    "github.com/logicmonitor/lm-sdk-go/client"
    "github.com/logicmonitor/lm-sdk-go/client/lm"
)
func main() {
    // Configure API key authorization: LMv1
    domain := "YOUR_COMPANY.logicmonitor.com"
    accessID := "YOUR_ACCESS_ID"
    accessKey := "YOUR_ACCESS_KEY"

    config := client.NewConfig()
    config.SetAccountDomain(&domain)
    config.SetAccessID(&accessID)
    config.SetAccessKey(&accessKey)
    
    // create an instance of the API class
    client := client.New(config)
    params := lm.NewAckCollectorDownAlertByIDParams()
    params.ID = 56 // Integer | 
    params.Body =  // AckCollectorDown | 

    // ack collector down alert
    resp, err := client.LM.AckCollectorDownAlertByID(params)
    if err != nil {
        fmt.Printf("Exception when calling client.LM.AckCollectorDownAlertByID: %v", err.Error())
    }
    fmt.Print(resp)
}

Parameters

Path parameters
Name Description
id*
Integer (int32)
Required
Body parameters
Name Description
body *

Responses

Status: 200 - successful operation

Status: default - Error


addAdmin

add user


/setting/admins

Usage and SDK Samples

curl -X POST -H "Authorization: [[apiKey]]" "https://localhost/santaba/rest/setting/admins"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LMApi;

import java.io.File;
import java.util.*;

public class LMApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: LMv1
        ApiKeyAuth LMv1 = (ApiKeyAuth) defaultClient.getAuthentication("LMv1");
        LMv1.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //LMv1.setApiKeyPrefix("Token");

        LMApi apiInstance = new LMApi();
        Admin body = ; // Admin | 
        try {
            Admin result = apiInstance.addAdmin(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addAdmin");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        Admin body = ; // Admin | 
        try {
            Admin result = apiInstance.addAdmin(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addAdmin");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: LMv1)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

Admin *body = ; // 

LMApi *apiInstance = [[LMApi alloc] init];

// add user
[apiInstance addAdminWith:body
              completionHandler: ^(Admin output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LogicMonitorRestApi = require('logic_monitor_rest_api');
var defaultClient = LogicMonitorRestApi.ApiClient.instance;

// Configure API key authorization: LMv1
var LMv1 = defaultClient.authentications['LMv1'];
LMv1.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//LMv1.apiKeyPrefix['Authorization'] = "Token"

var api = new LogicMonitorRestApi.LMApi()

var body = ; // {Admin} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addAdmin(body, callback);
using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class addAdminExample
    {
        public void main()
        {
            
            // Configure API key authorization: LMv1
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new LMApi();
            var body = new Admin(); // Admin | 

            try
            {
                // add user
                Admin result = apiInstance.addAdmin(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.addAdmin: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: LMv1
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\LMApi();
$body = ; // Admin | 

try {
    $result = $api_instance->addAdmin($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->addAdmin: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LMApi;

# Configure API key authorization: LMv1
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::LMApi->new();
my $body = WWW::SwaggerClient::Object::Admin->new(); # Admin | 

eval { 
    my $result = $api_instance->addAdmin(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->addAdmin: $@\n";
}
from __future__ import print_function
import time
import logicmonitor_sdk
from logicmonitor_sdk.rest import ApiException
from pprint import pprint


# Configure API key authorization: LMv1
configuration = logicmonitor_sdk.Configuration()
configuration.company = 'YOUR_COMPANY'
configuration.access_id = 'YOUR_ACCESS_ID'
configuration.access_key = 'YOUR_ACCESS_KEY'

# create an instance of the API class
api_instance = logicmonitor_sdk.LMApi(logicmonitor_sdk.ApiClient(configuration))
body =  # Admin | 

try:
    # add user
    api_response = api_instance.add_admin(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->addAdmin: %s\n" % e)
package main

import (
    "fmt"
    "github.com/logicmonitor/lm-sdk-go/client"
    "github.com/logicmonitor/lm-sdk-go/client/lm"
)
func main() {
    // Configure API key authorization: LMv1
    domain := "YOUR_COMPANY.logicmonitor.com"
    accessID := "YOUR_ACCESS_ID"
    accessKey := "YOUR_ACCESS_KEY"

    config := client.NewConfig()
    config.SetAccountDomain(&domain)
    config.SetAccessID(&accessID)
    config.SetAccessKey(&accessKey)
    
    // create an instance of the API class
    client := client.New(config)
    params := lm.NewAddAdminParams()
    params.Body =  // Admin | 

    // add user
    resp, err := client.LM.AddAdmin(params)
    if err != nil {
        fmt.Printf("Exception when calling client.LM.AddAdmin: %v", err.Error())
    }
    fmt.Print(resp)
}

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation

Status: default - Error


addAlertNoteById

add alert note


/alert/alerts/{id}/note

Usage and SDK Samples

curl -X POST -H "Authorization: [[apiKey]]" "https://localhost/santaba/rest/alert/alerts/{id}/note"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LMApi;

import java.io.File;
import java.util.*;

public class LMApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: LMv1
        ApiKeyAuth LMv1 = (ApiKeyAuth) defaultClient.getAuthentication("LMv1");
        LMv1.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //LMv1.setApiKeyPrefix("Token");

        LMApi apiInstance = new LMApi();
        AlertAck body = ; // AlertAck | 
        String id = id_example; // String | 
        try {
            Object result = apiInstance.addAlertNoteById(body, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addAlertNoteById");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        AlertAck body = ; // AlertAck | 
        String id = id_example; // String | 
        try {
            Object result = apiInstance.addAlertNoteById(body, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addAlertNoteById");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: LMv1)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

AlertAck *body = ; // 
String *id = id_example; // 

LMApi *apiInstance = [[LMApi alloc] init];

// add alert note
[apiInstance addAlertNoteByIdWith:body
    id:id
              completionHandler: ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LogicMonitorRestApi = require('logic_monitor_rest_api');
var defaultClient = LogicMonitorRestApi.ApiClient.instance;

// Configure API key authorization: LMv1
var LMv1 = defaultClient.authentications['LMv1'];
LMv1.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//LMv1.apiKeyPrefix['Authorization'] = "Token"

var api = new LogicMonitorRestApi.LMApi()

var body = ; // {AlertAck} 

var id = id_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addAlertNoteById(body, id, callback);
using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class addAlertNoteByIdExample
    {
        public void main()
        {
            
            // Configure API key authorization: LMv1
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new LMApi();
            var body = new AlertAck(); // AlertAck | 
            var id = id_example;  // String | 

            try
            {
                // add alert note
                Object result = apiInstance.addAlertNoteById(body, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.addAlertNoteById: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: LMv1
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\LMApi();
$body = ; // AlertAck | 
$id = id_example; // String | 

try {
    $result = $api_instance->addAlertNoteById($body, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->addAlertNoteById: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LMApi;

# Configure API key authorization: LMv1
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::LMApi->new();
my $body = WWW::SwaggerClient::Object::AlertAck->new(); # AlertAck | 
my $id = id_example; # String | 

eval { 
    my $result = $api_instance->addAlertNoteById(body => $body, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->addAlertNoteById: $@\n";
}
from __future__ import print_function
import time
import logicmonitor_sdk
from logicmonitor_sdk.rest import ApiException
from pprint import pprint


# Configure API key authorization: LMv1
configuration = logicmonitor_sdk.Configuration()
configuration.company = 'YOUR_COMPANY'
configuration.access_id = 'YOUR_ACCESS_ID'
configuration.access_key = 'YOUR_ACCESS_KEY'

# create an instance of the API class
api_instance = logicmonitor_sdk.LMApi(logicmonitor_sdk.ApiClient(configuration))
body =  # AlertAck | 
id = id_example # String | 

try:
    # add alert note
    api_response = api_instance.add_alert_note_by_id(body, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->addAlertNoteById: %s\n" % e)
package main

import (
    "fmt"
    "github.com/logicmonitor/lm-sdk-go/client"
    "github.com/logicmonitor/lm-sdk-go/client/lm"
)
func main() {
    // Configure API key authorization: LMv1
    domain := "YOUR_COMPANY.logicmonitor.com"
    accessID := "YOUR_ACCESS_ID"
    accessKey := "YOUR_ACCESS_KEY"

    config := client.NewConfig()
    config.SetAccountDomain(&domain)
    config.SetAccessID(&accessID)
    config.SetAccessKey(&accessKey)
    
    // create an instance of the API class
    client := client.New(config)
    params := lm.NewAddAlertNoteByIDParams()
    params.Body =  // AlertAck | 
    params.ID = id_example // String | 

    // add alert note
    resp, err := client.LM.AddAlertNoteByID(params)
    if err != nil {
        fmt.Printf("Exception when calling client.LM.AddAlertNoteByID: %v", err.Error())
    }
    fmt.Print(resp)
}

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
body *

Responses

Status: 200 - successful operation

Status: default - Error


addAlertRule

add alert rule


/setting/alert/rules

Usage and SDK Samples

curl -X POST -H "Authorization: [[apiKey]]" "https://localhost/santaba/rest/setting/alert/rules"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LMApi;

import java.io.File;
import java.util.*;

public class LMApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: LMv1
        ApiKeyAuth LMv1 = (ApiKeyAuth) defaultClient.getAuthentication("LMv1");
        LMv1.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //LMv1.setApiKeyPrefix("Token");

        LMApi apiInstance = new LMApi();
        AlertRule body = ; // AlertRule | 
        try {
            AlertRule result = apiInstance.addAlertRule(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addAlertRule");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        AlertRule body = ; // AlertRule | 
        try {
            AlertRule result = apiInstance.addAlertRule(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addAlertRule");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: LMv1)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

AlertRule *body = ; // 

LMApi *apiInstance = [[LMApi alloc] init];

// add alert rule
[apiInstance addAlertRuleWith:body
              completionHandler: ^(AlertRule output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LogicMonitorRestApi = require('logic_monitor_rest_api');
var defaultClient = LogicMonitorRestApi.ApiClient.instance;

// Configure API key authorization: LMv1
var LMv1 = defaultClient.authentications['LMv1'];
LMv1.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//LMv1.apiKeyPrefix['Authorization'] = "Token"

var api = new LogicMonitorRestApi.LMApi()

var body = ; // {AlertRule} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addAlertRule(body, callback);
using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class addAlertRuleExample
    {
        public void main()
        {
            
            // Configure API key authorization: LMv1
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new LMApi();
            var body = new AlertRule(); // AlertRule | 

            try
            {
                // add alert rule
                AlertRule result = apiInstance.addAlertRule(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.addAlertRule: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: LMv1
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\LMApi();
$body = ; // AlertRule | 

try {
    $result = $api_instance->addAlertRule($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->addAlertRule: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LMApi;

# Configure API key authorization: LMv1
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::LMApi->new();
my $body = WWW::SwaggerClient::Object::AlertRule->new(); # AlertRule | 

eval { 
    my $result = $api_instance->addAlertRule(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->addAlertRule: $@\n";
}
from __future__ import print_function
import time
import logicmonitor_sdk
from logicmonitor_sdk.rest import ApiException
from pprint import pprint


# Configure API key authorization: LMv1
configuration = logicmonitor_sdk.Configuration()
configuration.company = 'YOUR_COMPANY'
configuration.access_id = 'YOUR_ACCESS_ID'
configuration.access_key = 'YOUR_ACCESS_KEY'

# create an instance of the API class
api_instance = logicmonitor_sdk.LMApi(logicmonitor_sdk.ApiClient(configuration))
body =  # AlertRule | 

try:
    # add alert rule
    api_response = api_instance.add_alert_rule(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->addAlertRule: %s\n" % e)
package main

import (
    "fmt"
    "github.com/logicmonitor/lm-sdk-go/client"
    "github.com/logicmonitor/lm-sdk-go/client/lm"
)
func main() {
    // Configure API key authorization: LMv1
    domain := "YOUR_COMPANY.logicmonitor.com"
    accessID := "YOUR_ACCESS_ID"
    accessKey := "YOUR_ACCESS_KEY"

    config := client.NewConfig()
    config.SetAccountDomain(&domain)
    config.SetAccessID(&accessID)
    config.SetAccessKey(&accessKey)
    
    // create an instance of the API class
    client := client.New(config)
    params := lm.NewAddAlertRuleParams()
    params.Body =  // AlertRule | 

    // add alert rule
    resp, err := client.LM.AddAlertRule(params)
    if err != nil {
        fmt.Printf("Exception when calling client.LM.AddAlertRule: %v", err.Error())
    }
    fmt.Print(resp)
}

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation

Status: default - Error


addApiTokenByAdminId

add api tokens for a user


/setting/admins/{adminId}/apitokens

Usage and SDK Samples

curl -X POST -H "Authorization: [[apiKey]]" "https://localhost/santaba/rest/setting/admins/{adminId}/apitokens"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LMApi;

import java.io.File;
import java.util.*;

public class LMApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: LMv1
        ApiKeyAuth LMv1 = (ApiKeyAuth) defaultClient.getAuthentication("LMv1");
        LMv1.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //LMv1.setApiKeyPrefix("Token");

        LMApi apiInstance = new LMApi();
        Integer adminId = 56; // Integer | 
        APIToken body = ; // APIToken | 
        try {
            APIToken result = apiInstance.addApiTokenByAdminId(adminId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addApiTokenByAdminId");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        Integer adminId = 56; // Integer | 
        APIToken body = ; // APIToken | 
        try {
            APIToken result = apiInstance.addApiTokenByAdminId(adminId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addApiTokenByAdminId");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: LMv1)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

Integer *adminId = 56; // 
APIToken *body = ; // 

LMApi *apiInstance = [[LMApi alloc] init];

// add api tokens for a user
[apiInstance addApiTokenByAdminIdWith:adminId
    body:body
              completionHandler: ^(APIToken output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LogicMonitorRestApi = require('logic_monitor_rest_api');
var defaultClient = LogicMonitorRestApi.ApiClient.instance;

// Configure API key authorization: LMv1
var LMv1 = defaultClient.authentications['LMv1'];
LMv1.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//LMv1.apiKeyPrefix['Authorization'] = "Token"

var api = new LogicMonitorRestApi.LMApi()

var adminId = 56; // {Integer} 

var body = ; // {APIToken} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addApiTokenByAdminId(adminId, body, callback);
using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class addApiTokenByAdminIdExample
    {
        public void main()
        {
            
            // Configure API key authorization: LMv1
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new LMApi();
            var adminId = 56;  // Integer | 
            var body = new APIToken(); // APIToken | 

            try
            {
                // add api tokens for a user
                APIToken result = apiInstance.addApiTokenByAdminId(adminId, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.addApiTokenByAdminId: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: LMv1
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\LMApi();
$adminId = 56; // Integer | 
$body = ; // APIToken | 

try {
    $result = $api_instance->addApiTokenByAdminId($adminId, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->addApiTokenByAdminId: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LMApi;

# Configure API key authorization: LMv1
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::LMApi->new();
my $adminId = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::APIToken->new(); # APIToken | 

eval { 
    my $result = $api_instance->addApiTokenByAdminId(adminId => $adminId, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->addApiTokenByAdminId: $@\n";
}
from __future__ import print_function
import time
import logicmonitor_sdk
from logicmonitor_sdk.rest import ApiException
from pprint import pprint


# Configure API key authorization: LMv1
configuration = logicmonitor_sdk.Configuration()
configuration.company = 'YOUR_COMPANY'
configuration.access_id = 'YOUR_ACCESS_ID'
configuration.access_key = 'YOUR_ACCESS_KEY'

# create an instance of the API class
api_instance = logicmonitor_sdk.LMApi(logicmonitor_sdk.ApiClient(configuration))
adminId = 56 # Integer | 
body =  # APIToken | 

try:
    # add api tokens for a user
    api_response = api_instance.add_api_token_by_admin_id(adminId, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->addApiTokenByAdminId: %s\n" % e)
package main

import (
    "fmt"
    "github.com/logicmonitor/lm-sdk-go/client"
    "github.com/logicmonitor/lm-sdk-go/client/lm"
)
func main() {
    // Configure API key authorization: LMv1
    domain := "YOUR_COMPANY.logicmonitor.com"
    accessID := "YOUR_ACCESS_ID"
    accessKey := "YOUR_ACCESS_KEY"

    config := client.NewConfig()
    config.SetAccountDomain(&domain)
    config.SetAccessID(&accessID)
    config.SetAccessKey(&accessKey)
    
    // create an instance of the API class
    client := client.New(config)
    params := lm.NewAddAPITokenByAdminIDParams()
    params.AdminID = 56 // Integer | 
    params.Body =  // APIToken | 

    // add api tokens for a user
    resp, err := client.LM.AddAPITokenByAdminID(params)
    if err != nil {
        fmt.Printf("Exception when calling client.LM.AddAPITokenByAdminID: %v", err.Error())
    }
    fmt.Print(resp)
}

Parameters

Path parameters
Name Description
adminId*
Integer (int32)
Required
Body parameters
Name Description
body *

Responses

Status: 200 - successful operation

Status: default - Error


addCollector

add collector


/setting/collector/collectors

Usage and SDK Samples

curl -X POST -H "Authorization: [[apiKey]]" "https://localhost/santaba/rest/setting/collector/collectors"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LMApi;

import java.io.File;
import java.util.*;

public class LMApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: LMv1
        ApiKeyAuth LMv1 = (ApiKeyAuth) defaultClient.getAuthentication("LMv1");
        LMv1.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //LMv1.setApiKeyPrefix("Token");

        LMApi apiInstance = new LMApi();
        Collector body = ; // Collector | 
        try {
            Collector result = apiInstance.addCollector(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addCollector");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        Collector body = ; // Collector | 
        try {
            Collector result = apiInstance.addCollector(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addCollector");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: LMv1)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

Collector *body = ; // 

LMApi *apiInstance = [[LMApi alloc] init];

// add collector
[apiInstance addCollectorWith:body
              completionHandler: ^(Collector output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LogicMonitorRestApi = require('logic_monitor_rest_api');
var defaultClient = LogicMonitorRestApi.ApiClient.instance;

// Configure API key authorization: LMv1
var LMv1 = defaultClient.authentications['LMv1'];
LMv1.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//LMv1.apiKeyPrefix['Authorization'] = "Token"

var api = new LogicMonitorRestApi.LMApi()

var body = ; // {Collector} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addCollector(body, callback);
using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class addCollectorExample
    {
        public void main()
        {
            
            // Configure API key authorization: LMv1
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new LMApi();
            var body = new Collector(); // Collector | 

            try
            {
                // add collector
                Collector result = apiInstance.addCollector(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.addCollector: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: LMv1
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\LMApi();
$body = ; // Collector | 

try {
    $result = $api_instance->addCollector($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->addCollector: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LMApi;

# Configure API key authorization: LMv1
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::LMApi->new();
my $body = WWW::SwaggerClient::Object::Collector->new(); # Collector | 

eval { 
    my $result = $api_instance->addCollector(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->addCollector: $@\n";
}
from __future__ import print_function
import time
import logicmonitor_sdk
from logicmonitor_sdk.rest import ApiException
from pprint import pprint


# Configure API key authorization: LMv1
configuration = logicmonitor_sdk.Configuration()
configuration.company = 'YOUR_COMPANY'
configuration.access_id = 'YOUR_ACCESS_ID'
configuration.access_key = 'YOUR_ACCESS_KEY'

# create an instance of the API class
api_instance = logicmonitor_sdk.LMApi(logicmonitor_sdk.ApiClient(configuration))
body =  # Collector | 

try:
    # add collector
    api_response = api_instance.add_collector(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->addCollector: %s\n" % e)
package main

import (
    "fmt"
    "github.com/logicmonitor/lm-sdk-go/client"
    "github.com/logicmonitor/lm-sdk-go/client/lm"
)
func main() {
    // Configure API key authorization: LMv1
    domain := "YOUR_COMPANY.logicmonitor.com"
    accessID := "YOUR_ACCESS_ID"
    accessKey := "YOUR_ACCESS_KEY"

    config := client.NewConfig()
    config.SetAccountDomain(&domain)
    config.SetAccessID(&accessID)
    config.SetAccessKey(&accessKey)
    
    // create an instance of the API class
    client := client.New(config)
    params := lm.NewAddCollectorParams()
    params.Body =  // Collector | 

    // add collector
    resp, err := client.LM.AddCollector(params)
    if err != nil {
        fmt.Printf("Exception when calling client.LM.AddCollector: %v", err.Error())
    }
    fmt.Print(resp)
}

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation

Status: default - Error


addCollectorGroup

add collector group


/setting/collector/groups

Usage and SDK Samples

curl -X POST -H "Authorization: [[apiKey]]" "https://localhost/santaba/rest/setting/collector/groups"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LMApi;

import java.io.File;
import java.util.*;

public class LMApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: LMv1
        ApiKeyAuth LMv1 = (ApiKeyAuth) defaultClient.getAuthentication("LMv1");
        LMv1.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //LMv1.setApiKeyPrefix("Token");

        LMApi apiInstance = new LMApi();
        CollectorGroup body = ; // CollectorGroup | 
        try {
            CollectorGroup result = apiInstance.addCollectorGroup(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addCollectorGroup");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        CollectorGroup body = ; // CollectorGroup | 
        try {
            CollectorGroup result = apiInstance.addCollectorGroup(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addCollectorGroup");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: LMv1)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

CollectorGroup *body = ; // 

LMApi *apiInstance = [[LMApi alloc] init];

// add collector group
[apiInstance addCollectorGroupWith:body
              completionHandler: ^(CollectorGroup output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LogicMonitorRestApi = require('logic_monitor_rest_api');
var defaultClient = LogicMonitorRestApi.ApiClient.instance;

// Configure API key authorization: LMv1
var LMv1 = defaultClient.authentications['LMv1'];
LMv1.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//LMv1.apiKeyPrefix['Authorization'] = "Token"

var api = new LogicMonitorRestApi.LMApi()

var body = ; // {CollectorGroup} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addCollectorGroup(body, callback);
using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class addCollectorGroupExample
    {
        public void main()
        {
            
            // Configure API key authorization: LMv1
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new LMApi();
            var body = new CollectorGroup(); // CollectorGroup | 

            try
            {
                // add collector group
                CollectorGroup result = apiInstance.addCollectorGroup(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.addCollectorGroup: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: LMv1
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\LMApi();
$body = ; // CollectorGroup | 

try {
    $result = $api_instance->addCollectorGroup($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->addCollectorGroup: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LMApi;

# Configure API key authorization: LMv1
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::LMApi->new();
my $body = WWW::SwaggerClient::Object::CollectorGroup->new(); # CollectorGroup | 

eval { 
    my $result = $api_instance->addCollectorGroup(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->addCollectorGroup: $@\n";
}
from __future__ import print_function
import time
import logicmonitor_sdk
from logicmonitor_sdk.rest import ApiException
from pprint import pprint


# Configure API key authorization: LMv1
configuration = logicmonitor_sdk.Configuration()
configuration.company = 'YOUR_COMPANY'
configuration.access_id = 'YOUR_ACCESS_ID'
configuration.access_key = 'YOUR_ACCESS_KEY'

# create an instance of the API class
api_instance = logicmonitor_sdk.LMApi(logicmonitor_sdk.ApiClient(configuration))
body =  # CollectorGroup | 

try:
    # add collector group
    api_response = api_instance.add_collector_group(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->addCollectorGroup: %s\n" % e)
package main

import (
    "fmt"
    "github.com/logicmonitor/lm-sdk-go/client"
    "github.com/logicmonitor/lm-sdk-go/client/lm"
)
func main() {
    // Configure API key authorization: LMv1
    domain := "YOUR_COMPANY.logicmonitor.com"
    accessID := "YOUR_ACCESS_ID"
    accessKey := "YOUR_ACCESS_KEY"

    config := client.NewConfig()
    config.SetAccountDomain(&domain)
    config.SetAccessID(&accessID)
    config.SetAccessKey(&accessKey)
    
    // create an instance of the API class
    client := client.New(config)
    params := lm.NewAddCollectorGroupParams()
    params.Body =  // CollectorGroup | 

    // add collector group
    resp, err := client.LM.AddCollectorGroup(params)
    if err != nil {
        fmt.Printf("Exception when calling client.LM.AddCollectorGroup: %v", err.Error())
    }
    fmt.Print(resp)
}

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation

Status: default - Error


addDashboard

add dashboard


/dashboard/dashboards

Usage and SDK Samples

curl -X POST -H "Authorization: [[apiKey]]" "https://localhost/santaba/rest/dashboard/dashboards"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LMApi;

import java.io.File;
import java.util.*;

public class LMApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: LMv1
        ApiKeyAuth LMv1 = (ApiKeyAuth) defaultClient.getAuthentication("LMv1");
        LMv1.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //LMv1.setApiKeyPrefix("Token");

        LMApi apiInstance = new LMApi();
        Dashboard body = ; // Dashboard | 
        try {
            Dashboard result = apiInstance.addDashboard(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addDashboard");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        Dashboard body = ; // Dashboard | 
        try {
            Dashboard result = apiInstance.addDashboard(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addDashboard");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: LMv1)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

Dashboard *body = ; // 

LMApi *apiInstance = [[LMApi alloc] init];

// add dashboard
[apiInstance addDashboardWith:body
              completionHandler: ^(Dashboard output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LogicMonitorRestApi = require('logic_monitor_rest_api');
var defaultClient = LogicMonitorRestApi.ApiClient.instance;

// Configure API key authorization: LMv1
var LMv1 = defaultClient.authentications['LMv1'];
LMv1.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//LMv1.apiKeyPrefix['Authorization'] = "Token"

var api = new LogicMonitorRestApi.LMApi()

var body = ; // {Dashboard} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addDashboard(body, callback);
using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class addDashboardExample
    {
        public void main()
        {
            
            // Configure API key authorization: LMv1
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new LMApi();
            var body = new Dashboard(); // Dashboard | 

            try
            {
                // add dashboard
                Dashboard result = apiInstance.addDashboard(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.addDashboard: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: LMv1
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\LMApi();
$body = ; // Dashboard | 

try {
    $result = $api_instance->addDashboard($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->addDashboard: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LMApi;

# Configure API key authorization: LMv1
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::LMApi->new();
my $body = WWW::SwaggerClient::Object::Dashboard->new(); # Dashboard | 

eval { 
    my $result = $api_instance->addDashboard(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->addDashboard: $@\n";
}
from __future__ import print_function
import time
import logicmonitor_sdk
from logicmonitor_sdk.rest import ApiException
from pprint import pprint


# Configure API key authorization: LMv1
configuration = logicmonitor_sdk.Configuration()
configuration.company = 'YOUR_COMPANY'
configuration.access_id = 'YOUR_ACCESS_ID'
configuration.access_key = 'YOUR_ACCESS_KEY'

# create an instance of the API class
api_instance = logicmonitor_sdk.LMApi(logicmonitor_sdk.ApiClient(configuration))
body =  # Dashboard | 

try:
    # add dashboard
    api_response = api_instance.add_dashboard(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->addDashboard: %s\n" % e)
package main

import (
    "fmt"
    "github.com/logicmonitor/lm-sdk-go/client"
    "github.com/logicmonitor/lm-sdk-go/client/lm"
)
func main() {
    // Configure API key authorization: LMv1
    domain := "YOUR_COMPANY.logicmonitor.com"
    accessID := "YOUR_ACCESS_ID"
    accessKey := "YOUR_ACCESS_KEY"

    config := client.NewConfig()
    config.SetAccountDomain(&domain)
    config.SetAccessID(&accessID)
    config.SetAccessKey(&accessKey)
    
    // create an instance of the API class
    client := client.New(config)
    params := lm.NewAddDashboardParams()
    params.Body =  // Dashboard | 

    // add dashboard
    resp, err := client.LM.AddDashboard(params)
    if err != nil {
        fmt.Printf("Exception when calling client.LM.AddDashboard: %v", err.Error())
    }
    fmt.Print(resp)
}

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation

Status: default - Error


addDashboardGroup

add dashboard group


/dashboard/groups

Usage and SDK Samples

curl -X POST -H "Authorization: [[apiKey]]" "https://localhost/santaba/rest/dashboard/groups"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LMApi;

import java.io.File;
import java.util.*;

public class LMApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: LMv1
        ApiKeyAuth LMv1 = (ApiKeyAuth) defaultClient.getAuthentication("LMv1");
        LMv1.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //LMv1.setApiKeyPrefix("Token");

        LMApi apiInstance = new LMApi();
        DashboardGroup body = ; // DashboardGroup | 
        try {
            DashboardGroup result = apiInstance.addDashboardGroup(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addDashboardGroup");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        DashboardGroup body = ; // DashboardGroup | 
        try {
            DashboardGroup result = apiInstance.addDashboardGroup(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addDashboardGroup");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: LMv1)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

DashboardGroup *body = ; // 

LMApi *apiInstance = [[LMApi alloc] init];

// add dashboard group
[apiInstance addDashboardGroupWith:body
              completionHandler: ^(DashboardGroup output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LogicMonitorRestApi = require('logic_monitor_rest_api');
var defaultClient = LogicMonitorRestApi.ApiClient.instance;

// Configure API key authorization: LMv1
var LMv1 = defaultClient.authentications['LMv1'];
LMv1.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//LMv1.apiKeyPrefix['Authorization'] = "Token"

var api = new LogicMonitorRestApi.LMApi()

var body = ; // {DashboardGroup} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addDashboardGroup(body, callback);
using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class addDashboardGroupExample
    {
        public void main()
        {
            
            // Configure API key authorization: LMv1
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new LMApi();
            var body = new DashboardGroup(); // DashboardGroup | 

            try
            {
                // add dashboard group
                DashboardGroup result = apiInstance.addDashboardGroup(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.addDashboardGroup: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: LMv1
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\LMApi();
$body = ; // DashboardGroup | 

try {
    $result = $api_instance->addDashboardGroup($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->addDashboardGroup: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LMApi;

# Configure API key authorization: LMv1
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::LMApi->new();
my $body = WWW::SwaggerClient::Object::DashboardGroup->new(); # DashboardGroup | 

eval { 
    my $result = $api_instance->addDashboardGroup(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->addDashboardGroup: $@\n";
}
from __future__ import print_function
import time
import logicmonitor_sdk
from logicmonitor_sdk.rest import ApiException
from pprint import pprint


# Configure API key authorization: LMv1
configuration = logicmonitor_sdk.Configuration()
configuration.company = 'YOUR_COMPANY'
configuration.access_id = 'YOUR_ACCESS_ID'
configuration.access_key = 'YOUR_ACCESS_KEY'

# create an instance of the API class
api_instance = logicmonitor_sdk.LMApi(logicmonitor_sdk.ApiClient(configuration))
body =  # DashboardGroup | 

try:
    # add dashboard group
    api_response = api_instance.add_dashboard_group(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->addDashboardGroup: %s\n" % e)
package main

import (
    "fmt"
    "github.com/logicmonitor/lm-sdk-go/client"
    "github.com/logicmonitor/lm-sdk-go/client/lm"
)
func main() {
    // Configure API key authorization: LMv1
    domain := "YOUR_COMPANY.logicmonitor.com"
    accessID := "YOUR_ACCESS_ID"
    accessKey := "YOUR_ACCESS_KEY"

    config := client.NewConfig()
    config.SetAccountDomain(&domain)
    config.SetAccessID(&accessID)
    config.SetAccessKey(&accessKey)
    
    // create an instance of the API class
    client := client.New(config)
    params := lm.NewAddDashboardGroupParams()
    params.Body =  // DashboardGroup | 

    // add dashboard group
    resp, err := client.LM.AddDashboardGroup(params)
    if err != nil {
        fmt.Printf("Exception when calling client.LM.AddDashboardGroup: %v", err.Error())
    }
    fmt.Print(resp)
}

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation

Status: default - Error


addDevice

add a new device


/device/devices

Usage and SDK Samples

curl -X POST -H "Authorization: [[apiKey]]" "https://localhost/santaba/rest/device/devices?start=&end=&netflowFilter=&addFromWizard="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LMApi;

import java.io.File;
import java.util.*;

public class LMApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: LMv1
        ApiKeyAuth LMv1 = (ApiKeyAuth) defaultClient.getAuthentication("LMv1");
        LMv1.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //LMv1.setApiKeyPrefix("Token");

        LMApi apiInstance = new LMApi();
        Device body = ; // Device | 
        Long start = 789; // Long | 
        Long end = 789; // Long | 
        String netflowFilter = netflowFilter_example; // String | 
        Boolean addFromWizard = true; // Boolean | 
        try {
            Device result = apiInstance.addDevice(body, start, end, netflowFilter, addFromWizard);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addDevice");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        Device body = ; // Device | 
        Long start = 789; // Long | 
        Long end = 789; // Long | 
        String netflowFilter = netflowFilter_example; // String | 
        Boolean addFromWizard = true; // Boolean | 
        try {
            Device result = apiInstance.addDevice(body, start, end, netflowFilter, addFromWizard);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addDevice");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: LMv1)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

Device *body = ; // 
Long *start = 789; //  (optional)
Long *end = 789; //  (optional)
String *netflowFilter = netflowFilter_example; //  (optional)
Boolean *addFromWizard = true; //  (optional) (default to false)

LMApi *apiInstance = [[LMApi alloc] init];

// add a new device
[apiInstance addDeviceWith:body
    start:start
    end:end
    netflowFilter:netflowFilter
    addFromWizard:addFromWizard
              completionHandler: ^(Device output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LogicMonitorRestApi = require('logic_monitor_rest_api');
var defaultClient = LogicMonitorRestApi.ApiClient.instance;

// Configure API key authorization: LMv1
var LMv1 = defaultClient.authentications['LMv1'];
LMv1.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//LMv1.apiKeyPrefix['Authorization'] = "Token"

var api = new LogicMonitorRestApi.LMApi()

var body = ; // {Device} 

var opts = { 
  'start': 789, // {Long} 
  'end': 789, // {Long} 
  'netflowFilter': netflowFilter_example, // {String} 
  'addFromWizard': true // {Boolean} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addDevice(body, opts, callback);
using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class addDeviceExample
    {
        public void main()
        {
            
            // Configure API key authorization: LMv1
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new LMApi();
            var body = new Device(); // Device | 
            var start = 789;  // Long |  (optional) 
            var end = 789;  // Long |  (optional) 
            var netflowFilter = netflowFilter_example;  // String |  (optional) 
            var addFromWizard = true;  // Boolean |  (optional)  (default to false)

            try
            {
                // add a new device
                Device result = apiInstance.addDevice(body, start, end, netflowFilter, addFromWizard);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.addDevice: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: LMv1
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\LMApi();
$body = ; // Device | 
$start = 789; // Long | 
$end = 789; // Long | 
$netflowFilter = netflowFilter_example; // String | 
$addFromWizard = true; // Boolean | 

try {
    $result = $api_instance->addDevice($body, $start, $end, $netflowFilter, $addFromWizard);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->addDevice: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LMApi;

# Configure API key authorization: LMv1
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::LMApi->new();
my $body = WWW::SwaggerClient::Object::Device->new(); # Device | 
my $start = 789; # Long | 
my $end = 789; # Long | 
my $netflowFilter = netflowFilter_example; # String | 
my $addFromWizard = true; # Boolean | 

eval { 
    my $result = $api_instance->addDevice(body => $body, start => $start, end => $end, netflowFilter => $netflowFilter, addFromWizard => $addFromWizard);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->addDevice: $@\n";
}
from __future__ import print_function
import time
import logicmonitor_sdk
from logicmonitor_sdk.rest import ApiException
from pprint import pprint


# Configure API key authorization: LMv1
configuration = logicmonitor_sdk.Configuration()
configuration.company = 'YOUR_COMPANY'
configuration.access_id = 'YOUR_ACCESS_ID'
configuration.access_key = 'YOUR_ACCESS_KEY'

# create an instance of the API class
api_instance = logicmonitor_sdk.LMApi(logicmonitor_sdk.ApiClient(configuration))
body =  # Device | 
start = 789 # Long |  (optional)
end = 789 # Long |  (optional)
netflowFilter = netflowFilter_example # String |  (optional)
addFromWizard = true # Boolean |  (optional) (default to false)

try:
    # add a new device
    api_response = api_instance.add_device(body, start=start, end=end, netflowFilter=netflowFilter, addFromWizard=addFromWizard)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->addDevice: %s\n" % e)
package main

import (
    "fmt"
    "github.com/logicmonitor/lm-sdk-go/client"
    "github.com/logicmonitor/lm-sdk-go/client/lm"
)
func main() {
    // Configure API key authorization: LMv1
    domain := "YOUR_COMPANY.logicmonitor.com"
    accessID := "YOUR_ACCESS_ID"
    accessKey := "YOUR_ACCESS_KEY"

    config := client.NewConfig()
    config.SetAccountDomain(&domain)
    config.SetAccessID(&accessID)
    config.SetAccessKey(&accessKey)
    
    // create an instance of the API class
    client := client.New(config)
    params := lm.NewAddDeviceParams()
    params.Body =  // Device | 
    params.Start = 789 // Long |  (optional)
    params.End = 789 // Long |  (optional)
    params.NetflowFilter = netflowFilter_example // String |  (optional)
    params.AddFromWizard = true // Boolean |  (optional) (default to false)

    // add a new device
    resp, err := client.LM.AddDevice(params)
    if err != nil {
        fmt.Printf("Exception when calling client.LM.AddDevice: %v", err.Error())
    }
    fmt.Print(resp)
}

Parameters

Body parameters
Name Description
body *
Query parameters
Name Description
start
Long (int64)
end
Long (int64)
netflowFilter
String
addFromWizard
Boolean

Responses

Status: 200 - successful operation

Status: default - Error


addDeviceDatasourceInstance

add device instance


/device/devices/{deviceId}/devicedatasources/{hdsId}/instances

Usage and SDK Samples

curl -X POST -H "Authorization: [[apiKey]]" "https://localhost/santaba/rest/device/devices/{deviceId}/devicedatasources/{hdsId}/instances"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LMApi;

import java.io.File;
import java.util.*;

public class LMApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: LMv1
        ApiKeyAuth LMv1 = (ApiKeyAuth) defaultClient.getAuthentication("LMv1");
        LMv1.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //LMv1.setApiKeyPrefix("Token");

        LMApi apiInstance = new LMApi();
        Integer deviceId = 56; // Integer | 
        Integer hdsId = 56; // Integer | The device-datasource ID
        DeviceDataSourceInstance body = ; // DeviceDataSourceInstance | 
        try {
            DeviceDataSourceInstance result = apiInstance.addDeviceDatasourceInstance(deviceId, hdsId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addDeviceDatasourceInstance");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        Integer deviceId = 56; // Integer | 
        Integer hdsId = 56; // Integer | The device-datasource ID
        DeviceDataSourceInstance body = ; // DeviceDataSourceInstance | 
        try {
            DeviceDataSourceInstance result = apiInstance.addDeviceDatasourceInstance(deviceId, hdsId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addDeviceDatasourceInstance");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: LMv1)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

Integer *deviceId = 56; // 
Integer *hdsId = 56; // The device-datasource ID
DeviceDataSourceInstance *body = ; // 

LMApi *apiInstance = [[LMApi alloc] init];

// add device instance 
[apiInstance addDeviceDatasourceInstanceWith:deviceId
    hdsId:hdsId
    body:body
              completionHandler: ^(DeviceDataSourceInstance output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LogicMonitorRestApi = require('logic_monitor_rest_api');
var defaultClient = LogicMonitorRestApi.ApiClient.instance;

// Configure API key authorization: LMv1
var LMv1 = defaultClient.authentications['LMv1'];
LMv1.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//LMv1.apiKeyPrefix['Authorization'] = "Token"

var api = new LogicMonitorRestApi.LMApi()

var deviceId = 56; // {Integer} 

var hdsId = 56; // {Integer} The device-datasource ID

var body = ; // {DeviceDataSourceInstance} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addDeviceDatasourceInstance(deviceId, hdsId, body, callback);
using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class addDeviceDatasourceInstanceExample
    {
        public void main()
        {
            
            // Configure API key authorization: LMv1
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new LMApi();
            var deviceId = 56;  // Integer | 
            var hdsId = 56;  // Integer | The device-datasource ID
            var body = new DeviceDataSourceInstance(); // DeviceDataSourceInstance | 

            try
            {
                // add device instance 
                DeviceDataSourceInstance result = apiInstance.addDeviceDatasourceInstance(deviceId, hdsId, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.addDeviceDatasourceInstance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: LMv1
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\LMApi();
$deviceId = 56; // Integer | 
$hdsId = 56; // Integer | The device-datasource ID
$body = ; // DeviceDataSourceInstance | 

try {
    $result = $api_instance->addDeviceDatasourceInstance($deviceId, $hdsId, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->addDeviceDatasourceInstance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LMApi;

# Configure API key authorization: LMv1
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::LMApi->new();
my $deviceId = 56; # Integer | 
my $hdsId = 56; # Integer | The device-datasource ID
my $body = WWW::SwaggerClient::Object::DeviceDataSourceInstance->new(); # DeviceDataSourceInstance | 

eval { 
    my $result = $api_instance->addDeviceDatasourceInstance(deviceId => $deviceId, hdsId => $hdsId, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->addDeviceDatasourceInstance: $@\n";
}
from __future__ import print_function
import time
import logicmonitor_sdk
from logicmonitor_sdk.rest import ApiException
from pprint import pprint


# Configure API key authorization: LMv1
configuration = logicmonitor_sdk.Configuration()
configuration.company = 'YOUR_COMPANY'
configuration.access_id = 'YOUR_ACCESS_ID'
configuration.access_key = 'YOUR_ACCESS_KEY'

# create an instance of the API class
api_instance = logicmonitor_sdk.LMApi(logicmonitor_sdk.ApiClient(configuration))
deviceId = 56 # Integer | 
hdsId = 56 # Integer | The device-datasource ID
body =  # DeviceDataSourceInstance | 

try:
    # add device instance 
    api_response = api_instance.add_device_datasource_instance(deviceId, hdsId, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->addDeviceDatasourceInstance: %s\n" % e)
package main

import (
    "fmt"
    "github.com/logicmonitor/lm-sdk-go/client"
    "github.com/logicmonitor/lm-sdk-go/client/lm"
)
func main() {
    // Configure API key authorization: LMv1
    domain := "YOUR_COMPANY.logicmonitor.com"
    accessID := "YOUR_ACCESS_ID"
    accessKey := "YOUR_ACCESS_KEY"

    config := client.NewConfig()
    config.SetAccountDomain(&domain)
    config.SetAccessID(&accessID)
    config.SetAccessKey(&accessKey)
    
    // create an instance of the API class
    client := client.New(config)
    params := lm.NewAddDeviceDatasourceInstanceParams()
    params.DeviceID = 56 // Integer | 
    params.HdsID = 56 // Integer | The device-datasource ID
    params.Body =  // DeviceDataSourceInstance | 

    // add device instance 
    resp, err := client.LM.AddDeviceDatasourceInstance(params)
    if err != nil {
        fmt.Printf("Exception when calling client.LM.AddDeviceDatasourceInstance: %v", err.Error())
    }
    fmt.Print(resp)
}

Parameters

Path parameters
Name Description
deviceId*
Integer (int32)
Required
hdsId*
Integer (int32)
The device-datasource ID
Required
Body parameters
Name Description
body *

Responses

Status: 200 - successful operation

Status: default - Error


addDeviceDatasourceInstanceGroup

add device datasource instance group


/device/devices/{deviceId}/devicedatasources/{deviceDsId}/groups

Usage and SDK Samples

curl -X POST -H "Authorization: [[apiKey]]" "https://localhost/santaba/rest/device/devices/{deviceId}/devicedatasources/{deviceDsId}/groups"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LMApi;

import java.io.File;
import java.util.*;

public class LMApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: LMv1
        ApiKeyAuth LMv1 = (ApiKeyAuth) defaultClient.getAuthentication("LMv1");
        LMv1.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //LMv1.setApiKeyPrefix("Token");

        LMApi apiInstance = new LMApi();
        Integer deviceId = 56; // Integer | 
        Integer deviceDsId = 56; // Integer | The device-datasource ID you'd like to add an instance group for
        DeviceDataSourceInstanceGroup body = ; // DeviceDataSourceInstanceGroup | 
        try {
            DeviceDataSourceInstanceGroup result = apiInstance.addDeviceDatasourceInstanceGroup(deviceId, deviceDsId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addDeviceDatasourceInstanceGroup");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        Integer deviceId = 56; // Integer | 
        Integer deviceDsId = 56; // Integer | The device-datasource ID you'd like to add an instance group for
        DeviceDataSourceInstanceGroup body = ; // DeviceDataSourceInstanceGroup | 
        try {
            DeviceDataSourceInstanceGroup result = apiInstance.addDeviceDatasourceInstanceGroup(deviceId, deviceDsId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addDeviceDatasourceInstanceGroup");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: LMv1)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

Integer *deviceId = 56; // 
Integer *deviceDsId = 56; // The device-datasource ID you'd like to add an instance group for
DeviceDataSourceInstanceGroup *body = ; // 

LMApi *apiInstance = [[LMApi alloc] init];

// add device datasource instance group 
[apiInstance addDeviceDatasourceInstanceGroupWith:deviceId
    deviceDsId:deviceDsId
    body:body
              completionHandler: ^(DeviceDataSourceInstanceGroup output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LogicMonitorRestApi = require('logic_monitor_rest_api');
var defaultClient = LogicMonitorRestApi.ApiClient.instance;

// Configure API key authorization: LMv1
var LMv1 = defaultClient.authentications['LMv1'];
LMv1.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//LMv1.apiKeyPrefix['Authorization'] = "Token"

var api = new LogicMonitorRestApi.LMApi()

var deviceId = 56; // {Integer} 

var deviceDsId = 56; // {Integer} The device-datasource ID you'd like to add an instance group for

var body = ; // {DeviceDataSourceInstanceGroup} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addDeviceDatasourceInstanceGroup(deviceId, deviceDsId, body, callback);
using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class addDeviceDatasourceInstanceGroupExample
    {
        public void main()
        {
            
            // Configure API key authorization: LMv1
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new LMApi();
            var deviceId = 56;  // Integer | 
            var deviceDsId = 56;  // Integer | The device-datasource ID you'd like to add an instance group for
            var body = new DeviceDataSourceInstanceGroup(); // DeviceDataSourceInstanceGroup | 

            try
            {
                // add device datasource instance group 
                DeviceDataSourceInstanceGroup result = apiInstance.addDeviceDatasourceInstanceGroup(deviceId, deviceDsId, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.addDeviceDatasourceInstanceGroup: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: LMv1
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\LMApi();
$deviceId = 56; // Integer | 
$deviceDsId = 56; // Integer | The device-datasource ID you'd like to add an instance group for
$body = ; // DeviceDataSourceInstanceGroup | 

try {
    $result = $api_instance->addDeviceDatasourceInstanceGroup($deviceId, $deviceDsId, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->addDeviceDatasourceInstanceGroup: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LMApi;

# Configure API key authorization: LMv1
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::LMApi->new();
my $deviceId = 56; # Integer | 
my $deviceDsId = 56; # Integer | The device-datasource ID you'd like to add an instance group for
my $body = WWW::SwaggerClient::Object::DeviceDataSourceInstanceGroup->new(); # DeviceDataSourceInstanceGroup | 

eval { 
    my $result = $api_instance->addDeviceDatasourceInstanceGroup(deviceId => $deviceId, deviceDsId => $deviceDsId, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->addDeviceDatasourceInstanceGroup: $@\n";
}
from __future__ import print_function
import time
import logicmonitor_sdk
from logicmonitor_sdk.rest import ApiException
from pprint import pprint


# Configure API key authorization: LMv1
configuration = logicmonitor_sdk.Configuration()
configuration.company = 'YOUR_COMPANY'
configuration.access_id = 'YOUR_ACCESS_ID'
configuration.access_key = 'YOUR_ACCESS_KEY'

# create an instance of the API class
api_instance = logicmonitor_sdk.LMApi(logicmonitor_sdk.ApiClient(configuration))
deviceId = 56 # Integer | 
deviceDsId = 56 # Integer | The device-datasource ID you'd like to add an instance group for
body =  # DeviceDataSourceInstanceGroup | 

try:
    # add device datasource instance group 
    api_response = api_instance.add_device_datasource_instance_group(deviceId, deviceDsId, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->addDeviceDatasourceInstanceGroup: %s\n" % e)
package main

import (
    "fmt"
    "github.com/logicmonitor/lm-sdk-go/client"
    "github.com/logicmonitor/lm-sdk-go/client/lm"
)
func main() {
    // Configure API key authorization: LMv1
    domain := "YOUR_COMPANY.logicmonitor.com"
    accessID := "YOUR_ACCESS_ID"
    accessKey := "YOUR_ACCESS_KEY"

    config := client.NewConfig()
    config.SetAccountDomain(&domain)
    config.SetAccessID(&accessID)
    config.SetAccessKey(&accessKey)
    
    // create an instance of the API class
    client := client.New(config)
    params := lm.NewAddDeviceDatasourceInstanceGroupParams()
    params.DeviceID = 56 // Integer | 
    params.DeviceDsID = 56 // Integer | The device-datasource ID you'd like to add an instance group for
    params.Body =  // DeviceDataSourceInstanceGroup | 

    // add device datasource instance group 
    resp, err := client.LM.AddDeviceDatasourceInstanceGroup(params)
    if err != nil {
        fmt.Printf("Exception when calling client.LM.AddDeviceDatasourceInstanceGroup: %v", err.Error())
    }
    fmt.Print(resp)
}

Parameters

Path parameters
Name Description
deviceId*
Integer (int32)
Required
deviceDsId*
Integer (int32)
The device-datasource ID you'd like to add an instance group for
Required
Body parameters
Name Description
body *

Responses

Status: 200 - successful operation

Status: default - Error


addDeviceGroup

add device group


/device/groups

Usage and SDK Samples

curl -X POST -H "Authorization: [[apiKey]]" "https://localhost/santaba/rest/device/groups"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LMApi;

import java.io.File;
import java.util.*;

public class LMApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: LMv1
        ApiKeyAuth LMv1 = (ApiKeyAuth) defaultClient.getAuthentication("LMv1");
        LMv1.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //LMv1.setApiKeyPrefix("Token");

        LMApi apiInstance = new LMApi();
        DeviceGroup body = ; // DeviceGroup | 
        try {
            DeviceGroup result = apiInstance.addDeviceGroup(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addDeviceGroup");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        DeviceGroup body = ; // DeviceGroup | 
        try {
            DeviceGroup result = apiInstance.addDeviceGroup(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addDeviceGroup");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: LMv1)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

DeviceGroup *body = ; // 

LMApi *apiInstance = [[LMApi alloc] init];

// add device group
[apiInstance addDeviceGroupWith:body
              completionHandler: ^(DeviceGroup output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LogicMonitorRestApi = require('logic_monitor_rest_api');
var defaultClient = LogicMonitorRestApi.ApiClient.instance;

// Configure API key authorization: LMv1
var LMv1 = defaultClient.authentications['LMv1'];
LMv1.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//LMv1.apiKeyPrefix['Authorization'] = "Token"

var api = new LogicMonitorRestApi.LMApi()

var body = ; // {DeviceGroup} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addDeviceGroup(body, callback);
using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class addDeviceGroupExample
    {
        public void main()
        {
            
            // Configure API key authorization: LMv1
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new LMApi();
            var body = new DeviceGroup(); // DeviceGroup | 

            try
            {
                // add device group
                DeviceGroup result = apiInstance.addDeviceGroup(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.addDeviceGroup: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: LMv1
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\LMApi();
$body = ; // DeviceGroup | 

try {
    $result = $api_instance->addDeviceGroup($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->addDeviceGroup: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LMApi;

# Configure API key authorization: LMv1
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::LMApi->new();
my $body = WWW::SwaggerClient::Object::DeviceGroup->new(); # DeviceGroup | 

eval { 
    my $result = $api_instance->addDeviceGroup(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->addDeviceGroup: $@\n";
}
from __future__ import print_function
import time
import logicmonitor_sdk
from logicmonitor_sdk.rest import ApiException
from pprint import pprint


# Configure API key authorization: LMv1
configuration = logicmonitor_sdk.Configuration()
configuration.company = 'YOUR_COMPANY'
configuration.access_id = 'YOUR_ACCESS_ID'
configuration.access_key = 'YOUR_ACCESS_KEY'

# create an instance of the API class
api_instance = logicmonitor_sdk.LMApi(logicmonitor_sdk.ApiClient(configuration))
body =  # DeviceGroup | 

try:
    # add device group
    api_response = api_instance.add_device_group(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->addDeviceGroup: %s\n" % e)
package main

import (
    "fmt"
    "github.com/logicmonitor/lm-sdk-go/client"
    "github.com/logicmonitor/lm-sdk-go/client/lm"
)
func main() {
    // Configure API key authorization: LMv1
    domain := "YOUR_COMPANY.logicmonitor.com"
    accessID := "YOUR_ACCESS_ID"
    accessKey := "YOUR_ACCESS_KEY"

    config := client.NewConfig()
    config.SetAccountDomain(&domain)
    config.SetAccessID(&accessID)
    config.SetAccessKey(&accessKey)
    
    // create an instance of the API class
    client := client.New(config)
    params := lm.NewAddDeviceGroupParams()
    params.Body =  // DeviceGroup | 

    // add device group
    resp, err := client.LM.AddDeviceGroup(params)
    if err != nil {
        fmt.Printf("Exception when calling client.LM.AddDeviceGroup: %v", err.Error())
    }
    fmt.Print(resp)
}

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation

Status: default - Error


addDeviceGroupClusterAlertConf

Add cluster alert configuration


/device/groups/{deviceGroupId}/clusterAlertConf

Usage and SDK Samples

curl -X POST -H "Authorization: [[apiKey]]" "https://localhost/santaba/rest/device/groups/{deviceGroupId}/clusterAlertConf"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LMApi;

import java.io.File;
import java.util.*;

public class LMApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: LMv1
        ApiKeyAuth LMv1 = (ApiKeyAuth) defaultClient.getAuthentication("LMv1");
        LMv1.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //LMv1.setApiKeyPrefix("Token");

        LMApi apiInstance = new LMApi();
        Integer deviceGroupId = 56; // Integer | 
        DeviceClusterAlertConfig body = ; // DeviceClusterAlertConfig | 
        try {
            DeviceClusterAlertConfig result = apiInstance.addDeviceGroupClusterAlertConf(deviceGroupId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addDeviceGroupClusterAlertConf");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        Integer deviceGroupId = 56; // Integer | 
        DeviceClusterAlertConfig body = ; // DeviceClusterAlertConfig | 
        try {
            DeviceClusterAlertConfig result = apiInstance.addDeviceGroupClusterAlertConf(deviceGroupId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addDeviceGroupClusterAlertConf");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: LMv1)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

Integer *deviceGroupId = 56; // 
DeviceClusterAlertConfig *body = ; // 

LMApi *apiInstance = [[LMApi alloc] init];

// Add cluster alert configuration
[apiInstance addDeviceGroupClusterAlertConfWith:deviceGroupId
    body:body
              completionHandler: ^(DeviceClusterAlertConfig output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LogicMonitorRestApi = require('logic_monitor_rest_api');
var defaultClient = LogicMonitorRestApi.ApiClient.instance;

// Configure API key authorization: LMv1
var LMv1 = defaultClient.authentications['LMv1'];
LMv1.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//LMv1.apiKeyPrefix['Authorization'] = "Token"

var api = new LogicMonitorRestApi.LMApi()

var deviceGroupId = 56; // {Integer} 

var body = ; // {DeviceClusterAlertConfig} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addDeviceGroupClusterAlertConf(deviceGroupId, body, callback);
using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class addDeviceGroupClusterAlertConfExample
    {
        public void main()
        {
            
            // Configure API key authorization: LMv1
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new LMApi();
            var deviceGroupId = 56;  // Integer | 
            var body = new DeviceClusterAlertConfig(); // DeviceClusterAlertConfig | 

            try
            {
                // Add cluster alert configuration
                DeviceClusterAlertConfig result = apiInstance.addDeviceGroupClusterAlertConf(deviceGroupId, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.addDeviceGroupClusterAlertConf: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: LMv1
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\LMApi();
$deviceGroupId = 56; // Integer | 
$body = ; // DeviceClusterAlertConfig | 

try {
    $result = $api_instance->addDeviceGroupClusterAlertConf($deviceGroupId, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->addDeviceGroupClusterAlertConf: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LMApi;

# Configure API key authorization: LMv1
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::LMApi->new();
my $deviceGroupId = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::DeviceClusterAlertConfig->new(); # DeviceClusterAlertConfig | 

eval { 
    my $result = $api_instance->addDeviceGroupClusterAlertConf(deviceGroupId => $deviceGroupId, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->addDeviceGroupClusterAlertConf: $@\n";
}
from __future__ import print_function
import time
import logicmonitor_sdk
from logicmonitor_sdk.rest import ApiException
from pprint import pprint


# Configure API key authorization: LMv1
configuration = logicmonitor_sdk.Configuration()
configuration.company = 'YOUR_COMPANY'
configuration.access_id = 'YOUR_ACCESS_ID'
configuration.access_key = 'YOUR_ACCESS_KEY'

# create an instance of the API class
api_instance = logicmonitor_sdk.LMApi(logicmonitor_sdk.ApiClient(configuration))
deviceGroupId = 56 # Integer | 
body =  # DeviceClusterAlertConfig | 

try:
    # Add cluster alert configuration
    api_response = api_instance.add_device_group_cluster_alert_conf(deviceGroupId, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->addDeviceGroupClusterAlertConf: %s\n" % e)
package main

import (
    "fmt"
    "github.com/logicmonitor/lm-sdk-go/client"
    "github.com/logicmonitor/lm-sdk-go/client/lm"
)
func main() {
    // Configure API key authorization: LMv1
    domain := "YOUR_COMPANY.logicmonitor.com"
    accessID := "YOUR_ACCESS_ID"
    accessKey := "YOUR_ACCESS_KEY"

    config := client.NewConfig()
    config.SetAccountDomain(&domain)
    config.SetAccessID(&accessID)
    config.SetAccessKey(&accessKey)
    
    // create an instance of the API class
    client := client.New(config)
    params := lm.NewAddDeviceGroupClusterAlertConfParams()
    params.DeviceGroupID = 56 // Integer | 
    params.Body =  // DeviceClusterAlertConfig | 

    // Add cluster alert configuration
    resp, err := client.LM.AddDeviceGroupClusterAlertConf(params)
    if err != nil {
        fmt.Printf("Exception when calling client.LM.AddDeviceGroupClusterAlertConf: %v", err.Error())
    }
    fmt.Print(resp)
}

Parameters

Path parameters
Name Description
deviceGroupId*
Integer (int32)
Required
Body parameters
Name Description
body *

Responses

Status: 200 - successful operation

Status: default - Error


addDeviceGroupProperty

add device group property


/device/groups/{gid}/properties

Usage and SDK Samples

curl -X POST -H "Authorization: [[apiKey]]" "https://localhost/santaba/rest/device/groups/{gid}/properties"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LMApi;

import java.io.File;
import java.util.*;

public class LMApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: LMv1
        ApiKeyAuth LMv1 = (ApiKeyAuth) defaultClient.getAuthentication("LMv1");
        LMv1.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //LMv1.setApiKeyPrefix("Token");

        LMApi apiInstance = new LMApi();
        Integer gid = 56; // Integer | group ID
        EntityProperty body = ; // EntityProperty | 
        try {
            EntityProperty result = apiInstance.addDeviceGroupProperty(gid, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addDeviceGroupProperty");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        Integer gid = 56; // Integer | group ID
        EntityProperty body = ; // EntityProperty | 
        try {
            EntityProperty result = apiInstance.addDeviceGroupProperty(gid, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addDeviceGroupProperty");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: LMv1)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

Integer *gid = 56; // group ID
EntityProperty *body = ; // 

LMApi *apiInstance = [[LMApi alloc] init];

// add device group property
[apiInstance addDeviceGroupPropertyWith:gid
    body:body
              completionHandler: ^(EntityProperty output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LogicMonitorRestApi = require('logic_monitor_rest_api');
var defaultClient = LogicMonitorRestApi.ApiClient.instance;

// Configure API key authorization: LMv1
var LMv1 = defaultClient.authentications['LMv1'];
LMv1.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//LMv1.apiKeyPrefix['Authorization'] = "Token"

var api = new LogicMonitorRestApi.LMApi()

var gid = 56; // {Integer} group ID

var body = ; // {EntityProperty} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addDeviceGroupProperty(gid, body, callback);
using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class addDeviceGroupPropertyExample
    {
        public void main()
        {
            
            // Configure API key authorization: LMv1
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new LMApi();
            var gid = 56;  // Integer | group ID
            var body = new EntityProperty(); // EntityProperty | 

            try
            {
                // add device group property
                EntityProperty result = apiInstance.addDeviceGroupProperty(gid, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.addDeviceGroupProperty: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: LMv1
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\LMApi();
$gid = 56; // Integer | group ID
$body = ; // EntityProperty | 

try {
    $result = $api_instance->addDeviceGroupProperty($gid, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->addDeviceGroupProperty: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LMApi;

# Configure API key authorization: LMv1
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::LMApi->new();
my $gid = 56; # Integer | group ID
my $body = WWW::SwaggerClient::Object::EntityProperty->new(); # EntityProperty | 

eval { 
    my $result = $api_instance->addDeviceGroupProperty(gid => $gid, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->addDeviceGroupProperty: $@\n";
}
from __future__ import print_function
import time
import logicmonitor_sdk
from logicmonitor_sdk.rest import ApiException
from pprint import pprint


# Configure API key authorization: LMv1
configuration = logicmonitor_sdk.Configuration()
configuration.company = 'YOUR_COMPANY'
configuration.access_id = 'YOUR_ACCESS_ID'
configuration.access_key = 'YOUR_ACCESS_KEY'

# create an instance of the API class
api_instance = logicmonitor_sdk.LMApi(logicmonitor_sdk.ApiClient(configuration))
gid = 56 # Integer | group ID
body =  # EntityProperty | 

try:
    # add device group property
    api_response = api_instance.add_device_group_property(gid, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->addDeviceGroupProperty: %s\n" % e)
package main

import (
    "fmt"
    "github.com/logicmonitor/lm-sdk-go/client"
    "github.com/logicmonitor/lm-sdk-go/client/lm"
)
func main() {
    // Configure API key authorization: LMv1
    domain := "YOUR_COMPANY.logicmonitor.com"
    accessID := "YOUR_ACCESS_ID"
    accessKey := "YOUR_ACCESS_KEY"

    config := client.NewConfig()
    config.SetAccountDomain(&domain)
    config.SetAccessID(&accessID)
    config.SetAccessKey(&accessKey)
    
    // create an instance of the API class
    client := client.New(config)
    params := lm.NewAddDeviceGroupPropertyParams()
    params.Gid = 56 // Integer | group ID
    params.Body =  // EntityProperty | 

    // add device group property
    resp, err := client.LM.AddDeviceGroupProperty(params)
    if err != nil {
        fmt.Printf("Exception when calling client.LM.AddDeviceGroupProperty: %v", err.Error())
    }
    fmt.Print(resp)
}

Parameters

Path parameters
Name Description
gid*
Integer (int32)
group ID
Required
Body parameters
Name Description
body *

Responses

Status: 200 - successful operation

Status: default - Error


addDeviceProperty

add device property


/device/devices/{deviceId}/properties

Usage and SDK Samples

curl -X POST -H "Authorization: [[apiKey]]" "https://localhost/santaba/rest/device/devices/{deviceId}/properties"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LMApi;

import java.io.File;
import java.util.*;

public class LMApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: LMv1
        ApiKeyAuth LMv1 = (ApiKeyAuth) defaultClient.getAuthentication("LMv1");
        LMv1.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //LMv1.setApiKeyPrefix("Token");

        LMApi apiInstance = new LMApi();
        Integer deviceId = 56; // Integer | 
        EntityProperty body = ; // EntityProperty | 
        try {
            EntityProperty result = apiInstance.addDeviceProperty(deviceId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addDeviceProperty");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        Integer deviceId = 56; // Integer | 
        EntityProperty body = ; // EntityProperty | 
        try {
            EntityProperty result = apiInstance.addDeviceProperty(deviceId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addDeviceProperty");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: LMv1)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

Integer *deviceId = 56; // 
EntityProperty *body = ; // 

LMApi *apiInstance = [[LMApi alloc] init];

// add device property
[apiInstance addDevicePropertyWith:deviceId
    body:body
              completionHandler: ^(EntityProperty output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LogicMonitorRestApi = require('logic_monitor_rest_api');
var defaultClient = LogicMonitorRestApi.ApiClient.instance;

// Configure API key authorization: LMv1
var LMv1 = defaultClient.authentications['LMv1'];
LMv1.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//LMv1.apiKeyPrefix['Authorization'] = "Token"

var api = new LogicMonitorRestApi.LMApi()

var deviceId = 56; // {Integer} 

var body = ; // {EntityProperty} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addDeviceProperty(deviceId, body, callback);
using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class addDevicePropertyExample
    {
        public void main()
        {
            
            // Configure API key authorization: LMv1
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new LMApi();
            var deviceId = 56;  // Integer | 
            var body = new EntityProperty(); // EntityProperty | 

            try
            {
                // add device property
                EntityProperty result = apiInstance.addDeviceProperty(deviceId, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.addDeviceProperty: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: LMv1
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\LMApi();
$deviceId = 56; // Integer | 
$body = ; // EntityProperty | 

try {
    $result = $api_instance->addDeviceProperty($deviceId, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->addDeviceProperty: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LMApi;

# Configure API key authorization: LMv1
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::LMApi->new();
my $deviceId = 56; # Integer | 
my $body = WWW::SwaggerClient::Object::EntityProperty->new(); # EntityProperty | 

eval { 
    my $result = $api_instance->addDeviceProperty(deviceId => $deviceId, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->addDeviceProperty: $@\n";
}
from __future__ import print_function
import time
import logicmonitor_sdk
from logicmonitor_sdk.rest import ApiException
from pprint import pprint


# Configure API key authorization: LMv1
configuration = logicmonitor_sdk.Configuration()
configuration.company = 'YOUR_COMPANY'
configuration.access_id = 'YOUR_ACCESS_ID'
configuration.access_key = 'YOUR_ACCESS_KEY'

# create an instance of the API class
api_instance = logicmonitor_sdk.LMApi(logicmonitor_sdk.ApiClient(configuration))
deviceId = 56 # Integer | 
body =  # EntityProperty | 

try:
    # add device property
    api_response = api_instance.add_device_property(deviceId, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->addDeviceProperty: %s\n" % e)
package main

import (
    "fmt"
    "github.com/logicmonitor/lm-sdk-go/client"
    "github.com/logicmonitor/lm-sdk-go/client/lm"
)
func main() {
    // Configure API key authorization: LMv1
    domain := "YOUR_COMPANY.logicmonitor.com"
    accessID := "YOUR_ACCESS_ID"
    accessKey := "YOUR_ACCESS_KEY"

    config := client.NewConfig()
    config.SetAccountDomain(&domain)
    config.SetAccessID(&accessID)
    config.SetAccessKey(&accessKey)
    
    // create an instance of the API class
    client := client.New(config)
    params := lm.NewAddDevicePropertyParams()
    params.DeviceID = 56 // Integer | 
    params.Body =  // EntityProperty | 

    // add device property
    resp, err := client.LM.AddDeviceProperty(params)
    if err != nil {
        fmt.Printf("Exception when calling client.LM.AddDeviceProperty: %v", err.Error())
    }
    fmt.Print(resp)
}

Parameters

Path parameters
Name Description
deviceId*
Integer (int32)
Required
Body parameters
Name Description
body *

Responses

Status: 200 - successful operation

Status: default - Error


addEscalationChain

add escalation chain


/setting/alert/chains

Usage and SDK Samples

curl -X POST -H "Authorization: [[apiKey]]" "https://localhost/santaba/rest/setting/alert/chains"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LMApi;

import java.io.File;
import java.util.*;

public class LMApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: LMv1
        ApiKeyAuth LMv1 = (ApiKeyAuth) defaultClient.getAuthentication("LMv1");
        LMv1.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //LMv1.setApiKeyPrefix("Token");

        LMApi apiInstance = new LMApi();
        EscalatingChain body = ; // EscalatingChain | 
        try {
            EscalatingChain result = apiInstance.addEscalationChain(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addEscalationChain");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        EscalatingChain body = ; // EscalatingChain | 
        try {
            EscalatingChain result = apiInstance.addEscalationChain(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addEscalationChain");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: LMv1)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

EscalatingChain *body = ; // 

LMApi *apiInstance = [[LMApi alloc] init];

// add escalation chain
[apiInstance addEscalationChainWith:body
              completionHandler: ^(EscalatingChain output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LogicMonitorRestApi = require('logic_monitor_rest_api');
var defaultClient = LogicMonitorRestApi.ApiClient.instance;

// Configure API key authorization: LMv1
var LMv1 = defaultClient.authentications['LMv1'];
LMv1.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//LMv1.apiKeyPrefix['Authorization'] = "Token"

var api = new LogicMonitorRestApi.LMApi()

var body = ; // {EscalatingChain} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addEscalationChain(body, callback);
using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class addEscalationChainExample
    {
        public void main()
        {
            
            // Configure API key authorization: LMv1
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new LMApi();
            var body = new EscalatingChain(); // EscalatingChain | 

            try
            {
                // add escalation chain
                EscalatingChain result = apiInstance.addEscalationChain(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.addEscalationChain: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: LMv1
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\LMApi();
$body = ; // EscalatingChain | 

try {
    $result = $api_instance->addEscalationChain($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->addEscalationChain: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LMApi;

# Configure API key authorization: LMv1
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::LMApi->new();
my $body = WWW::SwaggerClient::Object::EscalatingChain->new(); # EscalatingChain | 

eval { 
    my $result = $api_instance->addEscalationChain(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->addEscalationChain: $@\n";
}
from __future__ import print_function
import time
import logicmonitor_sdk
from logicmonitor_sdk.rest import ApiException
from pprint import pprint


# Configure API key authorization: LMv1
configuration = logicmonitor_sdk.Configuration()
configuration.company = 'YOUR_COMPANY'
configuration.access_id = 'YOUR_ACCESS_ID'
configuration.access_key = 'YOUR_ACCESS_KEY'

# create an instance of the API class
api_instance = logicmonitor_sdk.LMApi(logicmonitor_sdk.ApiClient(configuration))
body =  # EscalatingChain | 

try:
    # add escalation chain
    api_response = api_instance.add_escalation_chain(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->addEscalationChain: %s\n" % e)
package main

import (
    "fmt"
    "github.com/logicmonitor/lm-sdk-go/client"
    "github.com/logicmonitor/lm-sdk-go/client/lm"
)
func main() {
    // Configure API key authorization: LMv1
    domain := "YOUR_COMPANY.logicmonitor.com"
    accessID := "YOUR_ACCESS_ID"
    accessKey := "YOUR_ACCESS_KEY"

    config := client.NewConfig()
    config.SetAccountDomain(&domain)
    config.SetAccessID(&accessID)
    config.SetAccessKey(&accessKey)
    
    // create an instance of the API class
    client := client.New(config)
    params := lm.NewAddEscalationChainParams()
    params.Body =  // EscalatingChain | 

    // add escalation chain
    resp, err := client.LM.AddEscalationChain(params)
    if err != nil {
        fmt.Printf("Exception when calling client.LM.AddEscalationChain: %v", err.Error())
    }
    fmt.Print(resp)
}

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation

Status: default - Error


addNetscan

add a new netscan


/setting/netscans

Usage and SDK Samples

curl -X POST -H "Authorization: [[apiKey]]" "https://localhost/santaba/rest/setting/netscans"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LMApi;

import java.io.File;
import java.util.*;

public class LMApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: LMv1
        ApiKeyAuth LMv1 = (ApiKeyAuth) defaultClient.getAuthentication("LMv1");
        LMv1.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //LMv1.setApiKeyPrefix("Token");

        LMApi apiInstance = new LMApi();
        Netscan body = ; // Netscan | 
        try {
            Netscan result = apiInstance.addNetscan(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addNetscan");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        Netscan body = ; // Netscan | 
        try {
            Netscan result = apiInstance.addNetscan(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addNetscan");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: LMv1)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

Netscan *body = ; //  (optional)

LMApi *apiInstance = [[LMApi alloc] init];

// add a new netscan
[apiInstance addNetscanWith:body
              completionHandler: ^(Netscan output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LogicMonitorRestApi = require('logic_monitor_rest_api');
var defaultClient = LogicMonitorRestApi.ApiClient.instance;

// Configure API key authorization: LMv1
var LMv1 = defaultClient.authentications['LMv1'];
LMv1.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//LMv1.apiKeyPrefix['Authorization'] = "Token"

var api = new LogicMonitorRestApi.LMApi()

var opts = { 
  'body':  // {Netscan} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addNetscan(opts, callback);
using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class addNetscanExample
    {
        public void main()
        {
            
            // Configure API key authorization: LMv1
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new LMApi();
            var body = new Netscan(); // Netscan |  (optional) 

            try
            {
                // add a new netscan
                Netscan result = apiInstance.addNetscan(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.addNetscan: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: LMv1
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\LMApi();
$body = ; // Netscan | 

try {
    $result = $api_instance->addNetscan($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->addNetscan: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LMApi;

# Configure API key authorization: LMv1
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::LMApi->new();
my $body = WWW::SwaggerClient::Object::Netscan->new(); # Netscan | 

eval { 
    my $result = $api_instance->addNetscan(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->addNetscan: $@\n";
}
from __future__ import print_function
import time
import logicmonitor_sdk
from logicmonitor_sdk.rest import ApiException
from pprint import pprint


# Configure API key authorization: LMv1
configuration = logicmonitor_sdk.Configuration()
configuration.company = 'YOUR_COMPANY'
configuration.access_id = 'YOUR_ACCESS_ID'
configuration.access_key = 'YOUR_ACCESS_KEY'

# create an instance of the API class
api_instance = logicmonitor_sdk.LMApi(logicmonitor_sdk.ApiClient(configuration))
body =  # Netscan |  (optional)

try:
    # add a new netscan
    api_response = api_instance.add_netscan(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->addNetscan: %s\n" % e)
package main

import (
    "fmt"
    "github.com/logicmonitor/lm-sdk-go/client"
    "github.com/logicmonitor/lm-sdk-go/client/lm"
)
func main() {
    // Configure API key authorization: LMv1
    domain := "YOUR_COMPANY.logicmonitor.com"
    accessID := "YOUR_ACCESS_ID"
    accessKey := "YOUR_ACCESS_KEY"

    config := client.NewConfig()
    config.SetAccountDomain(&domain)
    config.SetAccessID(&accessID)
    config.SetAccessKey(&accessKey)
    
    // create an instance of the API class
    client := client.New(config)
    params := lm.NewAddNetscanParams()
    params.Body =  // Netscan |  (optional)

    // add a new netscan
    resp, err := client.LM.AddNetscan(params)
    if err != nil {
        fmt.Printf("Exception when calling client.LM.AddNetscan: %v", err.Error())
    }
    fmt.Print(resp)
}

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - successful operation

Status: default - Error


addOpsNote

add opsnote


/setting/opsnotes

Usage and SDK Samples

curl -X POST -H "Authorization: [[apiKey]]" "https://localhost/santaba/rest/setting/opsnotes"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LMApi;

import java.io.File;
import java.util.*;

public class LMApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: LMv1
        ApiKeyAuth LMv1 = (ApiKeyAuth) defaultClient.getAuthentication("LMv1");
        LMv1.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //LMv1.setApiKeyPrefix("Token");

        LMApi apiInstance = new LMApi();
        OpsNote body = ; // OpsNote | 
        try {
            OpsNote result = apiInstance.addOpsNote(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addOpsNote");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        OpsNote body = ; // OpsNote | 
        try {
            OpsNote result = apiInstance.addOpsNote(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addOpsNote");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: LMv1)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

OpsNote *body = ; // 

LMApi *apiInstance = [[LMApi alloc] init];

// add opsnote
[apiInstance addOpsNoteWith:body
              completionHandler: ^(OpsNote output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LogicMonitorRestApi = require('logic_monitor_rest_api');
var defaultClient = LogicMonitorRestApi.ApiClient.instance;

// Configure API key authorization: LMv1
var LMv1 = defaultClient.authentications['LMv1'];
LMv1.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//LMv1.apiKeyPrefix['Authorization'] = "Token"

var api = new LogicMonitorRestApi.LMApi()

var body = ; // {OpsNote} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addOpsNote(body, callback);
using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class addOpsNoteExample
    {
        public void main()
        {
            
            // Configure API key authorization: LMv1
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new LMApi();
            var body = new OpsNote(); // OpsNote | 

            try
            {
                // add opsnote
                OpsNote result = apiInstance.addOpsNote(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.addOpsNote: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: LMv1
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\LMApi();
$body = ; // OpsNote | 

try {
    $result = $api_instance->addOpsNote($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->addOpsNote: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LMApi;

# Configure API key authorization: LMv1
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::LMApi->new();
my $body = WWW::SwaggerClient::Object::OpsNote->new(); # OpsNote | 

eval { 
    my $result = $api_instance->addOpsNote(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->addOpsNote: $@\n";
}
from __future__ import print_function
import time
import logicmonitor_sdk
from logicmonitor_sdk.rest import ApiException
from pprint import pprint


# Configure API key authorization: LMv1
configuration = logicmonitor_sdk.Configuration()
configuration.company = 'YOUR_COMPANY'
configuration.access_id = 'YOUR_ACCESS_ID'
configuration.access_key = 'YOUR_ACCESS_KEY'

# create an instance of the API class
api_instance = logicmonitor_sdk.LMApi(logicmonitor_sdk.ApiClient(configuration))
body =  # OpsNote | 

try:
    # add opsnote
    api_response = api_instance.add_ops_note(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->addOpsNote: %s\n" % e)
package main

import (
    "fmt"
    "github.com/logicmonitor/lm-sdk-go/client"
    "github.com/logicmonitor/lm-sdk-go/client/lm"
)
func main() {
    // Configure API key authorization: LMv1
    domain := "YOUR_COMPANY.logicmonitor.com"
    accessID := "YOUR_ACCESS_ID"
    accessKey := "YOUR_ACCESS_KEY"

    config := client.NewConfig()
    config.SetAccountDomain(&domain)
    config.SetAccessID(&accessID)
    config.SetAccessKey(&accessKey)
    
    // create an instance of the API class
    client := client.New(config)
    params := lm.NewAddOpsNoteParams()
    params.Body =  // OpsNote | 

    // add opsnote
    resp, err := client.LM.AddOpsNote(params)
    if err != nil {
        fmt.Printf("Exception when calling client.LM.AddOpsNote: %v", err.Error())
    }
    fmt.Print(resp)
}

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation

Status: default - Error


addRecipientGroup

add recipient group


/setting/recipientgroups

Usage and SDK Samples

curl -X POST -H "Authorization: [[apiKey]]" "https://localhost/santaba/rest/setting/recipientgroups"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LMApi;

import java.io.File;
import java.util.*;

public class LMApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: LMv1
        ApiKeyAuth LMv1 = (ApiKeyAuth) defaultClient.getAuthentication("LMv1");
        LMv1.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //LMv1.setApiKeyPrefix("Token");

        LMApi apiInstance = new LMApi();
        RecipientGroup body = ; // RecipientGroup | 
        try {
            RecipientGroup result = apiInstance.addRecipientGroup(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addRecipientGroup");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        RecipientGroup body = ; // RecipientGroup | 
        try {
            RecipientGroup result = apiInstance.addRecipientGroup(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addRecipientGroup");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: LMv1)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];

RecipientGroup *body = ; // 

LMApi *apiInstance = [[LMApi alloc] init];

// add recipient group
[apiInstance addRecipientGroupWith:body
              completionHandler: ^(RecipientGroup output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LogicMonitorRestApi = require('logic_monitor_rest_api');
var defaultClient = LogicMonitorRestApi.ApiClient.instance;

// Configure API key authorization: LMv1
var LMv1 = defaultClient.authentications['LMv1'];
LMv1.apiKey = "YOUR API KEY"
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//LMv1.apiKeyPrefix['Authorization'] = "Token"

var api = new LogicMonitorRestApi.LMApi()

var body = ; // {RecipientGroup} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addRecipientGroup(body, callback);
using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class addRecipientGroupExample
    {
        public void main()
        {
            
            // Configure API key authorization: LMv1
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");

            var apiInstance = new LMApi();
            var body = new RecipientGroup(); // RecipientGroup | 

            try
            {
                // add recipient group
                RecipientGroup result = apiInstance.addRecipientGroup(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.addRecipientGroup: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: LMv1
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

$api_instance = new Swagger\Client\Api\LMApi();
$body = ; // RecipientGroup | 

try {
    $result = $api_instance->addRecipientGroup($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->addRecipientGroup: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LMApi;

# Configure API key authorization: LMv1
$WWW::SwaggerClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::SwaggerClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

my $api_instance = WWW::SwaggerClient::LMApi->new();
my $body = WWW::SwaggerClient::Object::RecipientGroup->new(); # RecipientGroup | 

eval { 
    my $result = $api_instance->addRecipientGroup(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->addRecipientGroup: $@\n";
}
from __future__ import print_function
import time
import logicmonitor_sdk
from logicmonitor_sdk.rest import ApiException
from pprint import pprint


# Configure API key authorization: LMv1
configuration = logicmonitor_sdk.Configuration()
configuration.company = 'YOUR_COMPANY'
configuration.access_id = 'YOUR_ACCESS_ID'
configuration.access_key = 'YOUR_ACCESS_KEY'

# create an instance of the API class
api_instance = logicmonitor_sdk.LMApi(logicmonitor_sdk.ApiClient(configuration))
body =  # RecipientGroup | 

try:
    # add recipient group
    api_response = api_instance.add_recipient_group(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->addRecipientGroup: %s\n" % e)
package main

import (
    "fmt"
    "github.com/logicmonitor/lm-sdk-go/client"
    "github.com/logicmonitor/lm-sdk-go/client/lm"
)
func main() {
    // Configure API key authorization: LMv1
    domain := "YOUR_COMPANY.logicmonitor.com"
    accessID := "YOUR_ACCESS_ID"
    accessKey := "YOUR_ACCESS_KEY"

    config := client.NewConfig()
    config.SetAccountDomain(&domain)
    config.SetAccessID(&accessID)
    config.SetAccessKey(&accessKey)
    
    // create an instance of the API class
    client := client.New(config)
    params := lm.NewAddRecipientGroupParams()
    params.Body =  // RecipientGroup | 

    // add recipient group
    resp, err := client.LM.AddRecipientGroup(params)
    if err != nil {
        fmt.Printf("Exception when calling client.LM.AddRecipientGroup: %v", err.Error())
    }
    fmt.Print(resp)
}

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - successful operation

Status: default - Error


addReport

add report


/report/reports

Usage and SDK Samples

curl -X POST -H "Authorization: [[apiKey]]" "https://localhost/santaba/rest/report/reports"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LMApi;

import java.io.File;
import java.util.*;

public class LMApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: LMv1
        ApiKeyAuth LMv1 = (ApiKeyAuth) defaultClient.getAuthentication("LMv1");
        LMv1.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //LMv1.setApiKeyPrefix("Token");

        LMApi apiInstance = new LMApi();
        ReportBase body = ; // ReportBase | 
        try {
            ReportBase result = apiInstance.addReport(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addReport");
            e.printStackTrace();
        }
    }
}