import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        LmA2AHandoffRulesEntry lmA2AHandoffRulesEntry = ; // LmA2AHandoffRulesEntry | 
        try {
            lmA2AHandoffRulesEntry result = apiInstance.createLmA2AHandoffRulesTableEntry(lmA2AHandoffRulesEntry);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createLmA2AHandoffRulesTableEntry");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        LmA2AHandoffRulesEntry lmA2AHandoffRulesEntry = ; // LmA2AHandoffRulesEntry | 
        try {
            lmA2AHandoffRulesEntry result = apiInstance.createLmA2AHandoffRulesTableEntry(lmA2AHandoffRulesEntry);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createLmA2AHandoffRulesTableEntry");
            e.printStackTrace();
        }
    }
}

LmA2AHandoffRulesEntry *lmA2AHandoffRulesEntry = ; // 

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

// Creates a row of the lmA2AHandoffRulesTable Table
[apiInstance createLmA2AHandoffRulesTableEntryWith:lmA2AHandoffRulesEntry
              completionHandler: ^(lmA2AHandoffRulesEntry output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

var lmA2AHandoffRulesEntry = ; // {LmA2AHandoffRulesEntry} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createLmA2AHandoffRulesTableEntryExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var lmA2AHandoffRulesEntry = new LmA2AHandoffRulesEntry(); // LmA2AHandoffRulesEntry | 

            try
            {
                // Creates a row of the lmA2AHandoffRulesTable Table
                lmA2AHandoffRulesEntry result = apiInstance.createLmA2AHandoffRulesTableEntry(lmA2AHandoffRulesEntry);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createLmA2AHandoffRulesTableEntry: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$lmA2AHandoffRulesEntry = ; // LmA2AHandoffRulesEntry | 

try {
    $result = $api_instance->createLmA2AHandoffRulesTableEntry($lmA2AHandoffRulesEntry);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->createLmA2AHandoffRulesTableEntry: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $lmA2AHandoffRulesEntry = WWW::SwaggerClient::Object::LmA2AHandoffRulesEntry->new(); # LmA2AHandoffRulesEntry | 

eval { 
    my $result = $api_instance->createLmA2AHandoffRulesTableEntry(lmA2AHandoffRulesEntry => $lmA2AHandoffRulesEntry);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createLmA2AHandoffRulesTableEntry: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
lmA2AHandoffRulesEntry =  # LmA2AHandoffRulesEntry | 

try: 
    # Creates a row of the lmA2AHandoffRulesTable Table
    api_response = api_instance.create_lm_a2_a_handoff_rules_table_entry(lmA2AHandoffRulesEntry)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->createLmA2AHandoffRulesTableEntry: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        LmRxLinksEntry lmRxLinksEntry = ; // LmRxLinksEntry | 
        try {
            lmRxLinksEntry result = apiInstance.createLmRxLinksTableEntry(lmRxLinksEntry);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createLmRxLinksTableEntry");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        LmRxLinksEntry lmRxLinksEntry = ; // LmRxLinksEntry | 
        try {
            lmRxLinksEntry result = apiInstance.createLmRxLinksTableEntry(lmRxLinksEntry);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createLmRxLinksTableEntry");
            e.printStackTrace();
        }
    }
}

LmRxLinksEntry *lmRxLinksEntry = ; // 

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

// Creates a row of the lmRxLinksTable Table
[apiInstance createLmRxLinksTableEntryWith:lmRxLinksEntry
              completionHandler: ^(lmRxLinksEntry output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

var lmRxLinksEntry = ; // {LmRxLinksEntry} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createLmRxLinksTableEntryExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var lmRxLinksEntry = new LmRxLinksEntry(); // LmRxLinksEntry | 

            try
            {
                // Creates a row of the lmRxLinksTable Table
                lmRxLinksEntry result = apiInstance.createLmRxLinksTableEntry(lmRxLinksEntry);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createLmRxLinksTableEntry: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$lmRxLinksEntry = ; // LmRxLinksEntry | 

try {
    $result = $api_instance->createLmRxLinksTableEntry($lmRxLinksEntry);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->createLmRxLinksTableEntry: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $lmRxLinksEntry = WWW::SwaggerClient::Object::LmRxLinksEntry->new(); # LmRxLinksEntry | 

eval { 
    my $result = $api_instance->createLmRxLinksTableEntry(lmRxLinksEntry => $lmRxLinksEntry);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createLmRxLinksTableEntry: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
lmRxLinksEntry =  # LmRxLinksEntry | 

try: 
    # Creates a row of the lmRxLinksTable Table
    api_response = api_instance.create_lm_rx_links_table_entry(lmRxLinksEntry)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->createLmRxLinksTableEntry: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        LmTxLinksEntry lmTxLinksEntry = ; // LmTxLinksEntry | 
        try {
            lmTxLinksEntry result = apiInstance.createLmTxLinksTableEntry(lmTxLinksEntry);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createLmTxLinksTableEntry");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        LmTxLinksEntry lmTxLinksEntry = ; // LmTxLinksEntry | 
        try {
            lmTxLinksEntry result = apiInstance.createLmTxLinksTableEntry(lmTxLinksEntry);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createLmTxLinksTableEntry");
            e.printStackTrace();
        }
    }
}

LmTxLinksEntry *lmTxLinksEntry = ; // 

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

// Creates a row of the lmTxLinksTable Table
[apiInstance createLmTxLinksTableEntryWith:lmTxLinksEntry
              completionHandler: ^(lmTxLinksEntry output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

var lmTxLinksEntry = ; // {LmTxLinksEntry} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createLmTxLinksTableEntryExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var lmTxLinksEntry = new LmTxLinksEntry(); // LmTxLinksEntry | 

            try
            {
                // Creates a row of the lmTxLinksTable Table
                lmTxLinksEntry result = apiInstance.createLmTxLinksTableEntry(lmTxLinksEntry);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createLmTxLinksTableEntry: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$lmTxLinksEntry = ; // LmTxLinksEntry | 

try {
    $result = $api_instance->createLmTxLinksTableEntry($lmTxLinksEntry);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->createLmTxLinksTableEntry: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $lmTxLinksEntry = WWW::SwaggerClient::Object::LmTxLinksEntry->new(); # LmTxLinksEntry | 

eval { 
    my $result = $api_instance->createLmTxLinksTableEntry(lmTxLinksEntry => $lmTxLinksEntry);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createLmTxLinksTableEntry: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
lmTxLinksEntry =  # LmTxLinksEntry | 

try: 
    # Creates a row of the lmTxLinksTable Table
    api_response = api_instance.create_lm_tx_links_table_entry(lmTxLinksEntry)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->createLmTxLinksTableEntry: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        ManagedElementEntry managedElementEntry = ; // ManagedElementEntry | 
        try {
            managedElementEntry result = apiInstance.createManagedElementTableEntry(managedElementEntry);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createManagedElementTableEntry");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        ManagedElementEntry managedElementEntry = ; // ManagedElementEntry | 
        try {
            managedElementEntry result = apiInstance.createManagedElementTableEntry(managedElementEntry);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createManagedElementTableEntry");
            e.printStackTrace();
        }
    }
}

ManagedElementEntry *managedElementEntry = ; // 

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

// Creates a row of the managedElementTable Table
[apiInstance createManagedElementTableEntryWith:managedElementEntry
              completionHandler: ^(managedElementEntry output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

var managedElementEntry = ; // {ManagedElementEntry} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createManagedElementTableEntryExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var managedElementEntry = new ManagedElementEntry(); // ManagedElementEntry | 

            try
            {
                // Creates a row of the managedElementTable Table
                managedElementEntry result = apiInstance.createManagedElementTableEntry(managedElementEntry);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createManagedElementTableEntry: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$managedElementEntry = ; // ManagedElementEntry | 

try {
    $result = $api_instance->createManagedElementTableEntry($managedElementEntry);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->createManagedElementTableEntry: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $managedElementEntry = WWW::SwaggerClient::Object::ManagedElementEntry->new(); # ManagedElementEntry | 

eval { 
    my $result = $api_instance->createManagedElementTableEntry(managedElementEntry => $managedElementEntry);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createManagedElementTableEntry: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
managedElementEntry =  # ManagedElementEntry | 

try: 
    # Creates a row of the managedElementTable Table
    api_response = api_instance.create_managed_element_table_entry(managedElementEntry)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->createManagedElementTableEntry: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        SampleEntry sampleEntry = ; // SampleEntry | 
        try {
            sampleEntry result = apiInstance.createSampleTableEntry(sampleEntry);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createSampleTableEntry");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        SampleEntry sampleEntry = ; // SampleEntry | 
        try {
            sampleEntry result = apiInstance.createSampleTableEntry(sampleEntry);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createSampleTableEntry");
            e.printStackTrace();
        }
    }
}

SampleEntry *sampleEntry = ; // 

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

// Creates a row of the sampleTable Table
[apiInstance createSampleTableEntryWith:sampleEntry
              completionHandler: ^(sampleEntry output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

var sampleEntry = ; // {SampleEntry} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createSampleTableEntryExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var sampleEntry = new SampleEntry(); // SampleEntry | 

            try
            {
                // Creates a row of the sampleTable Table
                sampleEntry result = apiInstance.createSampleTableEntry(sampleEntry);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createSampleTableEntry: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$sampleEntry = ; // SampleEntry | 

try {
    $result = $api_instance->createSampleTableEntry($sampleEntry);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->createSampleTableEntry: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $sampleEntry = WWW::SwaggerClient::Object::SampleEntry->new(); # SampleEntry | 

eval { 
    my $result = $api_instance->createSampleTableEntry(sampleEntry => $sampleEntry);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createSampleTableEntry: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
sampleEntry =  # SampleEntry | 

try: 
    # Creates a row of the sampleTable Table
    api_response = api_instance.create_sample_table_entry(sampleEntry)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->createSampleTableEntry: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        TssRoutingEntry tssRoutingEntry = ; // TssRoutingEntry | 
        try {
            tssRoutingEntry result = apiInstance.createTssRoutingTableEntry(tssRoutingEntry);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createTssRoutingTableEntry");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        TssRoutingEntry tssRoutingEntry = ; // TssRoutingEntry | 
        try {
            tssRoutingEntry result = apiInstance.createTssRoutingTableEntry(tssRoutingEntry);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createTssRoutingTableEntry");
            e.printStackTrace();
        }
    }
}

TssRoutingEntry *tssRoutingEntry = ; // 

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

// Creates a row of the tssRoutingTable Table
[apiInstance createTssRoutingTableEntryWith:tssRoutingEntry
              completionHandler: ^(tssRoutingEntry output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

var tssRoutingEntry = ; // {TssRoutingEntry} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createTssRoutingTableEntryExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var tssRoutingEntry = new TssRoutingEntry(); // TssRoutingEntry | 

            try
            {
                // Creates a row of the tssRoutingTable Table
                tssRoutingEntry result = apiInstance.createTssRoutingTableEntry(tssRoutingEntry);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createTssRoutingTableEntry: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$tssRoutingEntry = ; // TssRoutingEntry | 

try {
    $result = $api_instance->createTssRoutingTableEntry($tssRoutingEntry);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->createTssRoutingTableEntry: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $tssRoutingEntry = WWW::SwaggerClient::Object::TssRoutingEntry->new(); # TssRoutingEntry | 

eval { 
    my $result = $api_instance->createTssRoutingTableEntry(tssRoutingEntry => $tssRoutingEntry);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createTssRoutingTableEntry: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
tssRoutingEntry =  # TssRoutingEntry | 

try: 
    # Creates a row of the tssRoutingTable Table
    api_response = api_instance.create_tss_routing_table_entry(tssRoutingEntry)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->createTssRoutingTableEntry: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        TssSrcSelEntry tssSrcSelEntry = ; // TssSrcSelEntry | 
        try {
            tssSrcSelEntry result = apiInstance.createTssSrcSelTableEntry(tssSrcSelEntry);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createTssSrcSelTableEntry");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        TssSrcSelEntry tssSrcSelEntry = ; // TssSrcSelEntry | 
        try {
            tssSrcSelEntry result = apiInstance.createTssSrcSelTableEntry(tssSrcSelEntry);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createTssSrcSelTableEntry");
            e.printStackTrace();
        }
    }
}

TssSrcSelEntry *tssSrcSelEntry = ; // 

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

// Creates a row of the tssSrcSelTable Table
[apiInstance createTssSrcSelTableEntryWith:tssSrcSelEntry
              completionHandler: ^(tssSrcSelEntry output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

var tssSrcSelEntry = ; // {TssSrcSelEntry} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createTssSrcSelTableEntryExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var tssSrcSelEntry = new TssSrcSelEntry(); // TssSrcSelEntry | 

            try
            {
                // Creates a row of the tssSrcSelTable Table
                tssSrcSelEntry result = apiInstance.createTssSrcSelTableEntry(tssSrcSelEntry);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createTssSrcSelTableEntry: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$tssSrcSelEntry = ; // TssSrcSelEntry | 

try {
    $result = $api_instance->createTssSrcSelTableEntry($tssSrcSelEntry);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->createTssSrcSelTableEntry: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $tssSrcSelEntry = WWW::SwaggerClient::Object::TssSrcSelEntry->new(); # TssSrcSelEntry | 

eval { 
    my $result = $api_instance->createTssSrcSelTableEntry(tssSrcSelEntry => $tssSrcSelEntry);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createTssSrcSelTableEntry: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
tssSrcSelEntry =  # TssSrcSelEntry | 

try: 
    # Creates a row of the tssSrcSelTable Table
    api_response = api_instance.create_tss_src_sel_table_entry(tssSrcSelEntry)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->createTssSrcSelTableEntry: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        TssTunnelEntry tssTunnelEntry = ; // TssTunnelEntry | 
        try {
            tssTunnelEntry result = apiInstance.createTssTunnelTableEntry(tssTunnelEntry);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createTssTunnelTableEntry");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        TssTunnelEntry tssTunnelEntry = ; // TssTunnelEntry | 
        try {
            tssTunnelEntry result = apiInstance.createTssTunnelTableEntry(tssTunnelEntry);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createTssTunnelTableEntry");
            e.printStackTrace();
        }
    }
}

TssTunnelEntry *tssTunnelEntry = ; // 

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

// Creates a row of the tssTunnelTable Table
[apiInstance createTssTunnelTableEntryWith:tssTunnelEntry
              completionHandler: ^(tssTunnelEntry output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

var tssTunnelEntry = ; // {TssTunnelEntry} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class createTssTunnelTableEntryExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var tssTunnelEntry = new TssTunnelEntry(); // TssTunnelEntry | 

            try
            {
                // Creates a row of the tssTunnelTable Table
                tssTunnelEntry result = apiInstance.createTssTunnelTableEntry(tssTunnelEntry);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createTssTunnelTableEntry: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$tssTunnelEntry = ; // TssTunnelEntry | 

try {
    $result = $api_instance->createTssTunnelTableEntry($tssTunnelEntry);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->createTssTunnelTableEntry: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $tssTunnelEntry = WWW::SwaggerClient::Object::TssTunnelEntry->new(); # TssTunnelEntry | 

eval { 
    my $result = $api_instance->createTssTunnelTableEntry(tssTunnelEntry => $tssTunnelEntry);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createTssTunnelTableEntry: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
tssTunnelEntry =  # TssTunnelEntry | 

try: 
    # Creates a row of the tssTunnelTable Table
    api_response = api_instance.create_tss_tunnel_table_entry(tssTunnelEntry)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->createTssTunnelTableEntry: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Integer lmA2AHandoffRuleNumber = 56; // Integer | 
        try {
            lmA2AHandoffRulesEntry result = apiInstance.deleteLmA2AHandoffRulesTableEntry(lmA2AHandoffRuleNumber);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteLmA2AHandoffRulesTableEntry");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer lmA2AHandoffRuleNumber = 56; // Integer | 
        try {
            lmA2AHandoffRulesEntry result = apiInstance.deleteLmA2AHandoffRulesTableEntry(lmA2AHandoffRuleNumber);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteLmA2AHandoffRulesTableEntry");
            e.printStackTrace();
        }
    }
}

Integer *lmA2AHandoffRuleNumber = 56; // 

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

// Deletes a row of the lmA2AHandoffRulesTable Table
[apiInstance deleteLmA2AHandoffRulesTableEntryWith:lmA2AHandoffRuleNumber
              completionHandler: ^(lmA2AHandoffRulesEntry output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

var lmA2AHandoffRuleNumber = 56; // {Integer} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteLmA2AHandoffRulesTableEntryExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var lmA2AHandoffRuleNumber = 56;  // Integer | 

            try
            {
                // Deletes a row of the lmA2AHandoffRulesTable Table
                lmA2AHandoffRulesEntry result = apiInstance.deleteLmA2AHandoffRulesTableEntry(lmA2AHandoffRuleNumber);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.deleteLmA2AHandoffRulesTableEntry: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$lmA2AHandoffRuleNumber = 56; // Integer | 

try {
    $result = $api_instance->deleteLmA2AHandoffRulesTableEntry($lmA2AHandoffRuleNumber);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteLmA2AHandoffRulesTableEntry: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $lmA2AHandoffRuleNumber = 56; # Integer | 

eval { 
    my $result = $api_instance->deleteLmA2AHandoffRulesTableEntry(lmA2AHandoffRuleNumber => $lmA2AHandoffRuleNumber);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteLmA2AHandoffRulesTableEntry: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
lmA2AHandoffRuleNumber = 56 # Integer | 

try: 
    # Deletes a row of the lmA2AHandoffRulesTable Table
    api_response = api_instance.delete_lm_a2_a_handoff_rules_table_entry(lmA2AHandoffRuleNumber)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteLmA2AHandoffRulesTableEntry: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Integer lmRxLinkDstGroupRfMacAddr = 56; // Integer | 
        try {
            lmRxLinksEntry result = apiInstance.deleteLmRxLinksTableEntry(lmRxLinkDstGroupRfMacAddr);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteLmRxLinksTableEntry");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer lmRxLinkDstGroupRfMacAddr = 56; // Integer | 
        try {
            lmRxLinksEntry result = apiInstance.deleteLmRxLinksTableEntry(lmRxLinkDstGroupRfMacAddr);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteLmRxLinksTableEntry");
            e.printStackTrace();
        }
    }
}

Integer *lmRxLinkDstGroupRfMacAddr = 56; // 

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

// Deletes a row of the lmRxLinksTable Table
[apiInstance deleteLmRxLinksTableEntryWith:lmRxLinkDstGroupRfMacAddr
              completionHandler: ^(lmRxLinksEntry output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

var lmRxLinkDstGroupRfMacAddr = 56; // {Integer} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteLmRxLinksTableEntryExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var lmRxLinkDstGroupRfMacAddr = 56;  // Integer | 

            try
            {
                // Deletes a row of the lmRxLinksTable Table
                lmRxLinksEntry result = apiInstance.deleteLmRxLinksTableEntry(lmRxLinkDstGroupRfMacAddr);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.deleteLmRxLinksTableEntry: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$lmRxLinkDstGroupRfMacAddr = 56; // Integer | 

try {
    $result = $api_instance->deleteLmRxLinksTableEntry($lmRxLinkDstGroupRfMacAddr);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteLmRxLinksTableEntry: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $lmRxLinkDstGroupRfMacAddr = 56; # Integer | 

eval { 
    my $result = $api_instance->deleteLmRxLinksTableEntry(lmRxLinkDstGroupRfMacAddr => $lmRxLinkDstGroupRfMacAddr);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteLmRxLinksTableEntry: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
lmRxLinkDstGroupRfMacAddr = 56 # Integer | 

try: 
    # Deletes a row of the lmRxLinksTable Table
    api_response = api_instance.delete_lm_rx_links_table_entry(lmRxLinkDstGroupRfMacAddr)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteLmRxLinksTableEntry: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Integer lmTxLinkDstGroupRfMacAddr = 56; // Integer | 
        try {
            lmTxLinksEntry result = apiInstance.deleteLmTxLinksTableEntry(lmTxLinkDstGroupRfMacAddr);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteLmTxLinksTableEntry");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer lmTxLinkDstGroupRfMacAddr = 56; // Integer | 
        try {
            lmTxLinksEntry result = apiInstance.deleteLmTxLinksTableEntry(lmTxLinkDstGroupRfMacAddr);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteLmTxLinksTableEntry");
            e.printStackTrace();
        }
    }
}

Integer *lmTxLinkDstGroupRfMacAddr = 56; // 

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

// Deletes a row of the lmTxLinksTable Table
[apiInstance deleteLmTxLinksTableEntryWith:lmTxLinkDstGroupRfMacAddr
              completionHandler: ^(lmTxLinksEntry output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

var lmTxLinkDstGroupRfMacAddr = 56; // {Integer} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteLmTxLinksTableEntryExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var lmTxLinkDstGroupRfMacAddr = 56;  // Integer | 

            try
            {
                // Deletes a row of the lmTxLinksTable Table
                lmTxLinksEntry result = apiInstance.deleteLmTxLinksTableEntry(lmTxLinkDstGroupRfMacAddr);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.deleteLmTxLinksTableEntry: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$lmTxLinkDstGroupRfMacAddr = 56; // Integer | 

try {
    $result = $api_instance->deleteLmTxLinksTableEntry($lmTxLinkDstGroupRfMacAddr);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteLmTxLinksTableEntry: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $lmTxLinkDstGroupRfMacAddr = 56; # Integer | 

eval { 
    my $result = $api_instance->deleteLmTxLinksTableEntry(lmTxLinkDstGroupRfMacAddr => $lmTxLinkDstGroupRfMacAddr);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteLmTxLinksTableEntry: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
lmTxLinkDstGroupRfMacAddr = 56 # Integer | 

try: 
    # Deletes a row of the lmTxLinksTable Table
    api_response = api_instance.delete_lm_tx_links_table_entry(lmTxLinkDstGroupRfMacAddr)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteLmTxLinksTableEntry: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Integer managedElementIndex = 56; // Integer | 
        try {
            managedElementEntry result = apiInstance.deleteManagedElementTableEntry(managedElementIndex);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteManagedElementTableEntry");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer managedElementIndex = 56; // Integer | 
        try {
            managedElementEntry result = apiInstance.deleteManagedElementTableEntry(managedElementIndex);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteManagedElementTableEntry");
            e.printStackTrace();
        }
    }
}

Integer *managedElementIndex = 56; // 

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

// Deletes a row of the managedElementTable Table
[apiInstance deleteManagedElementTableEntryWith:managedElementIndex
              completionHandler: ^(managedElementEntry output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

var managedElementIndex = 56; // {Integer} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteManagedElementTableEntryExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var managedElementIndex = 56;  // Integer | 

            try
            {
                // Deletes a row of the managedElementTable Table
                managedElementEntry result = apiInstance.deleteManagedElementTableEntry(managedElementIndex);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.deleteManagedElementTableEntry: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$managedElementIndex = 56; // Integer | 

try {
    $result = $api_instance->deleteManagedElementTableEntry($managedElementIndex);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteManagedElementTableEntry: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $managedElementIndex = 56; # Integer | 

eval { 
    my $result = $api_instance->deleteManagedElementTableEntry(managedElementIndex => $managedElementIndex);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteManagedElementTableEntry: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
managedElementIndex = 56 # Integer | 

try: 
    # Deletes a row of the managedElementTable Table
    api_response = api_instance.delete_managed_element_table_entry(managedElementIndex)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteManagedElementTableEntry: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Integer sampleIndex = 56; // Integer | 
        try {
            sampleEntry result = apiInstance.deleteSampleTableEntry(sampleIndex);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteSampleTableEntry");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer sampleIndex = 56; // Integer | 
        try {
            sampleEntry result = apiInstance.deleteSampleTableEntry(sampleIndex);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteSampleTableEntry");
            e.printStackTrace();
        }
    }
}

Integer *sampleIndex = 56; // 

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

// Deletes a row of the sampleTable Table
[apiInstance deleteSampleTableEntryWith:sampleIndex
              completionHandler: ^(sampleEntry output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

var sampleIndex = 56; // {Integer} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteSampleTableEntryExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var sampleIndex = 56;  // Integer | 

            try
            {
                // Deletes a row of the sampleTable Table
                sampleEntry result = apiInstance.deleteSampleTableEntry(sampleIndex);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.deleteSampleTableEntry: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$sampleIndex = 56; // Integer | 

try {
    $result = $api_instance->deleteSampleTableEntry($sampleIndex);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteSampleTableEntry: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $sampleIndex = 56; # Integer | 

eval { 
    my $result = $api_instance->deleteSampleTableEntry(sampleIndex => $sampleIndex);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteSampleTableEntry: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
sampleIndex = 56 # Integer | 

try: 
    # Deletes a row of the sampleTable Table
    api_response = api_instance.delete_sample_table_entry(sampleIndex)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteSampleTableEntry: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Integer tssRtDstGroupRfMacAddr = 56; // Integer | 
        try {
            tssRoutingEntry result = apiInstance.deleteTssRoutingTableEntry(tssRtDstGroupRfMacAddr);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteTssRoutingTableEntry");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer tssRtDstGroupRfMacAddr = 56; // Integer | 
        try {
            tssRoutingEntry result = apiInstance.deleteTssRoutingTableEntry(tssRtDstGroupRfMacAddr);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteTssRoutingTableEntry");
            e.printStackTrace();
        }
    }
}

Integer *tssRtDstGroupRfMacAddr = 56; // 

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

// Deletes a row of the tssRoutingTable Table
[apiInstance deleteTssRoutingTableEntryWith:tssRtDstGroupRfMacAddr
              completionHandler: ^(tssRoutingEntry output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

var tssRtDstGroupRfMacAddr = 56; // {Integer} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteTssRoutingTableEntryExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var tssRtDstGroupRfMacAddr = 56;  // Integer | 

            try
            {
                // Deletes a row of the tssRoutingTable Table
                tssRoutingEntry result = apiInstance.deleteTssRoutingTableEntry(tssRtDstGroupRfMacAddr);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.deleteTssRoutingTableEntry: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$tssRtDstGroupRfMacAddr = 56; // Integer | 

try {
    $result = $api_instance->deleteTssRoutingTableEntry($tssRtDstGroupRfMacAddr);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteTssRoutingTableEntry: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $tssRtDstGroupRfMacAddr = 56; # Integer | 

eval { 
    my $result = $api_instance->deleteTssRoutingTableEntry(tssRtDstGroupRfMacAddr => $tssRtDstGroupRfMacAddr);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteTssRoutingTableEntry: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
tssRtDstGroupRfMacAddr = 56 # Integer | 

try: 
    # Deletes a row of the tssRoutingTable Table
    api_response = api_instance.delete_tss_routing_table_entry(tssRtDstGroupRfMacAddr)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteTssRoutingTableEntry: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Integer tssSrcSelDstGroupRfMacAddr = 56; // Integer | 
        try {
            tssSrcSelEntry result = apiInstance.deleteTssSrcSelTableEntry(tssSrcSelDstGroupRfMacAddr);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteTssSrcSelTableEntry");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer tssSrcSelDstGroupRfMacAddr = 56; // Integer | 
        try {
            tssSrcSelEntry result = apiInstance.deleteTssSrcSelTableEntry(tssSrcSelDstGroupRfMacAddr);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteTssSrcSelTableEntry");
            e.printStackTrace();
        }
    }
}

Integer *tssSrcSelDstGroupRfMacAddr = 56; // 

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

// Deletes a row of the tssSrcSelTable Table
[apiInstance deleteTssSrcSelTableEntryWith:tssSrcSelDstGroupRfMacAddr
              completionHandler: ^(tssSrcSelEntry output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

var tssSrcSelDstGroupRfMacAddr = 56; // {Integer} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteTssSrcSelTableEntryExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var tssSrcSelDstGroupRfMacAddr = 56;  // Integer | 

            try
            {
                // Deletes a row of the tssSrcSelTable Table
                tssSrcSelEntry result = apiInstance.deleteTssSrcSelTableEntry(tssSrcSelDstGroupRfMacAddr);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.deleteTssSrcSelTableEntry: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$tssSrcSelDstGroupRfMacAddr = 56; // Integer | 

try {
    $result = $api_instance->deleteTssSrcSelTableEntry($tssSrcSelDstGroupRfMacAddr);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteTssSrcSelTableEntry: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $tssSrcSelDstGroupRfMacAddr = 56; # Integer | 

eval { 
    my $result = $api_instance->deleteTssSrcSelTableEntry(tssSrcSelDstGroupRfMacAddr => $tssSrcSelDstGroupRfMacAddr);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteTssSrcSelTableEntry: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
tssSrcSelDstGroupRfMacAddr = 56 # Integer | 

try: 
    # Deletes a row of the tssSrcSelTable Table
    api_response = api_instance.delete_tss_src_sel_table_entry(tssSrcSelDstGroupRfMacAddr)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteTssSrcSelTableEntry: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Integer tssTunnelEndpointIpAddr = 56; // Integer | 
        try {
            tssTunnelEntry result = apiInstance.deleteTssTunnelTableEntry(tssTunnelEndpointIpAddr);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteTssTunnelTableEntry");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer tssTunnelEndpointIpAddr = 56; // Integer | 
        try {
            tssTunnelEntry result = apiInstance.deleteTssTunnelTableEntry(tssTunnelEndpointIpAddr);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteTssTunnelTableEntry");
            e.printStackTrace();
        }
    }
}

Integer *tssTunnelEndpointIpAddr = 56; // 

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

// Deletes a row of the tssTunnelTable Table
[apiInstance deleteTssTunnelTableEntryWith:tssTunnelEndpointIpAddr
              completionHandler: ^(tssTunnelEntry output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

var tssTunnelEndpointIpAddr = 56; // {Integer} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class deleteTssTunnelTableEntryExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var tssTunnelEndpointIpAddr = 56;  // Integer | 

            try
            {
                // Deletes a row of the tssTunnelTable Table
                tssTunnelEntry result = apiInstance.deleteTssTunnelTableEntry(tssTunnelEndpointIpAddr);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.deleteTssTunnelTableEntry: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$tssTunnelEndpointIpAddr = 56; // Integer | 

try {
    $result = $api_instance->deleteTssTunnelTableEntry($tssTunnelEndpointIpAddr);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteTssTunnelTableEntry: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $tssTunnelEndpointIpAddr = 56; # Integer | 

eval { 
    my $result = $api_instance->deleteTssTunnelTableEntry(tssTunnelEndpointIpAddr => $tssTunnelEndpointIpAddr);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteTssTunnelTableEntry: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
tssTunnelEndpointIpAddr = 56 # Integer | 

try: 
    # Deletes a row of the tssTunnelTable Table
    api_response = api_instance.delete_tss_tunnel_table_entry(tssTunnelEndpointIpAddr)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteTssTunnelTableEntry: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            accessAnomalyDetectionNotificationEnable result = apiInstance.getAccessAnomalyDetectionNotificationEnable();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getAccessAnomalyDetectionNotificationEnable");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            accessAnomalyDetectionNotificationEnable result = apiInstance.getAccessAnomalyDetectionNotificationEnable();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getAccessAnomalyDetectionNotificationEnable");
            e.printStackTrace();
        }
    }
}

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

// Retrieves the accessAnomalyDetectionNotificationEnable OID
[apiInstance getAccessAnomalyDetectionNotificationEnableWithCompletionHandler: 
              ^(accessAnomalyDetectionNotificationEnable output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getAccessAnomalyDetectionNotificationEnableExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                // Retrieves the accessAnomalyDetectionNotificationEnable OID
                accessAnomalyDetectionNotificationEnable result = apiInstance.getAccessAnomalyDetectionNotificationEnable();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getAccessAnomalyDetectionNotificationEnable: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $result = $api_instance->getAccessAnomalyDetectionNotificationEnable();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getAccessAnomalyDetectionNotificationEnable: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    my $result = $api_instance->getAccessAnomalyDetectionNotificationEnable();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getAccessAnomalyDetectionNotificationEnable: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    # Retrieves the accessAnomalyDetectionNotificationEnable OID
    api_response = api_instance.get_access_anomaly_detection_notification_enable()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getAccessAnomalyDetectionNotificationEnable: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            accessAnomalyDetectionNotificationInterval result = apiInstance.getAccessAnomalyDetectionNotificationInterval();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getAccessAnomalyDetectionNotificationInterval");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            accessAnomalyDetectionNotificationInterval result = apiInstance.getAccessAnomalyDetectionNotificationInterval();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getAccessAnomalyDetectionNotificationInterval");
            e.printStackTrace();
        }
    }
}

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

// Retrieves the accessAnomalyDetectionNotificationInterval OID
[apiInstance getAccessAnomalyDetectionNotificationIntervalWithCompletionHandler: 
              ^(accessAnomalyDetectionNotificationInterval output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getAccessAnomalyDetectionNotificationIntervalExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                // Retrieves the accessAnomalyDetectionNotificationInterval OID
                accessAnomalyDetectionNotificationInterval result = apiInstance.getAccessAnomalyDetectionNotificationInterval();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getAccessAnomalyDetectionNotificationInterval: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $result = $api_instance->getAccessAnomalyDetectionNotificationInterval();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getAccessAnomalyDetectionNotificationInterval: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    my $result = $api_instance->getAccessAnomalyDetectionNotificationInterval();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getAccessAnomalyDetectionNotificationInterval: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    # Retrieves the accessAnomalyDetectionNotificationInterval OID
    api_response = api_instance.get_access_anomaly_detection_notification_interval()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getAccessAnomalyDetectionNotificationInterval: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            accessAnomalyDetectionNotificationRepeat result = apiInstance.getAccessAnomalyDetectionNotificationRepeat();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getAccessAnomalyDetectionNotificationRepeat");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            accessAnomalyDetectionNotificationRepeat result = apiInstance.getAccessAnomalyDetectionNotificationRepeat();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getAccessAnomalyDetectionNotificationRepeat");
            e.printStackTrace();
        }
    }
}

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

// Retrieves the accessAnomalyDetectionNotificationRepeat OID
[apiInstance getAccessAnomalyDetectionNotificationRepeatWithCompletionHandler: 
              ^(accessAnomalyDetectionNotificationRepeat output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getAccessAnomalyDetectionNotificationRepeatExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                // Retrieves the accessAnomalyDetectionNotificationRepeat OID
                accessAnomalyDetectionNotificationRepeat result = apiInstance.getAccessAnomalyDetectionNotificationRepeat();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getAccessAnomalyDetectionNotificationRepeat: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $result = $api_instance->getAccessAnomalyDetectionNotificationRepeat();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getAccessAnomalyDetectionNotificationRepeat: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    my $result = $api_instance->getAccessAnomalyDetectionNotificationRepeat();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getAccessAnomalyDetectionNotificationRepeat: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    # Retrieves the accessAnomalyDetectionNotificationRepeat OID
    api_response = api_instance.get_access_anomaly_detection_notification_repeat()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getAccessAnomalyDetectionNotificationRepeat: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            array[activeFaultsEntry] result = apiInstance.getActiveFaultsTable();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getActiveFaultsTable");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            array[activeFaultsEntry] result = apiInstance.getActiveFaultsTable();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getActiveFaultsTable");
            e.printStackTrace();
        }
    }
}

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

// Retrieves the entire activeFaultsTable Table
[apiInstance getActiveFaultsTableWithCompletionHandler: 
              ^(array[activeFaultsEntry] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getActiveFaultsTableExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                // Retrieves the entire activeFaultsTable Table
                array[activeFaultsEntry] result = apiInstance.getActiveFaultsTable();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getActiveFaultsTable: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $result = $api_instance->getActiveFaultsTable();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getActiveFaultsTable: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    my $result = $api_instance->getActiveFaultsTable();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getActiveFaultsTable: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    # Retrieves the entire activeFaultsTable Table
    api_response = api_instance.get_active_faults_table()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getActiveFaultsTable: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Integer faultIndex = 56; // Integer | 
        try {
            activeFaultsEntry result = apiInstance.getActiveFaultsTableEntry(faultIndex);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getActiveFaultsTableEntry");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer faultIndex = 56; // Integer | 
        try {
            activeFaultsEntry result = apiInstance.getActiveFaultsTableEntry(faultIndex);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getActiveFaultsTableEntry");
            e.printStackTrace();
        }
    }
}

Integer *faultIndex = 56; // 

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

// Retrieves a row of the activeFaultsTable Table
[apiInstance getActiveFaultsTableEntryWith:faultIndex
              completionHandler: ^(activeFaultsEntry output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

var faultIndex = 56; // {Integer} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getActiveFaultsTableEntryExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var faultIndex = 56;  // Integer | 

            try
            {
                // Retrieves a row of the activeFaultsTable Table
                activeFaultsEntry result = apiInstance.getActiveFaultsTableEntry(faultIndex);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getActiveFaultsTableEntry: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$faultIndex = 56; // Integer | 

try {
    $result = $api_instance->getActiveFaultsTableEntry($faultIndex);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getActiveFaultsTableEntry: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $faultIndex = 56; # Integer | 

eval { 
    my $result = $api_instance->getActiveFaultsTableEntry(faultIndex => $faultIndex);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getActiveFaultsTableEntry: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
faultIndex = 56 # Integer | 

try: 
    # Retrieves a row of the activeFaultsTable Table
    api_response = api_instance.get_active_faults_table_entry(faultIndex)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getActiveFaultsTableEntry: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            activeMdlSchemaVersion result = apiInstance.getActiveMdlSchemaVersion();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getActiveMdlSchemaVersion");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            activeMdlSchemaVersion result = apiInstance.getActiveMdlSchemaVersion();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getActiveMdlSchemaVersion");
            e.printStackTrace();
        }
    }
}

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

// Retrieves the activeMdlSchemaVersion OID
[apiInstance getActiveMdlSchemaVersionWithCompletionHandler: 
              ^(activeMdlSchemaVersion output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getActiveMdlSchemaVersionExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                // Retrieves the activeMdlSchemaVersion OID
                activeMdlSchemaVersion result = apiInstance.getActiveMdlSchemaVersion();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getActiveMdlSchemaVersion: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $result = $api_instance->getActiveMdlSchemaVersion();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getActiveMdlSchemaVersion: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    my $result = $api_instance->getActiveMdlSchemaVersion();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getActiveMdlSchemaVersion: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    # Retrieves the activeMdlSchemaVersion OID
    api_response = api_instance.get_active_mdl_schema_version()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getActiveMdlSchemaVersion: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            activeRCDataSinkSessions result = apiInstance.getActiveRCDataSinkSessions();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getActiveRCDataSinkSessions");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            activeRCDataSinkSessions result = apiInstance.getActiveRCDataSinkSessions();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getActiveRCDataSinkSessions");
            e.printStackTrace();
        }
    }
}

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

// Retrieves the activeRCDataSinkSessions OID
[apiInstance getActiveRCDataSinkSessionsWithCompletionHandler: 
              ^(activeRCDataSinkSessions output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getActiveRCDataSinkSessionsExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                // Retrieves the activeRCDataSinkSessions OID
                activeRCDataSinkSessions result = apiInstance.getActiveRCDataSinkSessions();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getActiveRCDataSinkSessions: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $result = $api_instance->getActiveRCDataSinkSessions();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getActiveRCDataSinkSessions: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    my $result = $api_instance->getActiveRCDataSinkSessions();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getActiveRCDataSinkSessions: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    # Retrieves the activeRCDataSinkSessions OID
    api_response = api_instance.get_active_rc_data_sink_sessions()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getActiveRCDataSinkSessions: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            activeRCDataSourceSessions result = apiInstance.getActiveRCDataSourceSessions();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getActiveRCDataSourceSessions");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            activeRCDataSourceSessions result = apiInstance.getActiveRCDataSourceSessions();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getActiveRCDataSourceSessions");
            e.printStackTrace();
        }
    }
}

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

// Retrieves the activeRCDataSourceSessions OID
[apiInstance getActiveRCDataSourceSessionsWithCompletionHandler: 
              ^(activeRCDataSourceSessions output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getActiveRCDataSourceSessionsExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                // Retrieves the activeRCDataSourceSessions OID
                activeRCDataSourceSessions result = apiInstance.getActiveRCDataSourceSessions();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getActiveRCDataSourceSessions: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $result = $api_instance->getActiveRCDataSourceSessions();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getActiveRCDataSourceSessions: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    my $result = $api_instance->getActiveRCDataSourceSessions();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getActiveRCDataSourceSessions: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    # Retrieves the activeRCDataSourceSessions OID
    api_response = api_instance.get_active_rc_data_source_sessions()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getActiveRCDataSourceSessions: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            adapterDeregisterDevice result = apiInstance.getAdapterDeregisterDevice();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getAdapterDeregisterDevice");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            adapterDeregisterDevice result = apiInstance.getAdapterDeregisterDevice();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getAdapterDeregisterDevice");
            e.printStackTrace();
        }
    }
}

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

// Retrieves the adapterDeregisterDevice OID
[apiInstance getAdapterDeregisterDeviceWithCompletionHandler: 
              ^(adapterDeregisterDevice output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getAdapterDeregisterDeviceExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                // Retrieves the adapterDeregisterDevice OID
                adapterDeregisterDevice result = apiInstance.getAdapterDeregisterDevice();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getAdapterDeregisterDevice: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $result = $api_instance->getAdapterDeregisterDevice();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getAdapterDeregisterDevice: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    my $result = $api_instance->getAdapterDeregisterDevice();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getAdapterDeregisterDevice: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    # Retrieves the adapterDeregisterDevice OID
    api_response = api_instance.get_adapter_deregister_device()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getAdapterDeregisterDevice: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            array[adapterDeviceEntry] result = apiInstance.getAdapterDeviceTable();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getAdapterDeviceTable");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            array[adapterDeviceEntry] result = apiInstance.getAdapterDeviceTable();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getAdapterDeviceTable");
            e.printStackTrace();
        }
    }
}

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

// Retrieves the entire adapterDeviceTable Table
[apiInstance getAdapterDeviceTableWithCompletionHandler: 
              ^(array[adapterDeviceEntry] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getAdapterDeviceTableExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                // Retrieves the entire adapterDeviceTable Table
                array[adapterDeviceEntry] result = apiInstance.getAdapterDeviceTable();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getAdapterDeviceTable: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $result = $api_instance->getAdapterDeviceTable();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getAdapterDeviceTable: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    my $result = $api_instance->getAdapterDeviceTable();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getAdapterDeviceTable: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    # Retrieves the entire adapterDeviceTable Table
    api_response = api_instance.get_adapter_device_table()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getAdapterDeviceTable: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Integer adapterDeviceIndex = 56; // Integer | 
        try {
            adapterDeviceEntry result = apiInstance.getAdapterDeviceTableEntry(adapterDeviceIndex);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getAdapterDeviceTableEntry");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer adapterDeviceIndex = 56; // Integer | 
        try {
            adapterDeviceEntry result = apiInstance.getAdapterDeviceTableEntry(adapterDeviceIndex);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getAdapterDeviceTableEntry");
            e.printStackTrace();
        }
    }
}

Integer *adapterDeviceIndex = 56; // 

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

// Retrieves a row of the adapterDeviceTable Table
[apiInstance getAdapterDeviceTableEntryWith:adapterDeviceIndex
              completionHandler: ^(adapterDeviceEntry output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

var adapterDeviceIndex = 56; // {Integer} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getAdapterDeviceTableEntryExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var adapterDeviceIndex = 56;  // Integer | 

            try
            {
                // Retrieves a row of the adapterDeviceTable Table
                adapterDeviceEntry result = apiInstance.getAdapterDeviceTableEntry(adapterDeviceIndex);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getAdapterDeviceTableEntry: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$adapterDeviceIndex = 56; // Integer | 

try {
    $result = $api_instance->getAdapterDeviceTableEntry($adapterDeviceIndex);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getAdapterDeviceTableEntry: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $adapterDeviceIndex = 56; # Integer | 

eval { 
    my $result = $api_instance->getAdapterDeviceTableEntry(adapterDeviceIndex => $adapterDeviceIndex);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getAdapterDeviceTableEntry: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
adapterDeviceIndex = 56 # Integer | 

try: 
    # Retrieves a row of the adapterDeviceTable Table
    api_response = api_instance.get_adapter_device_table_entry(adapterDeviceIndex)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getAdapterDeviceTableEntry: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            adapterRegisterDevice result = apiInstance.getAdapterRegisterDevice();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getAdapterRegisterDevice");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            adapterRegisterDevice result = apiInstance.getAdapterRegisterDevice();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getAdapterRegisterDevice");
            e.printStackTrace();
        }
    }
}

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

// Retrieves the adapterRegisterDevice OID
[apiInstance getAdapterRegisterDeviceWithCompletionHandler: 
              ^(adapterRegisterDevice output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getAdapterRegisterDeviceExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                // Retrieves the adapterRegisterDevice OID
                adapterRegisterDevice result = apiInstance.getAdapterRegisterDevice();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getAdapterRegisterDevice: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $result = $api_instance->getAdapterRegisterDevice();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getAdapterRegisterDevice: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    my $result = $api_instance->getAdapterRegisterDevice();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getAdapterRegisterDevice: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    # Retrieves the adapterRegisterDevice OID
    api_response = api_instance.get_adapter_register_device()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getAdapterRegisterDevice: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            applyToManager result = apiInstance.getApplyToManager();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getApplyToManager");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            applyToManager result = apiInstance.getApplyToManager();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getApplyToManager");
            e.printStackTrace();
        }
    }
}

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

// Retrieves the applyToManager OID
[apiInstance getApplyToManagerWithCompletionHandler: 
              ^(applyToManager output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getApplyToManagerExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                // Retrieves the applyToManager OID
                applyToManager result = apiInstance.getApplyToManager();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getApplyToManager: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $result = $api_instance->getApplyToManager();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getApplyToManager: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    my $result = $api_instance->getApplyToManager();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getApplyToManager: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    # Retrieves the applyToManager OID
    api_response = api_instance.get_apply_to_manager()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getApplyToManager: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            autotrackingEnabled result = apiInstance.getAutotrackingEnabled();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getAutotrackingEnabled");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            autotrackingEnabled result = apiInstance.getAutotrackingEnabled();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getAutotrackingEnabled");
            e.printStackTrace();
        }
    }
}

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

// Retrieves the autotrackingEnabled OID
[apiInstance getAutotrackingEnabledWithCompletionHandler: 
              ^(autotrackingEnabled output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getAutotrackingEnabledExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                // Retrieves the autotrackingEnabled OID
                autotrackingEnabled result = apiInstance.getAutotrackingEnabled();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getAutotrackingEnabled: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $result = $api_instance->getAutotrackingEnabled();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getAutotrackingEnabled: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    my $result = $api_instance->getAutotrackingEnabled();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getAutotrackingEnabled: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    # Retrieves the autotrackingEnabled OID
    api_response = api_instance.get_autotracking_enabled()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getAutotrackingEnabled: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            bitSlipCounter result = apiInstance.getBitSlipCounter();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getBitSlipCounter");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            bitSlipCounter result = apiInstance.getBitSlipCounter();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getBitSlipCounter");
            e.printStackTrace();
        }
    }
}

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

// Retrieves the bitSlipCounter OID
[apiInstance getBitSlipCounterWithCompletionHandler: 
              ^(bitSlipCounter output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getBitSlipCounterExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                // Retrieves the bitSlipCounter OID
                bitSlipCounter result = apiInstance.getBitSlipCounter();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getBitSlipCounter: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $result = $api_instance->getBitSlipCounter();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getBitSlipCounter: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    my $result = $api_instance->getBitSlipCounter();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getBitSlipCounter: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    # Retrieves the bitSlipCounter OID
    api_response = api_instance.get_bit_slip_counter()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getBitSlipCounter: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            array[bsEntry] result = apiInstance.getBsTable();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getBsTable");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            array[bsEntry] result = apiInstance.getBsTable();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getBsTable");
            e.printStackTrace();
        }
    }
}

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

// Retrieves the entire bsTable Table
[apiInstance getBsTableWithCompletionHandler: 
              ^(array[bsEntry] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getBsTableExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                // Retrieves the entire bsTable Table
                array[bsEntry] result = apiInstance.getBsTable();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getBsTable: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $result = $api_instance->getBsTable();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getBsTable: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    my $result = $api_instance->getBsTable();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getBsTable: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    # Retrieves the entire bsTable Table
    api_response = api_instance.get_bs_table()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getBsTable: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Integer bsQosPolicyID = 56; // Integer | 
        try {
            bsEntry result = apiInstance.getBsTableEntry(bsQosPolicyID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getBsTableEntry");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer bsQosPolicyID = 56; // Integer | 
        try {
            bsEntry result = apiInstance.getBsTableEntry(bsQosPolicyID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getBsTableEntry");
            e.printStackTrace();
        }
    }
}

Integer *bsQosPolicyID = 56; // 

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

// Retrieves a row of the bsTable Table
[apiInstance getBsTableEntryWith:bsQosPolicyID
              completionHandler: ^(bsEntry output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

var bsQosPolicyID = 56; // {Integer} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getBsTableEntryExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var bsQosPolicyID = 56;  // Integer | 

            try
            {
                // Retrieves a row of the bsTable Table
                bsEntry result = apiInstance.getBsTableEntry(bsQosPolicyID);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getBsTableEntry: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$bsQosPolicyID = 56; // Integer | 

try {
    $result = $api_instance->getBsTableEntry($bsQosPolicyID);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getBsTableEntry: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $bsQosPolicyID = 56; # Integer | 

eval { 
    my $result = $api_instance->getBsTableEntry(bsQosPolicyID => $bsQosPolicyID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getBsTableEntry: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
bsQosPolicyID = 56 # Integer | 

try: 
    # Retrieves a row of the bsTable Table
    api_response = api_instance.get_bs_table_entry(bsQosPolicyID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getBsTableEntry: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            array[bslpEntry] result = apiInstance.getBslpTable();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getBslpTable");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            array[bslpEntry] result = apiInstance.getBslpTable();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getBslpTable");
            e.printStackTrace();
        }
    }
}

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

// Retrieves the entire bslpTable Table
[apiInstance getBslpTableWithCompletionHandler: 
              ^(array[bslpEntry] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getBslpTableExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                // Retrieves the entire bslpTable Table
                array[bslpEntry] result = apiInstance.getBslpTable();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getBslpTable: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $result = $api_instance->getBslpTable();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getBslpTable: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    my $result = $api_instance->getBslpTable();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getBslpTable: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()

try: 
    # Retrieves the entire bslpTable Table
    api_response = api_instance.get_bslp_table()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getBslpTable: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        Integer bslpQosPolicyID = 56; // Integer | 
        try {
            bslpEntry result = apiInstance.getBslpTableEntry(bslpQosPolicyID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getBslpTableEntry");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Integer bslpQosPolicyID = 56; // Integer | 
        try {
            bslpEntry result = apiInstance.getBslpTableEntry(bslpQosPolicyID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getBslpTableEntry");
            e.printStackTrace();
        }
    }
}

Integer *bslpQosPolicyID = 56; // 

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

// Retrieves a row of the bslpTable Table
[apiInstance getBslpTableEntryWith:bslpQosPolicyID
              completionHandler: ^(bslpEntry output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

var bslpQosPolicyID = 56; // {Integer} 


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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getBslpTableEntryExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();
            var bslpQosPolicyID = 56;  // Integer | 

            try
            {
                // Retrieves a row of the bslpTable Table
                bslpEntry result = apiInstance.getBslpTableEntry(bslpQosPolicyID);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getBslpTableEntry: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();
$bslpQosPolicyID = 56; // Integer | 

try {
    $result = $api_instance->getBslpTableEntry($bslpQosPolicyID);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getBslpTableEntry: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $bslpQosPolicyID = 56; # Integer | 

eval { 
    my $result = $api_instance->getBslpTableEntry(bslpQosPolicyID => $bslpQosPolicyID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getBslpTableEntry: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DefaultApi()
bslpQosPolicyID = 56 # Integer | 

try: 
    # Retrieves a row of the bslpTable Table
    api_response = api_instance.get_bslp_table_entry(bslpQosPolicyID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getBslpTableEntry: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {
        
        DefaultApi apiInstance = new DefaultApi();
        try {
            array[bytesReceivedEntry] result = apiInstance.getBytesReceivedTable();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getBytesReceivedTable");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        try {
            array[bytesReceivedEntry] result = apiInstance.getBytesReceivedTable();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getBytesReceivedTable");
            e.printStackTrace();
        }
    }
}

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

// Retrieves the entire bytesReceivedTable Table
[apiInstance getBytesReceivedTableWithCompletionHandler: 
              ^(array[bytesReceivedEntry] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var TmNsRestApi = require('tm_ns_rest_api');

var api = new TmNsRestApi.DefaultApi()

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class getBytesReceivedTableExample
    {
        public void main()
        {
            
            var apiInstance = new DefaultApi();

            try
            {
                // Retrieves the entire bytesReceivedTable Table
                array[bytesReceivedEntry] result = apiInstance.getBytesReceivedTable();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.getBytesReceivedTable: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\DefaultApi();

try {
    $result = $api_instance->getBytesReceivedTable();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getBytesReceivedTable: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefaultApi;

my $api_instance = WWW::SwaggerClient::DefaultApi->new();

eval { 
    my $result = $api_instance->getBytesReceivedTable();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getBytesReceivedTable: $@\n";
}