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))
    

        
    
    

        
    
    

        
    
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()
    

        
    
    

        
    
    

        
    
// 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)
}

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))
    

        
    
    

        
    
    

        
    
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()
    

        
    
    

        
    
    

        
    
// 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)
}

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))
    

        
    
    

        
    
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()
    

        
    
    

        
    
// 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)
}

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))
    

        
    
    

        
    
    

        
    
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()
    

        
    
    

        
    
    

        
    
// 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)
}

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))
    

        
    
    

        
    
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()
    

        
    
    

        
    
// 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)
}

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 | 
        String type = type_example; // String | 
        try {
            APIToken result = apiInstance.addApiTokenByAdminId(adminId, body, type);
            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 | 
        String type = type_example; // String | 
        try {
            APIToken result = apiInstance.addApiTokenByAdminId(adminId, body, type);
            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 = ; // 
String *type = type_example; //  (optional) (default to API Token)

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

// add api tokens for a user
[apiInstance addApiTokenByAdminIdWith:adminId
    body:body
    type:type
              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 opts = { 
  'type': type_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addApiTokenByAdminId(adminId, body, opts, 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 | 
            var type = type_example;  // String |  (optional)  (default to API Token)

            try
            {
                // add api tokens for a user
                APIToken result = apiInstance.addApiTokenByAdminId(adminId, body, type);
                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 | 
$type = type_example; // String | 

try {
    $result = $api_instance->addApiTokenByAdminId($adminId, $body, $type);
    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 | 
my $type = type_example; # String | 

eval { 
    my $result = $api_instance->addApiTokenByAdminId(adminId => $adminId, body => $body, type => $type);
    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))
    

        
    
    

        
    
    

        
    
    

        
    
try:
    # add api tokens for a user
    api_response = api_instance.add_api_token_by_admin_id(adminId, body, type=type)
    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()
    

        
    
    

        
    
    

        
    
    

        
    
// 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)
}

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();
        AppliesToFunction body = ; // AppliesToFunction | 
        try {
            AppliesToFunction result = apiInstance.addAppliesToFunction(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addAppliesToFunction");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        AppliesToFunction body = ; // AppliesToFunction | 
        try {
            AppliesToFunction result = apiInstance.addAppliesToFunction(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addAppliesToFunction");
            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"];

AppliesToFunction *body = ; //  (optional)

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

// add applies to function
[apiInstance addAppliesToFunctionWith:body
              completionHandler: ^(AppliesToFunction 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':  // {AppliesToFunction} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addAppliesToFunction(opts, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class addAppliesToFunctionExample
    {
        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 AppliesToFunction(); // AppliesToFunction |  (optional) 

            try
            {
                // add applies to function
                AppliesToFunction result = apiInstance.addAppliesToFunction(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.addAppliesToFunction: " + 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 = ; // AppliesToFunction | 

try {
    $result = $api_instance->addAppliesToFunction($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->addAppliesToFunction: ', $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::AppliesToFunction->new(); # AppliesToFunction | 

eval { 
    my $result = $api_instance->addAppliesToFunction(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->addAppliesToFunction: $@\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))
    

        
    
    

        
    
try:
    # add applies to function
    api_response = api_instance.add_applies_to_function(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->addAppliesToFunction: %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.NewAddAppliesToFunctionParams()
    

        
    
    

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

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))
    

        
    
    

        
    
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()
    

        
    
    

        
    
// 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)
}

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))
    

        
    
    

        
    
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()
    

        
    
    

        
    
// 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)
}

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))
    

        
    
    

        
    
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()
    

        
    
    

        
    
// 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)
}

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))
    

        
    
    

        
    
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()
    

        
    
    

        
    
// 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)
}

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))
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
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()
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
// 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)
}

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))
    

        
    
    

        
    
    

        
    
    

        
    
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()
    

        
    
    

        
    
    

        
    
    

        
    
// 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)
}

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))
    

        
    
    

        
    
    

        
    
    

        
    
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()
    

        
    
    

        
    
    

        
    
    

        
    
// 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)
}

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))
    

        
    
    

        
    
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()
    

        
    
    

        
    
// 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)
}

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))
    

        
    
    

        
    
    

        
    
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()
    

        
    
    

        
    
    

        
    
// 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)
}

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))
    

        
    
    

        
    
    

        
    
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()
    

        
    
    

        
    
    

        
    
// 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)
}

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))
    

        
    
    

        
    
    

        
    
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()
    

        
    
    

        
    
    

        
    
// 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)
}

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))
    

        
    
    

        
    
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()
    

        
    
    

        
    
// 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)
}

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))
    

        
    
    

        
    
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()
    

        
    
    

        
    
// 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)
}

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))
    

        
    
    

        
    
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()
    

        
    
    

        
    
// 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)
}

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))
    

        
    
    

        
    
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()
    

        
    
    

        
    
// 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)
}

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();
        }
    }
}

import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        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();
        }
    }
}

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"];

ReportBase *body = ; // 

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

// add report
[apiInstance addReportWith:body
              completionHandler: ^(ReportBase 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 = ; // {ReportBase} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addReport(body, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class addReportExample
    {
        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 ReportBase(); // ReportBase | 

            try
            {
                // add report
                ReportBase result = apiInstance.addReport(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.addReport: " + 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 = ; // ReportBase | 

try {
    $result = $api_instance->addReport($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->addReport: ', $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::ReportBase->new(); # ReportBase | 

eval { 
    my $result = $api_instance->addReport(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->addReport: $@\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))
    

        
    
    

        
    
try:
    # add report
    api_response = api_instance.add_report(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->addReport: %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.NewAddReportParams()
    

        
    
    

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

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();
        ReportGroup body = ; // ReportGroup | 
        try {
            ReportGroup result = apiInstance.addReportGroup(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addReportGroup");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        ReportGroup body = ; // ReportGroup | 
        try {
            ReportGroup result = apiInstance.addReportGroup(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addReportGroup");
            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"];

ReportGroup *body = ; // 

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

// add report group
[apiInstance addReportGroupWith:body
              completionHandler: ^(ReportGroup 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 = ; // {ReportGroup} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addReportGroup(body, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class addReportGroupExample
    {
        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 ReportGroup(); // ReportGroup | 

            try
            {
                // add report group
                ReportGroup result = apiInstance.addReportGroup(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.addReportGroup: " + 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 = ; // ReportGroup | 

try {
    $result = $api_instance->addReportGroup($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->addReportGroup: ', $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::ReportGroup->new(); # ReportGroup | 

eval { 
    my $result = $api_instance->addReportGroup(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->addReportGroup: $@\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))
    

        
    
    

        
    
try:
    # add report group
    api_response = api_instance.add_report_group(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->addReportGroup: %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.NewAddReportGroupParams()
    

        
    
    

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

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();
        Role body = ; // Role | 
        try {
            Role result = apiInstance.addRole(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addRole");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        Role body = ; // Role | 
        try {
            Role result = apiInstance.addRole(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addRole");
            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"];

Role *body = ; // 

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

// add role
[apiInstance addRoleWith:body
              completionHandler: ^(Role 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 = ; // {Role} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addRole(body, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class addRoleExample
    {
        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 Role(); // Role | 

            try
            {
                // add role
                Role result = apiInstance.addRole(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.addRole: " + 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 = ; // Role | 

try {
    $result = $api_instance->addRole($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->addRole: ', $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::Role->new(); # Role | 

eval { 
    my $result = $api_instance->addRole(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->addRole: $@\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))
    

        
    
    

        
    
try:
    # add role
    api_response = api_instance.add_role(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->addRole: %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.NewAddRoleParams()
    

        
    
    

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

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();
        SDT body = ; // SDT | 
        try {
            SDT result = apiInstance.addSDT(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addSDT");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        SDT body = ; // SDT | 
        try {
            SDT result = apiInstance.addSDT(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addSDT");
            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"];

SDT *body = ; // 

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

// add SDT
[apiInstance addSDTWith:body
              completionHandler: ^(SDT 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 = ; // {SDT} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addSDT(body, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class addSDTExample
    {
        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 SDT(); // SDT | 

            try
            {
                // add SDT
                SDT result = apiInstance.addSDT(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.addSDT: " + 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 = ; // SDT | 

try {
    $result = $api_instance->addSDT($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->addSDT: ', $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::SDT->new(); # SDT | 

eval { 
    my $result = $api_instance->addSDT(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->addSDT: $@\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))
    

        
    
    

        
    
try:
    # add SDT
    api_response = api_instance.add_sdt(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->addSDT: %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.NewAddSDTParams()
    

        
    
    

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

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();
        Website body = ; // Website | 
        try {
            Website result = apiInstance.addWebsite(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addWebsite");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        Website body = ; // Website | 
        try {
            Website result = apiInstance.addWebsite(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addWebsite");
            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"];

Website *body = ; // 

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

// add website
[apiInstance addWebsiteWith:body
              completionHandler: ^(Website 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 = ; // {Website} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addWebsite(body, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class addWebsiteExample
    {
        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 Website(); // Website | 

            try
            {
                // add website
                Website result = apiInstance.addWebsite(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.addWebsite: " + 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 = ; // Website | 

try {
    $result = $api_instance->addWebsite($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->addWebsite: ', $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::Website->new(); # Website | 

eval { 
    my $result = $api_instance->addWebsite(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->addWebsite: $@\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))
    

        
    
    

        
    
try:
    # add website
    api_response = api_instance.add_website(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->addWebsite: %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.NewAddWebsiteParams()
    

        
    
    

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

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();
        WebsiteGroup body = ; // WebsiteGroup | 
        try {
            WebsiteGroup result = apiInstance.addWebsiteGroup(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addWebsiteGroup");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        WebsiteGroup body = ; // WebsiteGroup | 
        try {
            WebsiteGroup result = apiInstance.addWebsiteGroup(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addWebsiteGroup");
            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"];

WebsiteGroup *body = ; // 

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

// add website group
[apiInstance addWebsiteGroupWith:body
              completionHandler: ^(WebsiteGroup 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 = ; // {WebsiteGroup} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addWebsiteGroup(body, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class addWebsiteGroupExample
    {
        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 WebsiteGroup(); // WebsiteGroup | 

            try
            {
                // add website group
                WebsiteGroup result = apiInstance.addWebsiteGroup(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.addWebsiteGroup: " + 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 = ; // WebsiteGroup | 

try {
    $result = $api_instance->addWebsiteGroup($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->addWebsiteGroup: ', $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::WebsiteGroup->new(); # WebsiteGroup | 

eval { 
    my $result = $api_instance->addWebsiteGroup(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->addWebsiteGroup: $@\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))
    

        
    
    

        
    
try:
    # add website group
    api_response = api_instance.add_website_group(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->addWebsiteGroup: %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.NewAddWebsiteGroupParams()
    

        
    
    

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

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();
        Widget body = ; // Widget | 
        try {
            Widget result = apiInstance.addWidget(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addWidget");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        Widget body = ; // Widget | 
        try {
            Widget result = apiInstance.addWidget(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#addWidget");
            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"];

Widget *body = ; // 

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

// add widget
[apiInstance addWidgetWith:body
              completionHandler: ^(Widget 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 = ; // {Widget} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addWidget(body, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class addWidgetExample
    {
        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 Widget(); // Widget | 

            try
            {
                // add widget
                Widget result = apiInstance.addWidget(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.addWidget: " + 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 = ; // Widget | 

try {
    $result = $api_instance->addWidget($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->addWidget: ', $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::Widget->new(); # Widget | 

eval { 
    my $result = $api_instance->addWidget(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->addWidget: $@\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))
    

        
    
    

        
    
try:
    # add widget
    api_response = api_instance.add_widget(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->addWidget: %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.NewAddWidgetParams()
    

        
    
    

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

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 | 
        Integer instanceId = 56; // Integer | 
        try {
            Object result = apiInstance.collectDeviceConfigSourceConfig(deviceId, hdsId, instanceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#collectDeviceConfigSourceConfig");
            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 | 
        Integer instanceId = 56; // Integer | 
        try {
            Object result = apiInstance.collectDeviceConfigSourceConfig(deviceId, hdsId, instanceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#collectDeviceConfigSourceConfig");
            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; // 
Integer *instanceId = 56; // 

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

// collect a config for a device
[apiInstance collectDeviceConfigSourceConfigWith:deviceId
    hdsId:hdsId
    instanceId:instanceId
              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 deviceId = 56; // {Integer} 

var hdsId = 56; // {Integer} 

var instanceId = 56; // {Integer} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.collectDeviceConfigSourceConfig(deviceId, hdsId, instanceId, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class collectDeviceConfigSourceConfigExample
    {
        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 | 
            var instanceId = 56;  // Integer | 

            try
            {
                // collect a config for a device
                Object result = apiInstance.collectDeviceConfigSourceConfig(deviceId, hdsId, instanceId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.collectDeviceConfigSourceConfig: " + 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 | 
$instanceId = 56; // Integer | 

try {
    $result = $api_instance->collectDeviceConfigSourceConfig($deviceId, $hdsId, $instanceId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->collectDeviceConfigSourceConfig: ', $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 | 
my $instanceId = 56; # Integer | 

eval { 
    my $result = $api_instance->collectDeviceConfigSourceConfig(deviceId => $deviceId, hdsId => $hdsId, instanceId => $instanceId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->collectDeviceConfigSourceConfig: $@\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))
    

        
    
    

        
    
    

        
    
try:
    # collect a config for a device
    api_response = api_instance.collect_device_config_source_config(deviceId, hdsId, instanceId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->collectDeviceConfigSourceConfig: %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.NewCollectDeviceConfigSourceConfigParams()
    

        
    
    

        
    
    

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

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 | 
        try {
            Object result = apiInstance.deleteAdminById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteAdminById");
            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 | 
        try {
            Object result = apiInstance.deleteAdminById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteAdminById");
            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; // 

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

// delete user
[apiInstance deleteAdminByIdWith: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 id = 56; // {Integer} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteAdminById(id, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class deleteAdminByIdExample
    {
        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 | 

            try
            {
                // delete user
                Object result = apiInstance.deleteAdminById(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.deleteAdminById: " + 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 | 

try {
    $result = $api_instance->deleteAdminById($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->deleteAdminById: ', $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 | 

eval { 
    my $result = $api_instance->deleteAdminById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->deleteAdminById: $@\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))
    

        
    
try:
    # delete user
    api_response = api_instance.delete_admin_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->deleteAdminById: %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.NewDeleteAdminByIDParams()
    

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

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 | 
        try {
            Object result = apiInstance.deleteAlertRuleById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteAlertRuleById");
            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 | 
        try {
            Object result = apiInstance.deleteAlertRuleById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteAlertRuleById");
            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; // 

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

// delete alert rule
[apiInstance deleteAlertRuleByIdWith: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 id = 56; // {Integer} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteAlertRuleById(id, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class deleteAlertRuleByIdExample
    {
        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 | 

            try
            {
                // delete alert rule
                Object result = apiInstance.deleteAlertRuleById(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.deleteAlertRuleById: " + 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 | 

try {
    $result = $api_instance->deleteAlertRuleById($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->deleteAlertRuleById: ', $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 | 

eval { 
    my $result = $api_instance->deleteAlertRuleById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->deleteAlertRuleById: $@\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))
    

        
    
try:
    # delete alert rule
    api_response = api_instance.delete_alert_rule_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->deleteAlertRuleById: %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.NewDeleteAlertRuleByIDParams()
    

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

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 | 
        Integer apitokenId = 56; // Integer | 
        try {
            Object result = apiInstance.deleteApiTokenById(adminId, apitokenId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteApiTokenById");
            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 | 
        Integer apitokenId = 56; // Integer | 
        try {
            Object result = apiInstance.deleteApiTokenById(adminId, apitokenId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteApiTokenById");
            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; // 
Integer *apitokenId = 56; // 

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

// delete apiToken
[apiInstance deleteApiTokenByIdWith:adminId
    apitokenId:apitokenId
              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 adminId = 56; // {Integer} 

var apitokenId = 56; // {Integer} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteApiTokenById(adminId, apitokenId, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class deleteApiTokenByIdExample
    {
        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 apitokenId = 56;  // Integer | 

            try
            {
                // delete apiToken
                Object result = apiInstance.deleteApiTokenById(adminId, apitokenId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.deleteApiTokenById: " + 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 | 
$apitokenId = 56; // Integer | 

try {
    $result = $api_instance->deleteApiTokenById($adminId, $apitokenId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->deleteApiTokenById: ', $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 $apitokenId = 56; # Integer | 

eval { 
    my $result = $api_instance->deleteApiTokenById(adminId => $adminId, apitokenId => $apitokenId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->deleteApiTokenById: $@\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))
    

        
    
    

        
    
try:
    # delete apiToken
    api_response = api_instance.delete_api_token_by_id(adminId, apitokenId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->deleteApiTokenById: %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.NewDeleteAPITokenByIDParams()
    

        
    
    

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

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 | 
        Boolean ignoreReference = true; // Boolean | 
        try {
            Object result = apiInstance.deleteAppliesToFunctionById(id, ignoreReference);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteAppliesToFunctionById");
            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 | 
        Boolean ignoreReference = true; // Boolean | 
        try {
            Object result = apiInstance.deleteAppliesToFunctionById(id, ignoreReference);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteAppliesToFunctionById");
            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; // 
Boolean *ignoreReference = true; //  (optional) (default to false)

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

// delete applies to function
[apiInstance deleteAppliesToFunctionByIdWith:id
    ignoreReference:ignoreReference
              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 opts = { 
  'ignoreReference': true // {Boolean} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteAppliesToFunctionById(id, opts, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class deleteAppliesToFunctionByIdExample
    {
        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 ignoreReference = true;  // Boolean |  (optional)  (default to false)

            try
            {
                // delete applies to function
                Object result = apiInstance.deleteAppliesToFunctionById(id, ignoreReference);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.deleteAppliesToFunctionById: " + 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 | 
$ignoreReference = true; // Boolean | 

try {
    $result = $api_instance->deleteAppliesToFunctionById($id, $ignoreReference);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->deleteAppliesToFunctionById: ', $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 $ignoreReference = true; # Boolean | 

eval { 
    my $result = $api_instance->deleteAppliesToFunctionById(id => $id, ignoreReference => $ignoreReference);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->deleteAppliesToFunctionById: $@\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))
    

        
    
    

        
    
try:
    # delete applies to function
    api_response = api_instance.delete_applies_to_function_by_id(id, ignoreReference=ignoreReference)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->deleteAppliesToFunctionById: %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.NewDeleteAppliesToFunctionByIDParams()
    

        
    
    

        
    
// delete applies to function
resp, err := client.LM.DeleteAppliesToFunctionByID(params)
if err != nil {
fmt.Printf("Exception when calling client.LM.DeleteAppliesToFunctionByID: %v", err.Error())
}
fmt.Print(resp)
}

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 | 
        try {
            Object result = apiInstance.deleteCollectorById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteCollectorById");
            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 | 
        try {
            Object result = apiInstance.deleteCollectorById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteCollectorById");
            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; // 

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

// delete collector
[apiInstance deleteCollectorByIdWith: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 id = 56; // {Integer} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteCollectorById(id, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class deleteCollectorByIdExample
    {
        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 | 

            try
            {
                // delete collector
                Object result = apiInstance.deleteCollectorById(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.deleteCollectorById: " + 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 | 

try {
    $result = $api_instance->deleteCollectorById($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->deleteCollectorById: ', $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 | 

eval { 
    my $result = $api_instance->deleteCollectorById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->deleteCollectorById: $@\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))
    

        
    
try:
    # delete collector
    api_response = api_instance.delete_collector_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->deleteCollectorById: %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.NewDeleteCollectorByIDParams()
    

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

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 | 
        try {
            Object result = apiInstance.deleteCollectorGroupById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteCollectorGroupById");
            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 | 
        try {
            Object result = apiInstance.deleteCollectorGroupById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteCollectorGroupById");
            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; // 

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

// delete collector group
[apiInstance deleteCollectorGroupByIdWith: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 id = 56; // {Integer} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteCollectorGroupById(id, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class deleteCollectorGroupByIdExample
    {
        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 | 

            try
            {
                // delete collector group
                Object result = apiInstance.deleteCollectorGroupById(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.deleteCollectorGroupById: " + 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 | 

try {
    $result = $api_instance->deleteCollectorGroupById($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->deleteCollectorGroupById: ', $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 | 

eval { 
    my $result = $api_instance->deleteCollectorGroupById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->deleteCollectorGroupById: $@\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))
    

        
    
try:
    # delete collector group
    api_response = api_instance.delete_collector_group_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->deleteCollectorGroupById: %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.NewDeleteCollectorGroupByIDParams()
    

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

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 | 
        try {
            Object result = apiInstance.deleteDashboardById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteDashboardById");
            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 | 
        try {
            Object result = apiInstance.deleteDashboardById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteDashboardById");
            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; // 

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

// delete dashboard
[apiInstance deleteDashboardByIdWith: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 id = 56; // {Integer} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteDashboardById(id, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class deleteDashboardByIdExample
    {
        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 | 

            try
            {
                // delete dashboard
                Object result = apiInstance.deleteDashboardById(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.deleteDashboardById: " + 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 | 

try {
    $result = $api_instance->deleteDashboardById($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->deleteDashboardById: ', $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 | 

eval { 
    my $result = $api_instance->deleteDashboardById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->deleteDashboardById: $@\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))
    

        
    
try:
    # delete dashboard
    api_response = api_instance.delete_dashboard_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->deleteDashboardById: %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.NewDeleteDashboardByIDParams()
    

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

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 | 
        Boolean allowNonEmptyGroup = true; // Boolean | 
        try {
            Object result = apiInstance.deleteDashboardGroupById(id, allowNonEmptyGroup);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteDashboardGroupById");
            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 | 
        Boolean allowNonEmptyGroup = true; // Boolean | 
        try {
            Object result = apiInstance.deleteDashboardGroupById(id, allowNonEmptyGroup);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteDashboardGroupById");
            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; // 
Boolean *allowNonEmptyGroup = true; //  (optional) (default to false)

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

// delete dashboard group
[apiInstance deleteDashboardGroupByIdWith:id
    allowNonEmptyGroup:allowNonEmptyGroup
              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 opts = { 
  'allowNonEmptyGroup': true // {Boolean} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteDashboardGroupById(id, opts, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class deleteDashboardGroupByIdExample
    {
        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 allowNonEmptyGroup = true;  // Boolean |  (optional)  (default to false)

            try
            {
                // delete dashboard group
                Object result = apiInstance.deleteDashboardGroupById(id, allowNonEmptyGroup);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.deleteDashboardGroupById: " + 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 | 
$allowNonEmptyGroup = true; // Boolean | 

try {
    $result = $api_instance->deleteDashboardGroupById($id, $allowNonEmptyGroup);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->deleteDashboardGroupById: ', $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 $allowNonEmptyGroup = true; # Boolean | 

eval { 
    my $result = $api_instance->deleteDashboardGroupById(id => $id, allowNonEmptyGroup => $allowNonEmptyGroup);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->deleteDashboardGroupById: $@\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))
    

        
    
    

        
    
try:
    # delete dashboard group
    api_response = api_instance.delete_dashboard_group_by_id(id, allowNonEmptyGroup=allowNonEmptyGroup)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->deleteDashboardGroupById: %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.NewDeleteDashboardGroupByIDParams()
    

        
    
    

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

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 | 
        try {
            Object result = apiInstance.deleteDatasourceById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteDatasourceById");
            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 | 
        try {
            Object result = apiInstance.deleteDatasourceById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteDatasourceById");
            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; // 

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

// delete datasource
[apiInstance deleteDatasourceByIdWith: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 id = 56; // {Integer} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteDatasourceById(id, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class deleteDatasourceByIdExample
    {
        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 | 

            try
            {
                // delete datasource
                Object result = apiInstance.deleteDatasourceById(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.deleteDatasourceById: " + 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 | 

try {
    $result = $api_instance->deleteDatasourceById($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->deleteDatasourceById: ', $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 | 

eval { 
    my $result = $api_instance->deleteDatasourceById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->deleteDatasourceById: $@\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))
    

        
    
try:
    # delete datasource
    api_response = api_instance.delete_datasource_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->deleteDatasourceById: %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.NewDeleteDatasourceByIDParams()
    

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

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 | 
        Long start = 789; // Long | 
        Long end = 789; // Long | 
        String netflowFilter = netflowFilter_example; // String | 
        Boolean deleteHard = true; // Boolean | 
        try {
            Object result = apiInstance.deleteDeviceById(id, start, end, netflowFilter, deleteHard);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteDeviceById");
            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 | 
        Long start = 789; // Long | 
        Long end = 789; // Long | 
        String netflowFilter = netflowFilter_example; // String | 
        Boolean deleteHard = true; // Boolean | 
        try {
            Object result = apiInstance.deleteDeviceById(id, start, end, netflowFilter, deleteHard);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteDeviceById");
            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; // 
Long *start = 789; //  (optional)
Long *end = 789; //  (optional)
String *netflowFilter = netflowFilter_example; //  (optional)
Boolean *deleteHard = true; //  (optional) (default to true)

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

// delete a device
[apiInstance deleteDeviceByIdWith:id
    start:start
    end:end
    netflowFilter:netflowFilter
    deleteHard:deleteHard
              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 opts = { 
  'start': 789, // {Long} 
  'end': 789, // {Long} 
  'netflowFilter': netflowFilter_example, // {String} 
  'deleteHard': true // {Boolean} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteDeviceById(id, opts, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class deleteDeviceByIdExample
    {
        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 start = 789;  // Long |  (optional) 
            var end = 789;  // Long |  (optional) 
            var netflowFilter = netflowFilter_example;  // String |  (optional) 
            var deleteHard = true;  // Boolean |  (optional)  (default to true)

            try
            {
                // delete a device
                Object result = apiInstance.deleteDeviceById(id, start, end, netflowFilter, deleteHard);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.deleteDeviceById: " + 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 | 
$start = 789; // Long | 
$end = 789; // Long | 
$netflowFilter = netflowFilter_example; // String | 
$deleteHard = true; // Boolean | 

try {
    $result = $api_instance->deleteDeviceById($id, $start, $end, $netflowFilter, $deleteHard);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->deleteDeviceById: ', $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 $start = 789; # Long | 
my $end = 789; # Long | 
my $netflowFilter = netflowFilter_example; # String | 
my $deleteHard = true; # Boolean | 

eval { 
    my $result = $api_instance->deleteDeviceById(id => $id, start => $start, end => $end, netflowFilter => $netflowFilter, deleteHard => $deleteHard);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->deleteDeviceById: $@\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))
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
try:
    # delete a device
    api_response = api_instance.delete_device_by_id(id, start=start, end=end, netflowFilter=netflowFilter, deleteHard=deleteHard)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->deleteDeviceById: %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.NewDeleteDeviceByIDParams()
    

        
    
    

        
    
    

        
    
    

        
    
    

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

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
        Integer id = 56; // Integer | 
        try {
            Object result = apiInstance.deleteDeviceDatasourceInstanceById(deviceId, hdsId, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteDeviceDatasourceInstanceById");
            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
        Integer id = 56; // Integer | 
        try {
            Object result = apiInstance.deleteDeviceDatasourceInstanceById(deviceId, hdsId, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteDeviceDatasourceInstanceById");
            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
Integer *id = 56; // 

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

// delete a device instance
[apiInstance deleteDeviceDatasourceInstanceByIdWith:deviceId
    hdsId:hdsId
    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 deviceId = 56; // {Integer} 

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

var id = 56; // {Integer} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteDeviceDatasourceInstanceById(deviceId, hdsId, id, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class deleteDeviceDatasourceInstanceByIdExample
    {
        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 id = 56;  // Integer | 

            try
            {
                // delete a device instance
                Object result = apiInstance.deleteDeviceDatasourceInstanceById(deviceId, hdsId, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.deleteDeviceDatasourceInstanceById: " + 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
$id = 56; // Integer | 

try {
    $result = $api_instance->deleteDeviceDatasourceInstanceById($deviceId, $hdsId, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->deleteDeviceDatasourceInstanceById: ', $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 $id = 56; # Integer | 

eval { 
    my $result = $api_instance->deleteDeviceDatasourceInstanceById(deviceId => $deviceId, hdsId => $hdsId, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->deleteDeviceDatasourceInstanceById: $@\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))
    

        
    
    

        
    
    

        
    
try:
    # delete a device instance
    api_response = api_instance.delete_device_datasource_instance_by_id(deviceId, hdsId, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->deleteDeviceDatasourceInstanceById: %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.NewDeleteDeviceDatasourceInstanceByIDParams()
    

        
    
    

        
    
    

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

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 | 
        Boolean deleteChildren = true; // Boolean | 
        Boolean deleteHard = true; // Boolean | 
        try {
            Object result = apiInstance.deleteDeviceGroupById(id, deleteChildren, deleteHard);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteDeviceGroupById");
            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 | 
        Boolean deleteChildren = true; // Boolean | 
        Boolean deleteHard = true; // Boolean | 
        try {
            Object result = apiInstance.deleteDeviceGroupById(id, deleteChildren, deleteHard);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteDeviceGroupById");
            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; // 
Boolean *deleteChildren = true; //  (optional) (default to false)
Boolean *deleteHard = true; //  (optional) (default to true)

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

// delete device group
[apiInstance deleteDeviceGroupByIdWith:id
    deleteChildren:deleteChildren
    deleteHard:deleteHard
              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 opts = { 
  'deleteChildren': true, // {Boolean} 
  'deleteHard': true // {Boolean} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteDeviceGroupById(id, opts, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class deleteDeviceGroupByIdExample
    {
        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 deleteChildren = true;  // Boolean |  (optional)  (default to false)
            var deleteHard = true;  // Boolean |  (optional)  (default to true)

            try
            {
                // delete device group
                Object result = apiInstance.deleteDeviceGroupById(id, deleteChildren, deleteHard);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.deleteDeviceGroupById: " + 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 | 
$deleteChildren = true; // Boolean | 
$deleteHard = true; // Boolean | 

try {
    $result = $api_instance->deleteDeviceGroupById($id, $deleteChildren, $deleteHard);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->deleteDeviceGroupById: ', $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 $deleteChildren = true; # Boolean | 
my $deleteHard = true; # Boolean | 

eval { 
    my $result = $api_instance->deleteDeviceGroupById(id => $id, deleteChildren => $deleteChildren, deleteHard => $deleteHard);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->deleteDeviceGroupById: $@\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))
    

        
    
    

        
    
    

        
    
try:
    # delete device group
    api_response = api_instance.delete_device_group_by_id(id, deleteChildren=deleteChildren, deleteHard=deleteHard)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->deleteDeviceGroupById: %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.NewDeleteDeviceGroupByIDParams()
    

        
    
    

        
    
    

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

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 | 
        Integer id = 56; // Integer | 
        try {
            Object result = apiInstance.deleteDeviceGroupClusterAlertConfById(deviceGroupId, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteDeviceGroupClusterAlertConfById");
            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 | 
        Integer id = 56; // Integer | 
        try {
            Object result = apiInstance.deleteDeviceGroupClusterAlertConfById(deviceGroupId, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteDeviceGroupClusterAlertConfById");
            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; // 
Integer *id = 56; // 

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

// Delete cluster alert configuration
[apiInstance deleteDeviceGroupClusterAlertConfByIdWith:deviceGroupId
    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 deviceGroupId = 56; // {Integer} 

var id = 56; // {Integer} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteDeviceGroupClusterAlertConfById(deviceGroupId, id, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class deleteDeviceGroupClusterAlertConfByIdExample
    {
        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 id = 56;  // Integer | 

            try
            {
                // Delete cluster alert configuration
                Object result = apiInstance.deleteDeviceGroupClusterAlertConfById(deviceGroupId, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.deleteDeviceGroupClusterAlertConfById: " + 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 | 
$id = 56; // Integer | 

try {
    $result = $api_instance->deleteDeviceGroupClusterAlertConfById($deviceGroupId, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->deleteDeviceGroupClusterAlertConfById: ', $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 $id = 56; # Integer | 

eval { 
    my $result = $api_instance->deleteDeviceGroupClusterAlertConfById(deviceGroupId => $deviceGroupId, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->deleteDeviceGroupClusterAlertConfById: $@\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))
    

        
    
    

        
    
try:
    # Delete cluster alert configuration
    api_response = api_instance.delete_device_group_cluster_alert_conf_by_id(deviceGroupId, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->deleteDeviceGroupClusterAlertConfById: %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.NewDeleteDeviceGroupClusterAlertConfByIDParams()
    

        
    
    

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

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
        String name = name_example; // String | 
        try {
            Object result = apiInstance.deleteDeviceGroupPropertyByName(gid, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteDeviceGroupPropertyByName");
            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
        String name = name_example; // String | 
        try {
            Object result = apiInstance.deleteDeviceGroupPropertyByName(gid, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteDeviceGroupPropertyByName");
            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
String *name = name_example; // 

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

// delete device group property
[apiInstance deleteDeviceGroupPropertyByNameWith:gid
    name:name
              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 gid = 56; // {Integer} group ID

var name = name_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteDeviceGroupPropertyByName(gid, name, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class deleteDeviceGroupPropertyByNameExample
    {
        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 name = name_example;  // String | 

            try
            {
                // delete device group property
                Object result = apiInstance.deleteDeviceGroupPropertyByName(gid, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.deleteDeviceGroupPropertyByName: " + 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
$name = name_example; // String | 

try {
    $result = $api_instance->deleteDeviceGroupPropertyByName($gid, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->deleteDeviceGroupPropertyByName: ', $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 $name = name_example; # String | 

eval { 
    my $result = $api_instance->deleteDeviceGroupPropertyByName(gid => $gid, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->deleteDeviceGroupPropertyByName: $@\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))
    

        
    
    

        
    
try:
    # delete device group property
    api_response = api_instance.delete_device_group_property_by_name(gid, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->deleteDeviceGroupPropertyByName: %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.NewDeleteDeviceGroupPropertyByNameParams()
    

        
    
    

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

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 | 
        String name = name_example; // String | 
        try {
            Object result = apiInstance.deleteDevicePropertyByName(deviceId, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteDevicePropertyByName");
            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 | 
        String name = name_example; // String | 
        try {
            Object result = apiInstance.deleteDevicePropertyByName(deviceId, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteDevicePropertyByName");
            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; // 
String *name = name_example; // 

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

// delete device property
[apiInstance deleteDevicePropertyByNameWith:deviceId
    name:name
              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 deviceId = 56; // {Integer} 

var name = name_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteDevicePropertyByName(deviceId, name, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class deleteDevicePropertyByNameExample
    {
        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 name = name_example;  // String | 

            try
            {
                // delete device property
                Object result = apiInstance.deleteDevicePropertyByName(deviceId, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.deleteDevicePropertyByName: " + 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 | 
$name = name_example; // String | 

try {
    $result = $api_instance->deleteDevicePropertyByName($deviceId, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->deleteDevicePropertyByName: ', $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 $name = name_example; # String | 

eval { 
    my $result = $api_instance->deleteDevicePropertyByName(deviceId => $deviceId, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->deleteDevicePropertyByName: $@\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))
    

        
    
    

        
    
try:
    # delete device property
    api_response = api_instance.delete_device_property_by_name(deviceId, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->deleteDevicePropertyByName: %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.NewDeleteDevicePropertyByNameParams()
    

        
    
    

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

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 | 
        try {
            Object result = apiInstance.deleteEscalationChainById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteEscalationChainById");
            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 | 
        try {
            Object result = apiInstance.deleteEscalationChainById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteEscalationChainById");
            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; // 

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

// delete escalation chain
[apiInstance deleteEscalationChainByIdWith: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 id = 56; // {Integer} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteEscalationChainById(id, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class deleteEscalationChainByIdExample
    {
        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 | 

            try
            {
                // delete escalation chain
                Object result = apiInstance.deleteEscalationChainById(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.deleteEscalationChainById: " + 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 | 

try {
    $result = $api_instance->deleteEscalationChainById($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->deleteEscalationChainById: ', $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 | 

eval { 
    my $result = $api_instance->deleteEscalationChainById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->deleteEscalationChainById: $@\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))
    

        
    
try:
    # delete escalation chain
    api_response = api_instance.delete_escalation_chain_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->deleteEscalationChainById: %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.NewDeleteEscalationChainByIDParams()
    

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

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 | 
        try {
            Object result = apiInstance.deleteNetscanById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteNetscanById");
            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 | 
        try {
            Object result = apiInstance.deleteNetscanById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteNetscanById");
            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; // 

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

// delete a netscan
[apiInstance deleteNetscanByIdWith: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 id = 56; // {Integer} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteNetscanById(id, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class deleteNetscanByIdExample
    {
        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 | 

            try
            {
                // delete a netscan
                Object result = apiInstance.deleteNetscanById(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.deleteNetscanById: " + 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 | 

try {
    $result = $api_instance->deleteNetscanById($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->deleteNetscanById: ', $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 | 

eval { 
    my $result = $api_instance->deleteNetscanById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->deleteNetscanById: $@\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))
    

        
    
try:
    # delete a netscan
    api_response = api_instance.delete_netscan_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->deleteNetscanById: %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.NewDeleteNetscanByIDParams()
    

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

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();
        String id = id_example; // String | 
        try {
            Object result = apiInstance.deleteOpsNoteById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteOpsNoteById");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        String id = id_example; // String | 
        try {
            Object result = apiInstance.deleteOpsNoteById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteOpsNoteById");
            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"];

String *id = id_example; // 

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

// delete opsnote
[apiInstance deleteOpsNoteByIdWith: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 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.deleteOpsNoteById(id, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class deleteOpsNoteByIdExample
    {
        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 = id_example;  // String | 

            try
            {
                // delete opsnote
                Object result = apiInstance.deleteOpsNoteById(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.deleteOpsNoteById: " + 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 = id_example; // String | 

try {
    $result = $api_instance->deleteOpsNoteById($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->deleteOpsNoteById: ', $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 = id_example; # String | 

eval { 
    my $result = $api_instance->deleteOpsNoteById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->deleteOpsNoteById: $@\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))
    

        
    
try:
    # delete opsnote
    api_response = api_instance.delete_ops_note_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->deleteOpsNoteById: %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.NewDeleteOpsNoteByIDParams()
    

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

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 | 
        try {
            Object result = apiInstance.deleteRecipientGroupById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteRecipientGroupById");
            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 | 
        try {
            Object result = apiInstance.deleteRecipientGroupById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteRecipientGroupById");
            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; // 

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

// delete recipient group
[apiInstance deleteRecipientGroupByIdWith: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 id = 56; // {Integer} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteRecipientGroupById(id, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class deleteRecipientGroupByIdExample
    {
        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 | 

            try
            {
                // delete recipient group
                Object result = apiInstance.deleteRecipientGroupById(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.deleteRecipientGroupById: " + 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 | 

try {
    $result = $api_instance->deleteRecipientGroupById($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->deleteRecipientGroupById: ', $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 | 

eval { 
    my $result = $api_instance->deleteRecipientGroupById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->deleteRecipientGroupById: $@\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))
    

        
    
try:
    # delete recipient group
    api_response = api_instance.delete_recipient_group_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->deleteRecipientGroupById: %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.NewDeleteRecipientGroupByIDParams()
    

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

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 | 
        try {
            Object result = apiInstance.deleteReportById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteReportById");
            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 | 
        try {
            Object result = apiInstance.deleteReportById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteReportById");
            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; // 

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

// delete report
[apiInstance deleteReportByIdWith: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 id = 56; // {Integer} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteReportById(id, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class deleteReportByIdExample
    {
        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 | 

            try
            {
                // delete report
                Object result = apiInstance.deleteReportById(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.deleteReportById: " + 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 | 

try {
    $result = $api_instance->deleteReportById($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->deleteReportById: ', $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 | 

eval { 
    my $result = $api_instance->deleteReportById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->deleteReportById: $@\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))
    

        
    
try:
    # delete report
    api_response = api_instance.delete_report_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->deleteReportById: %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.NewDeleteReportByIDParams()
    

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

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 | 
        try {
            Object result = apiInstance.deleteReportGroupById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteReportGroupById");
            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 | 
        try {
            Object result = apiInstance.deleteReportGroupById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteReportGroupById");
            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; // 

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

// delete report group
[apiInstance deleteReportGroupByIdWith: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 id = 56; // {Integer} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteReportGroupById(id, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class deleteReportGroupByIdExample
    {
        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 | 

            try
            {
                // delete report group
                Object result = apiInstance.deleteReportGroupById(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.deleteReportGroupById: " + 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 | 

try {
    $result = $api_instance->deleteReportGroupById($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->deleteReportGroupById: ', $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 | 

eval { 
    my $result = $api_instance->deleteReportGroupById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->deleteReportGroupById: $@\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))
    

        
    
try:
    # delete report group
    api_response = api_instance.delete_report_group_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->deleteReportGroupById: %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.NewDeleteReportGroupByIDParams()
    

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

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 | 
        try {
            Object result = apiInstance.deleteRoleById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteRoleById");
            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 | 
        try {
            Object result = apiInstance.deleteRoleById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteRoleById");
            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; // 

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

// delete role
[apiInstance deleteRoleByIdWith: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 id = 56; // {Integer} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteRoleById(id, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class deleteRoleByIdExample
    {
        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 | 

            try
            {
                // delete role
                Object result = apiInstance.deleteRoleById(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.deleteRoleById: " + 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 | 

try {
    $result = $api_instance->deleteRoleById($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->deleteRoleById: ', $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 | 

eval { 
    my $result = $api_instance->deleteRoleById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->deleteRoleById: $@\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))
    

        
    
try:
    # delete role
    api_response = api_instance.delete_role_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->deleteRoleById: %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.NewDeleteRoleByIDParams()
    

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

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();
        String id = id_example; // String | 
        try {
            Object result = apiInstance.deleteSDTById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteSDTById");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        String id = id_example; // String | 
        try {
            Object result = apiInstance.deleteSDTById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteSDTById");
            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"];

String *id = id_example; // 

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

// delete SDT
[apiInstance deleteSDTByIdWith: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 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.deleteSDTById(id, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class deleteSDTByIdExample
    {
        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 = id_example;  // String | 

            try
            {
                // delete SDT
                Object result = apiInstance.deleteSDTById(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.deleteSDTById: " + 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 = id_example; // String | 

try {
    $result = $api_instance->deleteSDTById($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->deleteSDTById: ', $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 = id_example; # String | 

eval { 
    my $result = $api_instance->deleteSDTById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->deleteSDTById: $@\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))
    

        
    
try:
    # delete SDT
    api_response = api_instance.delete_sdt_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->deleteSDTById: %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.NewDeleteSDTByIDParams()
    

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

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 | 
        try {
            Object result = apiInstance.deleteWebsiteById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteWebsiteById");
            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 | 
        try {
            Object result = apiInstance.deleteWebsiteById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteWebsiteById");
            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; // 

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

// delete website
[apiInstance deleteWebsiteByIdWith: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 id = 56; // {Integer} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteWebsiteById(id, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class deleteWebsiteByIdExample
    {
        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 | 

            try
            {
                // delete website
                Object result = apiInstance.deleteWebsiteById(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.deleteWebsiteById: " + 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 | 

try {
    $result = $api_instance->deleteWebsiteById($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->deleteWebsiteById: ', $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 | 

eval { 
    my $result = $api_instance->deleteWebsiteById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->deleteWebsiteById: $@\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))
    

        
    
try:
    # delete website
    api_response = api_instance.delete_website_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->deleteWebsiteById: %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.NewDeleteWebsiteByIDParams()
    

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

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 | 
        Integer deleteChildren = 56; // Integer | 
        try {
            Object result = apiInstance.deleteWebsiteGroupById(id, deleteChildren);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteWebsiteGroupById");
            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 | 
        Integer deleteChildren = 56; // Integer | 
        try {
            Object result = apiInstance.deleteWebsiteGroupById(id, deleteChildren);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteWebsiteGroupById");
            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; // 
Integer *deleteChildren = 56; //  (optional)

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

// delete website group
[apiInstance deleteWebsiteGroupByIdWith:id
    deleteChildren:deleteChildren
              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 opts = { 
  'deleteChildren': 56 // {Integer} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteWebsiteGroupById(id, opts, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class deleteWebsiteGroupByIdExample
    {
        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 deleteChildren = 56;  // Integer |  (optional) 

            try
            {
                // delete website group
                Object result = apiInstance.deleteWebsiteGroupById(id, deleteChildren);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.deleteWebsiteGroupById: " + 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 | 
$deleteChildren = 56; // Integer | 

try {
    $result = $api_instance->deleteWebsiteGroupById($id, $deleteChildren);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->deleteWebsiteGroupById: ', $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 $deleteChildren = 56; # Integer | 

eval { 
    my $result = $api_instance->deleteWebsiteGroupById(id => $id, deleteChildren => $deleteChildren);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->deleteWebsiteGroupById: $@\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))
    

        
    
    

        
    
try:
    # delete website group
    api_response = api_instance.delete_website_group_by_id(id, deleteChildren=deleteChildren)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->deleteWebsiteGroupById: %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.NewDeleteWebsiteGroupByIDParams()
    

        
    
    

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

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 | 
        try {
            Object result = apiInstance.deleteWidgetById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteWidgetById");
            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 | 
        try {
            Object result = apiInstance.deleteWidgetById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#deleteWidgetById");
            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; // 

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

// delete widget
[apiInstance deleteWidgetByIdWith: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 id = 56; // {Integer} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteWidgetById(id, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class deleteWidgetByIdExample
    {
        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 | 

            try
            {
                // delete widget
                Object result = apiInstance.deleteWidgetById(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.deleteWidgetById: " + 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 | 

try {
    $result = $api_instance->deleteWidgetById($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->deleteWidgetById: ', $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 | 

eval { 
    my $result = $api_instance->deleteWidgetById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->deleteWidgetById: $@\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))
    

        
    
try:
    # delete widget
    api_response = api_instance.delete_widget_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->deleteWidgetById: %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.NewDeleteWidgetByIDParams()
    

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

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();
        Debug body = ; // Debug | 
        Integer collectorId = 56; // Integer | 
        try {
            Debug result = apiInstance.executeDebugCommand(body, collectorId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#executeDebugCommand");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        Debug body = ; // Debug | 
        Integer collectorId = 56; // Integer | 
        try {
            Debug result = apiInstance.executeDebugCommand(body, collectorId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#executeDebugCommand");
            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"];

Debug *body = ; //  (optional)
Integer *collectorId = 56; //  (optional)

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

// Execute a Collector debug command
[apiInstance executeDebugCommandWith:body
    collectorId:collectorId
              completionHandler: ^(Debug 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': , // {Debug} 
  'collectorId': 56 // {Integer} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.executeDebugCommand(opts, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class executeDebugCommandExample
    {
        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 Debug(); // Debug |  (optional) 
            var collectorId = 56;  // Integer |  (optional) 

            try
            {
                // Execute a Collector debug command
                Debug result = apiInstance.executeDebugCommand(body, collectorId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.executeDebugCommand: " + 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 = ; // Debug | 
$collectorId = 56; // Integer | 

try {
    $result = $api_instance->executeDebugCommand($body, $collectorId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->executeDebugCommand: ', $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::Debug->new(); # Debug | 
my $collectorId = 56; # Integer | 

eval { 
    my $result = $api_instance->executeDebugCommand(body => $body, collectorId => $collectorId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->executeDebugCommand: $@\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))
    

        
    
    

        
    
    

        
    
try:
    # Execute a Collector debug command
    api_response = api_instance.execute_debug_command(body=body, collectorId=collectorId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->executeDebugCommand: %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.NewExecuteDebugCommandParams()
    

        
    
    

        
    
    

        
    
// Execute a Collector debug command
resp, err := client.LM.ExecuteDebugCommand(params)
if err != nil {
fmt.Printf("Exception when calling client.LM.ExecuteDebugCommand: %v", err.Error())
}
fmt.Print(resp)
}

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();
        DeviceInstances body = ; // DeviceInstances | 
        Double period = 1.2; // Double | 
        Long start = 789; // Long | 
        Long end = 789; // Long | 
        String aggregate = aggregate_example; // String | the aggregate option
        try {
            DeviceInstanceDataPaginationResponse result = apiInstance.fetchDeviceInstancesData(body, period, start, end, aggregate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#fetchDeviceInstancesData");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        DeviceInstances body = ; // DeviceInstances | 
        Double period = 1.2; // Double | 
        Long start = 789; // Long | 
        Long end = 789; // Long | 
        String aggregate = aggregate_example; // String | the aggregate option
        try {
            DeviceInstanceDataPaginationResponse result = apiInstance.fetchDeviceInstancesData(body, period, start, end, aggregate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#fetchDeviceInstancesData");
            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"];

DeviceInstances *body = ; // 
Double *period = 1.2; //  (optional) (default to 1.0)
Long *start = 789; //  (optional)
Long *end = 789; //  (optional)
String *aggregate = aggregate_example; // the aggregate option (optional) (default to none)

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

// fetch device instances data
[apiInstance fetchDeviceInstancesDataWith:body
    period:period
    start:start
    end:end
    aggregate:aggregate
              completionHandler: ^(DeviceInstanceDataPaginationResponse 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 = ; // {DeviceInstances} 

var opts = { 
  'period': 1.2, // {Double} 
  'start': 789, // {Long} 
  'end': 789, // {Long} 
  'aggregate': aggregate_example // {String} the aggregate option
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.fetchDeviceInstancesData(body, opts, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class fetchDeviceInstancesDataExample
    {
        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 DeviceInstances(); // DeviceInstances | 
            var period = 1.2;  // Double |  (optional)  (default to 1.0)
            var start = 789;  // Long |  (optional) 
            var end = 789;  // Long |  (optional) 
            var aggregate = aggregate_example;  // String | the aggregate option (optional)  (default to none)

            try
            {
                // fetch device instances data
                DeviceInstanceDataPaginationResponse result = apiInstance.fetchDeviceInstancesData(body, period, start, end, aggregate);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.fetchDeviceInstancesData: " + 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 = ; // DeviceInstances | 
$period = 1.2; // Double | 
$start = 789; // Long | 
$end = 789; // Long | 
$aggregate = aggregate_example; // String | the aggregate option

try {
    $result = $api_instance->fetchDeviceInstancesData($body, $period, $start, $end, $aggregate);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->fetchDeviceInstancesData: ', $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::DeviceInstances->new(); # DeviceInstances | 
my $period = 1.2; # Double | 
my $start = 789; # Long | 
my $end = 789; # Long | 
my $aggregate = aggregate_example; # String | the aggregate option

eval { 
    my $result = $api_instance->fetchDeviceInstancesData(body => $body, period => $period, start => $start, end => $end, aggregate => $aggregate);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->fetchDeviceInstancesData: $@\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))
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
try:
    # fetch device instances data
    api_response = api_instance.fetch_device_instances_data(body, period=period, start=start, end=end, aggregate=aggregate)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->fetchDeviceInstancesData: %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.NewFetchDeviceInstancesDataParams()
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
    

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

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 | 
        GenerateReportRequest body = ; // GenerateReportRequest | 
        try {
            GenerateReportResult result = apiInstance.generateReportById(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#generateReportById");
            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 | 
        GenerateReportRequest body = ; // GenerateReportRequest | 
        try {
            GenerateReportResult result = apiInstance.generateReportById(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#generateReportById");
            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; // 
GenerateReportRequest *body = ; //  (optional)

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

// run a report
[apiInstance generateReportByIdWith:id
    body:body
              completionHandler: ^(GenerateReportResult 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 opts = { 
  'body':  // {GenerateReportRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.generateReportById(id, opts, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class generateReportByIdExample
    {
        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 GenerateReportRequest(); // GenerateReportRequest |  (optional) 

            try
            {
                // run a report
                GenerateReportResult result = apiInstance.generateReportById(id, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.generateReportById: " + 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 = ; // GenerateReportRequest | 

try {
    $result = $api_instance->generateReportById($id, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->generateReportById: ', $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::GenerateReportRequest->new(); # GenerateReportRequest | 

eval { 
    my $result = $api_instance->generateReportById(id => $id, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->generateReportById: $@\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))
    

        
    
    

        
    
    

        
    
try:
    # run a report
    api_response = api_instance.generate_report_by_id(id, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->generateReportById: %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.NewGenerateReportByIDParams()
    

        
    
    

        
    
    

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

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 | 
        String fields = fields_example; // String | 
        try {
            Admin result = apiInstance.getAdminById(id, fields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAdminById");
            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 | 
        String fields = fields_example; // String | 
        try {
            Admin result = apiInstance.getAdminById(id, fields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAdminById");
            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; // 
String *fields = fields_example; //  (optional)

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

// get user
[apiInstance getAdminByIdWith:id
    fields:fields
              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 id = 56; // {Integer} 

var opts = { 
  'fields': fields_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAdminById(id, opts, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class getAdminByIdExample
    {
        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 fields = fields_example;  // String |  (optional) 

            try
            {
                // get user
                Admin result = apiInstance.getAdminById(id, fields);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.getAdminById: " + 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 | 
$fields = fields_example; // String | 

try {
    $result = $api_instance->getAdminById($id, $fields);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->getAdminById: ', $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 $fields = fields_example; # String | 

eval { 
    my $result = $api_instance->getAdminById(id => $id, fields => $fields);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->getAdminById: $@\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))
    

        
    
    

        
    
try:
    # get user
    api_response = api_instance.get_admin_by_id(id, fields=fields)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->getAdminById: %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.NewGetAdminByIDParams()
    

        
    
    

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

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();
        String fields = fields_example; // String | 
        Integer size = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String filter = filter_example; // String | 
        try {
            AdminPaginationResponse result = apiInstance.getAdminList(fields, size, offset, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAdminList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        String fields = fields_example; // String | 
        Integer size = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String filter = filter_example; // String | 
        try {
            AdminPaginationResponse result = apiInstance.getAdminList(fields, size, offset, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAdminList");
            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"];

String *fields = fields_example; //  (optional)
Integer *size = 56; //  (optional)
Integer *offset = 56; //  (optional)
String *filter = filter_example; //  (optional)

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

// get user list
[apiInstance getAdminListWith:fields
    size:size
    offset:offset
    filter:filter
              completionHandler: ^(AdminPaginationResponse 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 = { 
  'fields': fields_example, // {String} 
  'size': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'filter': filter_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAdminList(opts, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class getAdminListExample
    {
        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 fields = fields_example;  // String |  (optional) 
            var size = 56;  // Integer |  (optional) 
            var offset = 56;  // Integer |  (optional) 
            var filter = filter_example;  // String |  (optional) 

            try
            {
                // get user list
                AdminPaginationResponse result = apiInstance.getAdminList(fields, size, offset, filter);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.getAdminList: " + 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();
$fields = fields_example; // String | 
$size = 56; // Integer | 
$offset = 56; // Integer | 
$filter = filter_example; // String | 

try {
    $result = $api_instance->getAdminList($fields, $size, $offset, $filter);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->getAdminList: ', $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 $fields = fields_example; # String | 
my $size = 56; # Integer | 
my $offset = 56; # Integer | 
my $filter = filter_example; # String | 

eval { 
    my $result = $api_instance->getAdminList(fields => $fields, size => $size, offset => $offset, filter => $filter);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->getAdminList: $@\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))
    

        
    
    

        
    
    

        
    
    

        
    
try:
    # get user list
    api_response = api_instance.get_admin_list(fields=fields, size=size, offset=offset, filter=filter)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->getAdminList: %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.NewGetAdminListParams()
    

        
    
    

        
    
    

        
    
    

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

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();
        String id = id_example; // String | 
        Boolean needMessage = true; // Boolean | 
        String customColumns = customColumns_example; // String | 
        String fields = fields_example; // String | 
        try {
            Alert result = apiInstance.getAlertById(id, needMessage, customColumns, fields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAlertById");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        String id = id_example; // String | 
        Boolean needMessage = true; // Boolean | 
        String customColumns = customColumns_example; // String | 
        String fields = fields_example; // String | 
        try {
            Alert result = apiInstance.getAlertById(id, needMessage, customColumns, fields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAlertById");
            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"];

String *id = id_example; // 
Boolean *needMessage = true; //  (optional) (default to false)
String *customColumns = customColumns_example; //  (optional)
String *fields = fields_example; //  (optional)

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

// get alert
[apiInstance getAlertByIdWith:id
    needMessage:needMessage
    customColumns:customColumns
    fields:fields
              completionHandler: ^(Alert 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 = id_example; // {String} 

var opts = { 
  'needMessage': true, // {Boolean} 
  'customColumns': customColumns_example, // {String} 
  'fields': fields_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAlertById(id, opts, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class getAlertByIdExample
    {
        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 = id_example;  // String | 
            var needMessage = true;  // Boolean |  (optional)  (default to false)
            var customColumns = customColumns_example;  // String |  (optional) 
            var fields = fields_example;  // String |  (optional) 

            try
            {
                // get alert
                Alert result = apiInstance.getAlertById(id, needMessage, customColumns, fields);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.getAlertById: " + 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 = id_example; // String | 
$needMessage = true; // Boolean | 
$customColumns = customColumns_example; // String | 
$fields = fields_example; // String | 

try {
    $result = $api_instance->getAlertById($id, $needMessage, $customColumns, $fields);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->getAlertById: ', $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 = id_example; # String | 
my $needMessage = true; # Boolean | 
my $customColumns = customColumns_example; # String | 
my $fields = fields_example; # String | 

eval { 
    my $result = $api_instance->getAlertById(id => $id, needMessage => $needMessage, customColumns => $customColumns, fields => $fields);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->getAlertById: $@\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))
    

        
    
    

        
    
    

        
    
    

        
    
try:
    # get alert
    api_response = api_instance.get_alert_by_id(id, needMessage=needMessage, customColumns=customColumns, fields=fields)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->getAlertById: %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.NewGetAlertByIDParams()
    

        
    
    

        
    
    

        
    
    

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

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();
        String fields = fields_example; // String | 
        Integer size = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String filter = filter_example; // String | 
        try {
            AlertPaginationResponse result = apiInstance.getAlertList(fields, size, offset, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAlertList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        String fields = fields_example; // String | 
        Integer size = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String filter = filter_example; // String | 
        try {
            AlertPaginationResponse result = apiInstance.getAlertList(fields, size, offset, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAlertList");
            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"];

String *fields = fields_example; //  (optional)
Integer *size = 56; //  (optional)
Integer *offset = 56; //  (optional)
String *filter = filter_example; //  (optional)

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

// get alert list
[apiInstance getAlertListWith:fields
    size:size
    offset:offset
    filter:filter
              completionHandler: ^(AlertPaginationResponse 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 = { 
  'fields': fields_example, // {String} 
  'size': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'filter': filter_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAlertList(opts, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class getAlertListExample
    {
        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 fields = fields_example;  // String |  (optional) 
            var size = 56;  // Integer |  (optional) 
            var offset = 56;  // Integer |  (optional) 
            var filter = filter_example;  // String |  (optional) 

            try
            {
                // get alert list
                AlertPaginationResponse result = apiInstance.getAlertList(fields, size, offset, filter);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.getAlertList: " + 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();
$fields = fields_example; // String | 
$size = 56; // Integer | 
$offset = 56; // Integer | 
$filter = filter_example; // String | 

try {
    $result = $api_instance->getAlertList($fields, $size, $offset, $filter);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->getAlertList: ', $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 $fields = fields_example; # String | 
my $size = 56; # Integer | 
my $offset = 56; # Integer | 
my $filter = filter_example; # String | 

eval { 
    my $result = $api_instance->getAlertList(fields => $fields, size => $size, offset => $offset, filter => $filter);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->getAlertList: $@\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))
    

        
    
    

        
    
    

        
    
    

        
    
try:
    # get alert list
    api_response = api_instance.get_alert_list(fields=fields, size=size, offset=offset, filter=filter)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->getAlertList: %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.NewGetAlertListParams()
    

        
    
    

        
    
    

        
    
    

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

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 | 
        Boolean needMessage = true; // Boolean | 
        String customColumns = customColumns_example; // String | 
        String fields = fields_example; // String | 
        Integer size = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String filter = filter_example; // String | 
        try {
            AlertPaginationResponse result = apiInstance.getAlertListByDeviceGroupId(id, needMessage, customColumns, fields, size, offset, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAlertListByDeviceGroupId");
            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 | 
        Boolean needMessage = true; // Boolean | 
        String customColumns = customColumns_example; // String | 
        String fields = fields_example; // String | 
        Integer size = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String filter = filter_example; // String | 
        try {
            AlertPaginationResponse result = apiInstance.getAlertListByDeviceGroupId(id, needMessage, customColumns, fields, size, offset, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAlertListByDeviceGroupId");
            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; // 
Boolean *needMessage = true; //  (optional) (default to false)
String *customColumns = customColumns_example; //  (optional)
String *fields = fields_example; //  (optional)
Integer *size = 56; //  (optional)
Integer *offset = 56; //  (optional)
String *filter = filter_example; //  (optional)

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

// get device group alerts
[apiInstance getAlertListByDeviceGroupIdWith:id
    needMessage:needMessage
    customColumns:customColumns
    fields:fields
    size:size
    offset:offset
    filter:filter
              completionHandler: ^(AlertPaginationResponse 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 opts = { 
  'needMessage': true, // {Boolean} 
  'customColumns': customColumns_example, // {String} 
  'fields': fields_example, // {String} 
  'size': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'filter': filter_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAlertListByDeviceGroupId(id, opts, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class getAlertListByDeviceGroupIdExample
    {
        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 needMessage = true;  // Boolean |  (optional)  (default to false)
            var customColumns = customColumns_example;  // String |  (optional) 
            var fields = fields_example;  // String |  (optional) 
            var size = 56;  // Integer |  (optional) 
            var offset = 56;  // Integer |  (optional) 
            var filter = filter_example;  // String |  (optional) 

            try
            {
                // get device group alerts
                AlertPaginationResponse result = apiInstance.getAlertListByDeviceGroupId(id, needMessage, customColumns, fields, size, offset, filter);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.getAlertListByDeviceGroupId: " + 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 | 
$needMessage = true; // Boolean | 
$customColumns = customColumns_example; // String | 
$fields = fields_example; // String | 
$size = 56; // Integer | 
$offset = 56; // Integer | 
$filter = filter_example; // String | 

try {
    $result = $api_instance->getAlertListByDeviceGroupId($id, $needMessage, $customColumns, $fields, $size, $offset, $filter);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->getAlertListByDeviceGroupId: ', $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 $needMessage = true; # Boolean | 
my $customColumns = customColumns_example; # String | 
my $fields = fields_example; # String | 
my $size = 56; # Integer | 
my $offset = 56; # Integer | 
my $filter = filter_example; # String | 

eval { 
    my $result = $api_instance->getAlertListByDeviceGroupId(id => $id, needMessage => $needMessage, customColumns => $customColumns, fields => $fields, size => $size, offset => $offset, filter => $filter);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->getAlertListByDeviceGroupId: $@\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))
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
try:
    # get device group alerts
    api_response = api_instance.get_alert_list_by_device_group_id(id, needMessage=needMessage, customColumns=customColumns, fields=fields, size=size, offset=offset, filter=filter)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->getAlertListByDeviceGroupId: %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.NewGetAlertListByDeviceGroupIDParams()
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
    

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

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 | 
        Long start = 789; // Long | 
        Long end = 789; // Long | 
        String netflowFilter = netflowFilter_example; // String | 
        Boolean needMessage = true; // Boolean | 
        String customColumns = customColumns_example; // String | 
        String bound = bound_example; // String | 
        String fields = fields_example; // String | 
        Integer size = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String filter = filter_example; // String | 
        try {
            AlertPaginationResponse result = apiInstance.getAlertListByDeviceId(id, start, end, netflowFilter, needMessage, customColumns, bound, fields, size, offset, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAlertListByDeviceId");
            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 | 
        Long start = 789; // Long | 
        Long end = 789; // Long | 
        String netflowFilter = netflowFilter_example; // String | 
        Boolean needMessage = true; // Boolean | 
        String customColumns = customColumns_example; // String | 
        String bound = bound_example; // String | 
        String fields = fields_example; // String | 
        Integer size = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String filter = filter_example; // String | 
        try {
            AlertPaginationResponse result = apiInstance.getAlertListByDeviceId(id, start, end, netflowFilter, needMessage, customColumns, bound, fields, size, offset, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAlertListByDeviceId");
            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; // 
Long *start = 789; //  (optional)
Long *end = 789; //  (optional)
String *netflowFilter = netflowFilter_example; //  (optional)
Boolean *needMessage = true; //  (optional) (default to false)
String *customColumns = customColumns_example; //  (optional)
String *bound = bound_example; //  (optional) (default to instances)
String *fields = fields_example; //  (optional)
Integer *size = 56; //  (optional)
Integer *offset = 56; //  (optional)
String *filter = filter_example; //  (optional)

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

// get alerts
[apiInstance getAlertListByDeviceIdWith:id
    start:start
    end:end
    netflowFilter:netflowFilter
    needMessage:needMessage
    customColumns:customColumns
    bound:bound
    fields:fields
    size:size
    offset:offset
    filter:filter
              completionHandler: ^(AlertPaginationResponse 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 opts = { 
  'start': 789, // {Long} 
  'end': 789, // {Long} 
  'netflowFilter': netflowFilter_example, // {String} 
  'needMessage': true, // {Boolean} 
  'customColumns': customColumns_example, // {String} 
  'bound': bound_example, // {String} 
  'fields': fields_example, // {String} 
  'size': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'filter': filter_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAlertListByDeviceId(id, opts, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class getAlertListByDeviceIdExample
    {
        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 start = 789;  // Long |  (optional) 
            var end = 789;  // Long |  (optional) 
            var netflowFilter = netflowFilter_example;  // String |  (optional) 
            var needMessage = true;  // Boolean |  (optional)  (default to false)
            var customColumns = customColumns_example;  // String |  (optional) 
            var bound = bound_example;  // String |  (optional)  (default to instances)
            var fields = fields_example;  // String |  (optional) 
            var size = 56;  // Integer |  (optional) 
            var offset = 56;  // Integer |  (optional) 
            var filter = filter_example;  // String |  (optional) 

            try
            {
                // get alerts
                AlertPaginationResponse result = apiInstance.getAlertListByDeviceId(id, start, end, netflowFilter, needMessage, customColumns, bound, fields, size, offset, filter);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.getAlertListByDeviceId: " + 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 | 
$start = 789; // Long | 
$end = 789; // Long | 
$netflowFilter = netflowFilter_example; // String | 
$needMessage = true; // Boolean | 
$customColumns = customColumns_example; // String | 
$bound = bound_example; // String | 
$fields = fields_example; // String | 
$size = 56; // Integer | 
$offset = 56; // Integer | 
$filter = filter_example; // String | 

try {
    $result = $api_instance->getAlertListByDeviceId($id, $start, $end, $netflowFilter, $needMessage, $customColumns, $bound, $fields, $size, $offset, $filter);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->getAlertListByDeviceId: ', $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 $start = 789; # Long | 
my $end = 789; # Long | 
my $netflowFilter = netflowFilter_example; # String | 
my $needMessage = true; # Boolean | 
my $customColumns = customColumns_example; # String | 
my $bound = bound_example; # String | 
my $fields = fields_example; # String | 
my $size = 56; # Integer | 
my $offset = 56; # Integer | 
my $filter = filter_example; # String | 

eval { 
    my $result = $api_instance->getAlertListByDeviceId(id => $id, start => $start, end => $end, netflowFilter => $netflowFilter, needMessage => $needMessage, customColumns => $customColumns, bound => $bound, fields => $fields, size => $size, offset => $offset, filter => $filter);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->getAlertListByDeviceId: $@\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))
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
try:
    # get alerts
    api_response = api_instance.get_alert_list_by_device_id(id, start=start, end=end, netflowFilter=netflowFilter, needMessage=needMessage, customColumns=customColumns, bound=bound, fields=fields, size=size, offset=offset, filter=filter)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->getAlertListByDeviceId: %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.NewGetAlertListByDeviceIDParams()
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
    

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

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 | 
        String fields = fields_example; // String | 
        try {
            AlertRule result = apiInstance.getAlertRuleById(id, fields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAlertRuleById");
            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 | 
        String fields = fields_example; // String | 
        try {
            AlertRule result = apiInstance.getAlertRuleById(id, fields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAlertRuleById");
            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; // 
String *fields = fields_example; //  (optional)

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

// get alert rule by id
[apiInstance getAlertRuleByIdWith:id
    fields:fields
              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 id = 56; // {Integer} 

var opts = { 
  'fields': fields_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAlertRuleById(id, opts, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class getAlertRuleByIdExample
    {
        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 fields = fields_example;  // String |  (optional) 

            try
            {
                // get alert rule by id
                AlertRule result = apiInstance.getAlertRuleById(id, fields);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.getAlertRuleById: " + 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 | 
$fields = fields_example; // String | 

try {
    $result = $api_instance->getAlertRuleById($id, $fields);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->getAlertRuleById: ', $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 $fields = fields_example; # String | 

eval { 
    my $result = $api_instance->getAlertRuleById(id => $id, fields => $fields);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->getAlertRuleById: $@\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))
    

        
    
    

        
    
try:
    # get alert rule by id
    api_response = api_instance.get_alert_rule_by_id(id, fields=fields)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->getAlertRuleById: %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.NewGetAlertRuleByIDParams()
    

        
    
    

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

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();
        String fields = fields_example; // String | 
        Integer size = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String filter = filter_example; // String | 
        try {
            AlertRulePaginationResponse result = apiInstance.getAlertRuleList(fields, size, offset, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAlertRuleList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        String fields = fields_example; // String | 
        Integer size = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String filter = filter_example; // String | 
        try {
            AlertRulePaginationResponse result = apiInstance.getAlertRuleList(fields, size, offset, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAlertRuleList");
            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"];

String *fields = fields_example; //  (optional)
Integer *size = 56; //  (optional)
Integer *offset = 56; //  (optional)
String *filter = filter_example; //  (optional)

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

// get alert rule list
[apiInstance getAlertRuleListWith:fields
    size:size
    offset:offset
    filter:filter
              completionHandler: ^(AlertRulePaginationResponse 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 = { 
  'fields': fields_example, // {String} 
  'size': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'filter': filter_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAlertRuleList(opts, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class getAlertRuleListExample
    {
        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 fields = fields_example;  // String |  (optional) 
            var size = 56;  // Integer |  (optional) 
            var offset = 56;  // Integer |  (optional) 
            var filter = filter_example;  // String |  (optional) 

            try
            {
                // get alert rule list
                AlertRulePaginationResponse result = apiInstance.getAlertRuleList(fields, size, offset, filter);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.getAlertRuleList: " + 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();
$fields = fields_example; // String | 
$size = 56; // Integer | 
$offset = 56; // Integer | 
$filter = filter_example; // String | 

try {
    $result = $api_instance->getAlertRuleList($fields, $size, $offset, $filter);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->getAlertRuleList: ', $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 $fields = fields_example; # String | 
my $size = 56; # Integer | 
my $offset = 56; # Integer | 
my $filter = filter_example; # String | 

eval { 
    my $result = $api_instance->getAlertRuleList(fields => $fields, size => $size, offset => $offset, filter => $filter);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->getAlertRuleList: $@\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))
    

        
    
    

        
    
    

        
    
    

        
    
try:
    # get alert rule list
    api_response = api_instance.get_alert_rule_list(fields=fields, size=size, offset=offset, filter=filter)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->getAlertRuleList: %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.NewGetAlertRuleListParams()
    

        
    
    

        
    
    

        
    
    

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

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 | 
        Long start = 789; // Long | 
        Long end = 789; // Long | 
        String netflowFilter = netflowFilter_example; // String | 
        String fields = fields_example; // String | 
        Integer size = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String filter = filter_example; // String | 
        try {
            SDTPaginationResponse result = apiInstance.getAllSDTListByDeviceId(id, start, end, netflowFilter, fields, size, offset, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAllSDTListByDeviceId");
            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 | 
        Long start = 789; // Long | 
        Long end = 789; // Long | 
        String netflowFilter = netflowFilter_example; // String | 
        String fields = fields_example; // String | 
        Integer size = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String filter = filter_example; // String | 
        try {
            SDTPaginationResponse result = apiInstance.getAllSDTListByDeviceId(id, start, end, netflowFilter, fields, size, offset, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAllSDTListByDeviceId");
            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; // 
Long *start = 789; //  (optional)
Long *end = 789; //  (optional)
String *netflowFilter = netflowFilter_example; //  (optional)
String *fields = fields_example; //  (optional)
Integer *size = 56; //  (optional)
Integer *offset = 56; //  (optional)
String *filter = filter_example; //  (optional)

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

// get SDTs for a device
[apiInstance getAllSDTListByDeviceIdWith:id
    start:start
    end:end
    netflowFilter:netflowFilter
    fields:fields
    size:size
    offset:offset
    filter:filter
              completionHandler: ^(SDTPaginationResponse 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 opts = { 
  'start': 789, // {Long} 
  'end': 789, // {Long} 
  'netflowFilter': netflowFilter_example, // {String} 
  'fields': fields_example, // {String} 
  'size': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'filter': filter_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAllSDTListByDeviceId(id, opts, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class getAllSDTListByDeviceIdExample
    {
        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 start = 789;  // Long |  (optional) 
            var end = 789;  // Long |  (optional) 
            var netflowFilter = netflowFilter_example;  // String |  (optional) 
            var fields = fields_example;  // String |  (optional) 
            var size = 56;  // Integer |  (optional) 
            var offset = 56;  // Integer |  (optional) 
            var filter = filter_example;  // String |  (optional) 

            try
            {
                // get SDTs for a device
                SDTPaginationResponse result = apiInstance.getAllSDTListByDeviceId(id, start, end, netflowFilter, fields, size, offset, filter);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.getAllSDTListByDeviceId: " + 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 | 
$start = 789; // Long | 
$end = 789; // Long | 
$netflowFilter = netflowFilter_example; // String | 
$fields = fields_example; // String | 
$size = 56; // Integer | 
$offset = 56; // Integer | 
$filter = filter_example; // String | 

try {
    $result = $api_instance->getAllSDTListByDeviceId($id, $start, $end, $netflowFilter, $fields, $size, $offset, $filter);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->getAllSDTListByDeviceId: ', $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 $start = 789; # Long | 
my $end = 789; # Long | 
my $netflowFilter = netflowFilter_example; # String | 
my $fields = fields_example; # String | 
my $size = 56; # Integer | 
my $offset = 56; # Integer | 
my $filter = filter_example; # String | 

eval { 
    my $result = $api_instance->getAllSDTListByDeviceId(id => $id, start => $start, end => $end, netflowFilter => $netflowFilter, fields => $fields, size => $size, offset => $offset, filter => $filter);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->getAllSDTListByDeviceId: $@\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))
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
try:
    # get SDTs for a device
    api_response = api_instance.get_all_sdt_list_by_device_id(id, start=start, end=end, netflowFilter=netflowFilter, fields=fields, size=size, offset=offset, filter=filter)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->getAllSDTListByDeviceId: %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.NewGetAllSDTListByDeviceIDParams()
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
    

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

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 | 
        String fields = fields_example; // String | 
        Integer size = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String filter = filter_example; // String | 
        try {
            SDTPaginationResponse result = apiInstance.getAllSDTListByWebsiteGroupId(id, fields, size, offset, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAllSDTListByWebsiteGroupId");
            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 | 
        String fields = fields_example; // String | 
        Integer size = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String filter = filter_example; // String | 
        try {
            SDTPaginationResponse result = apiInstance.getAllSDTListByWebsiteGroupId(id, fields, size, offset, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAllSDTListByWebsiteGroupId");
            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; // 
String *fields = fields_example; //  (optional)
Integer *size = 56; //  (optional)
Integer *offset = 56; //  (optional)
String *filter = filter_example; //  (optional)

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

// get a list of SDTs for a website group
[apiInstance getAllSDTListByWebsiteGroupIdWith:id
    fields:fields
    size:size
    offset:offset
    filter:filter
              completionHandler: ^(SDTPaginationResponse 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 opts = { 
  'fields': fields_example, // {String} 
  'size': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'filter': filter_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAllSDTListByWebsiteGroupId(id, opts, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class getAllSDTListByWebsiteGroupIdExample
    {
        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 fields = fields_example;  // String |  (optional) 
            var size = 56;  // Integer |  (optional) 
            var offset = 56;  // Integer |  (optional) 
            var filter = filter_example;  // String |  (optional) 

            try
            {
                // get a list of SDTs for a website group
                SDTPaginationResponse result = apiInstance.getAllSDTListByWebsiteGroupId(id, fields, size, offset, filter);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.getAllSDTListByWebsiteGroupId: " + 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 | 
$fields = fields_example; // String | 
$size = 56; // Integer | 
$offset = 56; // Integer | 
$filter = filter_example; // String | 

try {
    $result = $api_instance->getAllSDTListByWebsiteGroupId($id, $fields, $size, $offset, $filter);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->getAllSDTListByWebsiteGroupId: ', $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 $fields = fields_example; # String | 
my $size = 56; # Integer | 
my $offset = 56; # Integer | 
my $filter = filter_example; # String | 

eval { 
    my $result = $api_instance->getAllSDTListByWebsiteGroupId(id => $id, fields => $fields, size => $size, offset => $offset, filter => $filter);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->getAllSDTListByWebsiteGroupId: $@\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))
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
try:
    # get a list of SDTs for a website group
    api_response = api_instance.get_all_sdt_list_by_website_group_id(id, fields=fields, size=size, offset=offset, filter=filter)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->getAllSDTListByWebsiteGroupId: %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.NewGetAllSDTListByWebsiteGroupIDParams()
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
// get a list of SDTs for a website group
resp, err := client.LM.GetAllSDTListByWebsiteGroupID(params)
if err != nil {
fmt.Printf("Exception when calling client.LM.GetAllSDTListByWebsiteGroupID: %v", err.Error())
}
fmt.Print(resp)
}

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();
        String fields = fields_example; // String | 
        Integer size = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String filter = filter_example; // String | 
        try {
            ApiTokenPaginationResponse result = apiInstance.getApiTokenList(fields, size, offset, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getApiTokenList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        String fields = fields_example; // String | 
        Integer size = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String filter = filter_example; // String | 
        try {
            ApiTokenPaginationResponse result = apiInstance.getApiTokenList(fields, size, offset, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getApiTokenList");
            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"];

String *fields = fields_example; //  (optional)
Integer *size = 56; //  (optional)
Integer *offset = 56; //  (optional)
String *filter = filter_example; //  (optional)

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

// get a list of api tokens across users
[apiInstance getApiTokenListWith:fields
    size:size
    offset:offset
    filter:filter
              completionHandler: ^(ApiTokenPaginationResponse 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 = { 
  'fields': fields_example, // {String} 
  'size': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'filter': filter_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getApiTokenList(opts, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class getApiTokenListExample
    {
        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 fields = fields_example;  // String |  (optional) 
            var size = 56;  // Integer |  (optional) 
            var offset = 56;  // Integer |  (optional) 
            var filter = filter_example;  // String |  (optional) 

            try
            {
                // get a list of api tokens across users
                ApiTokenPaginationResponse result = apiInstance.getApiTokenList(fields, size, offset, filter);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.getApiTokenList: " + 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();
$fields = fields_example; // String | 
$size = 56; // Integer | 
$offset = 56; // Integer | 
$filter = filter_example; // String | 

try {
    $result = $api_instance->getApiTokenList($fields, $size, $offset, $filter);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->getApiTokenList: ', $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 $fields = fields_example; # String | 
my $size = 56; # Integer | 
my $offset = 56; # Integer | 
my $filter = filter_example; # String | 

eval { 
    my $result = $api_instance->getApiTokenList(fields => $fields, size => $size, offset => $offset, filter => $filter);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->getApiTokenList: $@\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))
    

        
    
    

        
    
    

        
    
    

        
    
try:
    # get a list of api tokens across users
    api_response = api_instance.get_api_token_list(fields=fields, size=size, offset=offset, filter=filter)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->getApiTokenList: %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.NewGetAPITokenListParams()
    

        
    
    

        
    
    

        
    
    

        
    
// get a list of api tokens across users
resp, err := client.LM.GetAPITokenList(params)
if err != nil {
fmt.Printf("Exception when calling client.LM.GetAPITokenList: %v", err.Error())
}
fmt.Print(resp)
}

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 | 
        String fields = fields_example; // String | 
        Integer size = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String filter = filter_example; // String | 
        try {
            ApiTokenPaginationResponse result = apiInstance.getApiTokenListByAdminId(adminId, fields, size, offset, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getApiTokenListByAdminId");
            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 | 
        String fields = fields_example; // String | 
        Integer size = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String filter = filter_example; // String | 
        try {
            ApiTokenPaginationResponse result = apiInstance.getApiTokenListByAdminId(adminId, fields, size, offset, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getApiTokenListByAdminId");
            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; // 
String *fields = fields_example; //  (optional)
Integer *size = 56; //  (optional)
Integer *offset = 56; //  (optional)
String *filter = filter_example; //  (optional)

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

// get api tokens for a user
[apiInstance getApiTokenListByAdminIdWith:adminId
    fields:fields
    size:size
    offset:offset
    filter:filter
              completionHandler: ^(ApiTokenPaginationResponse 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 opts = { 
  'fields': fields_example, // {String} 
  'size': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'filter': filter_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getApiTokenListByAdminId(adminId, opts, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class getApiTokenListByAdminIdExample
    {
        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 fields = fields_example;  // String |  (optional) 
            var size = 56;  // Integer |  (optional) 
            var offset = 56;  // Integer |  (optional) 
            var filter = filter_example;  // String |  (optional) 

            try
            {
                // get api tokens for a user
                ApiTokenPaginationResponse result = apiInstance.getApiTokenListByAdminId(adminId, fields, size, offset, filter);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.getApiTokenListByAdminId: " + 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 | 
$fields = fields_example; // String | 
$size = 56; // Integer | 
$offset = 56; // Integer | 
$filter = filter_example; // String | 

try {
    $result = $api_instance->getApiTokenListByAdminId($adminId, $fields, $size, $offset, $filter);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->getApiTokenListByAdminId: ', $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 $fields = fields_example; # String | 
my $size = 56; # Integer | 
my $offset = 56; # Integer | 
my $filter = filter_example; # String | 

eval { 
    my $result = $api_instance->getApiTokenListByAdminId(adminId => $adminId, fields => $fields, size => $size, offset => $offset, filter => $filter);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->getApiTokenListByAdminId: $@\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))
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
try:
    # get api tokens for a user
    api_response = api_instance.get_api_token_list_by_admin_id(adminId, fields=fields, size=size, offset=offset, filter=filter)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->getApiTokenListByAdminId: %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.NewGetAPITokenListByAdminIDParams()
    

        
    
    

        
    
    

        
    
    

        
    
    

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

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 | 
        try {
            AppliesToFunction result = apiInstance.getAppliesToFunctionById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAppliesToFunctionById");
            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 | 
        try {
            AppliesToFunction result = apiInstance.getAppliesToFunctionById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAppliesToFunctionById");
            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; // 

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

// get applies to function
[apiInstance getAppliesToFunctionByIdWith:id
              completionHandler: ^(AppliesToFunction 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 callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAppliesToFunctionById(id, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class getAppliesToFunctionByIdExample
    {
        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 | 

            try
            {
                // get applies to function
                AppliesToFunction result = apiInstance.getAppliesToFunctionById(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.getAppliesToFunctionById: " + 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 | 

try {
    $result = $api_instance->getAppliesToFunctionById($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->getAppliesToFunctionById: ', $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 | 

eval { 
    my $result = $api_instance->getAppliesToFunctionById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->getAppliesToFunctionById: $@\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))
    

        
    
try:
    # get applies to function
    api_response = api_instance.get_applies_to_function_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->getAppliesToFunctionById: %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.NewGetAppliesToFunctionByIDParams()
    

        
    
// get applies to function
resp, err := client.LM.GetAppliesToFunctionByID(params)
if err != nil {
fmt.Printf("Exception when calling client.LM.GetAppliesToFunctionByID: %v", err.Error())
}
fmt.Print(resp)
}

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();
        String fields = fields_example; // String | 
        Integer size = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String filter = filter_example; // String | 
        try {
            RestAppliesToFunctionPaginationResponse result = apiInstance.getAppliesToFunctionList(fields, size, offset, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAppliesToFunctionList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        String fields = fields_example; // String | 
        Integer size = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String filter = filter_example; // String | 
        try {
            RestAppliesToFunctionPaginationResponse result = apiInstance.getAppliesToFunctionList(fields, size, offset, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAppliesToFunctionList");
            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"];

String *fields = fields_example; //  (optional)
Integer *size = 56; //  (optional)
Integer *offset = 56; //  (optional)
String *filter = filter_example; //  (optional)

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

// get applies to function list
[apiInstance getAppliesToFunctionListWith:fields
    size:size
    offset:offset
    filter:filter
              completionHandler: ^(RestAppliesToFunctionPaginationResponse 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 = { 
  'fields': fields_example, // {String} 
  'size': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'filter': filter_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAppliesToFunctionList(opts, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class getAppliesToFunctionListExample
    {
        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 fields = fields_example;  // String |  (optional) 
            var size = 56;  // Integer |  (optional) 
            var offset = 56;  // Integer |  (optional) 
            var filter = filter_example;  // String |  (optional) 

            try
            {
                // get applies to function list
                RestAppliesToFunctionPaginationResponse result = apiInstance.getAppliesToFunctionList(fields, size, offset, filter);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.getAppliesToFunctionList: " + 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();
$fields = fields_example; // String | 
$size = 56; // Integer | 
$offset = 56; // Integer | 
$filter = filter_example; // String | 

try {
    $result = $api_instance->getAppliesToFunctionList($fields, $size, $offset, $filter);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->getAppliesToFunctionList: ', $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 $fields = fields_example; # String | 
my $size = 56; # Integer | 
my $offset = 56; # Integer | 
my $filter = filter_example; # String | 

eval { 
    my $result = $api_instance->getAppliesToFunctionList(fields => $fields, size => $size, offset => $offset, filter => $filter);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->getAppliesToFunctionList: $@\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))
    

        
    
    

        
    
    

        
    
    

        
    
try:
    # get applies to function list
    api_response = api_instance.get_applies_to_function_list(fields=fields, size=size, offset=offset, filter=filter)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->getAppliesToFunctionList: %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.NewGetAppliesToFunctionListParams()
    

        
    
    

        
    
    

        
    
    

        
    
// get applies to function list
resp, err := client.LM.GetAppliesToFunctionList(params)
if err != nil {
fmt.Printf("Exception when calling client.LM.GetAppliesToFunctionList: %v", err.Error())
}
fmt.Print(resp)
}

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 | 
        String fields = fields_example; // String | 
        Integer size = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String filter = filter_example; // String | 
        try {
            DeviceDataSourceAssociatedPaginationResponse result = apiInstance.getAssociatedDeviceListByDataSourceId(id, fields, size, offset, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAssociatedDeviceListByDataSourceId");
            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 | 
        String fields = fields_example; // String | 
        Integer size = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String filter = filter_example; // String | 
        try {
            DeviceDataSourceAssociatedPaginationResponse result = apiInstance.getAssociatedDeviceListByDataSourceId(id, fields, size, offset, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAssociatedDeviceListByDataSourceId");
            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; // 
String *fields = fields_example; //  (optional)
Integer *size = 56; //  (optional)
Integer *offset = 56; //  (optional)
String *filter = filter_example; //  (optional)

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

// get devices associated with a datasource
[apiInstance getAssociatedDeviceListByDataSourceIdWith:id
    fields:fields
    size:size
    offset:offset
    filter:filter
              completionHandler: ^(DeviceDataSourceAssociatedPaginationResponse 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 opts = { 
  'fields': fields_example, // {String} 
  'size': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'filter': filter_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAssociatedDeviceListByDataSourceId(id, opts, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class getAssociatedDeviceListByDataSourceIdExample
    {
        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 fields = fields_example;  // String |  (optional) 
            var size = 56;  // Integer |  (optional) 
            var offset = 56;  // Integer |  (optional) 
            var filter = filter_example;  // String |  (optional) 

            try
            {
                // get devices associated with a datasource
                DeviceDataSourceAssociatedPaginationResponse result = apiInstance.getAssociatedDeviceListByDataSourceId(id, fields, size, offset, filter);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.getAssociatedDeviceListByDataSourceId: " + 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 | 
$fields = fields_example; // String | 
$size = 56; // Integer | 
$offset = 56; // Integer | 
$filter = filter_example; // String | 

try {
    $result = $api_instance->getAssociatedDeviceListByDataSourceId($id, $fields, $size, $offset, $filter);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->getAssociatedDeviceListByDataSourceId: ', $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 $fields = fields_example; # String | 
my $size = 56; # Integer | 
my $offset = 56; # Integer | 
my $filter = filter_example; # String | 

eval { 
    my $result = $api_instance->getAssociatedDeviceListByDataSourceId(id => $id, fields => $fields, size => $size, offset => $offset, filter => $filter);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->getAssociatedDeviceListByDataSourceId: $@\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))
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
try:
    # get devices associated with a datasource
    api_response = api_instance.get_associated_device_list_by_data_source_id(id, fields=fields, size=size, offset=offset, filter=filter)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->getAssociatedDeviceListByDataSourceId: %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.NewGetAssociatedDeviceListByDataSourceIDParams()
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
// get devices associated with a datasource
resp, err := client.LM.GetAssociatedDeviceListByDataSourceID(params)
if err != nil {
fmt.Printf("Exception when calling client.LM.GetAssociatedDeviceListByDataSourceID: %v", err.Error())
}
fmt.Print(resp)
}

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();
        String id = id_example; // String | 
        try {
            AuditLog result = apiInstance.getAuditLogById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAuditLogById");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        String id = id_example; // String | 
        try {
            AuditLog result = apiInstance.getAuditLogById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAuditLogById");
            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"];

String *id = id_example; // 

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

// Get audit log by id
[apiInstance getAuditLogByIdWith:id
              completionHandler: ^(AuditLog 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 = id_example; // {String} 


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAuditLogById(id, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class getAuditLogByIdExample
    {
        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 = id_example;  // String | 

            try
            {
                // Get audit log by id
                AuditLog result = apiInstance.getAuditLogById(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.getAuditLogById: " + 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 = id_example; // String | 

try {
    $result = $api_instance->getAuditLogById($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->getAuditLogById: ', $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 = id_example; # String | 

eval { 
    my $result = $api_instance->getAuditLogById(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->getAuditLogById: $@\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))
    

        
    
try:
    # Get audit log by id
    api_response = api_instance.get_audit_log_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->getAuditLogById: %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.NewGetAuditLogByIDParams()
    

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

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();
        String format = format_example; // String | 
        String fields = fields_example; // String | 
        Integer size = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String filter = filter_example; // String | 
        try {
            AccessLogPaginationResponse result = apiInstance.getAuditLogList(format, fields, size, offset, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAuditLogList");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        String format = format_example; // String | 
        String fields = fields_example; // String | 
        Integer size = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String filter = filter_example; // String | 
        try {
            AccessLogPaginationResponse result = apiInstance.getAuditLogList(format, fields, size, offset, filter);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAuditLogList");
            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"];

String *format = format_example; //  (optional)
String *fields = fields_example; //  (optional)
Integer *size = 56; //  (optional)
Integer *offset = 56; //  (optional)
String *filter = filter_example; //  (optional)

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

// Get audit logs
[apiInstance getAuditLogListWith:format
    fields:fields
    size:size
    offset:offset
    filter:filter
              completionHandler: ^(AccessLogPaginationResponse 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 = { 
  'format': format_example, // {String} 
  'fields': fields_example, // {String} 
  'size': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'filter': filter_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAuditLogList(opts, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class getAuditLogListExample
    {
        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 format = format_example;  // String |  (optional) 
            var fields = fields_example;  // String |  (optional) 
            var size = 56;  // Integer |  (optional) 
            var offset = 56;  // Integer |  (optional) 
            var filter = filter_example;  // String |  (optional) 

            try
            {
                // Get audit logs
                AccessLogPaginationResponse result = apiInstance.getAuditLogList(format, fields, size, offset, filter);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.getAuditLogList: " + 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();
$format = format_example; // String | 
$fields = fields_example; // String | 
$size = 56; // Integer | 
$offset = 56; // Integer | 
$filter = filter_example; // String | 

try {
    $result = $api_instance->getAuditLogList($format, $fields, $size, $offset, $filter);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->getAuditLogList: ', $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 $format = format_example; # String | 
my $fields = fields_example; # String | 
my $size = 56; # Integer | 
my $offset = 56; # Integer | 
my $filter = filter_example; # String | 

eval { 
    my $result = $api_instance->getAuditLogList(format => $format, fields => $fields, size => $size, offset => $offset, filter => $filter);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->getAuditLogList: $@\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))
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
try:
    # Get audit logs
    api_response = api_instance.get_audit_log_list(format=format, fields=fields, size=size, offset=offset, filter=filter)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->getAuditLogList: %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.NewGetAuditLogListParams()
    

        
    
    

        
    
    

        
    
    

        
    
    

        
    
// Get audit logs
resp, err := client.LM.GetAuditLogList(params)
if err != nil {
fmt.Printf("Exception when calling client.LM.GetAuditLogList: %v", err.Error())
}
fmt.Print(resp)
}

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();
        try {
            AwsExternalId result = apiInstance.getAwsExternalId();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAwsExternalId");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LMApi;

public class LMApiExample {

    public static void main(String[] args) {
        LMApi apiInstance = new LMApi();
        try {
            AwsExternalId result = apiInstance.getAwsExternalId();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getAwsExternalId");
            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"];


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

// Get AWS external id
[apiInstance getAwsExternalIdWithCompletionHandler: 
              ^(AwsExternalId 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 callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAwsExternalId(callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class getAwsExternalIdExample
    {
        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();

            try
            {
                // Get AWS external id
                AwsExternalId result = apiInstance.getAwsExternalId();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.getAwsExternalId: " + 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();

try {
    $result = $api_instance->getAwsExternalId();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->getAwsExternalId: ', $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();

eval { 
    my $result = $api_instance->getAwsExternalId();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->getAwsExternalId: $@\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))
try:
    # Get AWS external id
    api_response = api_instance.get_aws_external_id()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->getAwsExternalId: %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.NewGetAwsExternalIDParams()
// Get AWS external id
resp, err := client.LM.GetAwsExternalID(params)
if err != nil {
fmt.Printf("Exception when calling client.LM.GetAwsExternalID: %v", err.Error())
}
fmt.Print(resp)
}

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 | 
        String fields = fields_example; // String | 
        try {
            Collector result = apiInstance.getCollectorById(id, fields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getCollectorById");
            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 | 
        String fields = fields_example; // String | 
        try {
            Collector result = apiInstance.getCollectorById(id, fields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LMApi#getCollectorById");
            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; // 
String *fields = fields_example; //  (optional)

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

// get collector
[apiInstance getCollectorByIdWith:id
    fields:fields
              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 id = 56; // {Integer} 

var opts = { 
  'fields': fields_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getCollectorById(id, opts, callback);

using System;
using System.Diagnostics;
using logicmonitor_sdk.Api;
using logicmonitor_sdk.Client;
using logicmonitor_sdk.Model;

namespace Example
{
    public class getCollectorByIdExample
    {
        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 fields = fields_example;  // String |  (optional) 

            try
            {
                // get collector
                Collector result = apiInstance.getCollectorById(id, fields);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LMApi.getCollectorById: " + 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 | 
$fields = fields_example; // String | 

try {
    $result = $api_instance->getCollectorById($id, $fields);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LMApi->getCollectorById: ', $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 $fields = fields_example; # String | 

eval { 
    my $result = $api_instance->getCollectorById(id => $id, fields => $fields);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LMApi->getCollectorById: $@\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))
    

        
    
    

        
    
try:
    # get collector
    api_response = api_instance.get_collector_by_id(id, fields=fields)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LMApi->getCollectorById: %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.NewGetCollectorByIDParams()
    

        
    
    

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