Linkar REST API

SendCommandApi

apiConversionPost

Returns the result of executing ICONV() or OCONV() functions from a expression list in the Database.


/api/Conversion

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json,application/xml"\
"//api/Conversion"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SendCommandApiApi;

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

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKCONVERSIONCOMMAND body = ; // LKCONVERSIONCOMMAND | 
        try {
            apiInstance.apiConversionPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiConversionPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SendCommandApiApi;

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKCONVERSIONCOMMAND body = ; // LKCONVERSIONCOMMAND | 
        try {
            apiInstance.apiConversionPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiConversionPost");
            e.printStackTrace();
        }
    }
}
LKCONVERSIONCOMMAND *body = ; //  (optional)

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

// Returns the result of executing ICONV() or OCONV() functions from a expression list in the Database.
[apiInstance apiConversionPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LinkarRestApi = require('linkar_rest_api');

var api = new LinkarRestApi.SendCommandApiApi()
var opts = { 
  'body':  // {{LKCONVERSIONCOMMAND}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiConversionPost(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiConversionPostExample
    {
        public void main()
        {

            var apiInstance = new SendCommandApiApi();
            var body = new LKCONVERSIONCOMMAND(); // LKCONVERSIONCOMMAND |  (optional) 

            try
            {
                // Returns the result of executing ICONV() or OCONV() functions from a expression list in the Database.
                apiInstance.apiConversionPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SendCommandApiApi.apiConversionPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSendCommandApiApi();
$body = ; // LKCONVERSIONCOMMAND | 

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

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

eval { 
    $api_instance->apiConversionPost(body => $body);
};
if ($@) {
    warn "Exception when calling SendCommandApiApi->apiConversionPost: $@\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.SendCommandApiApi()
body =  # LKCONVERSIONCOMMAND |  (optional)

try: 
    # Returns the result of executing ICONV() or OCONV() functions from a expression list in the Database.
    api_instance.api_conversion_post(body=body)
except ApiException as e:
    print("Exception when calling SendCommandApiApi->apiConversionPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Success

Status: 400 - Error:Bad Request


apiDeleteCustomPost

Deletes one or several records in file. Recover Custom item IDs.


/api/DeleteCustom

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json,application/xml"\
"//api/DeleteCustom"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SendCommandApiApi;

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

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKDELETECUSTOMCOMMAND body = ; // LKDELETECUSTOMCOMMAND | 
        try {
            apiInstance.apiDeleteCustomPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiDeleteCustomPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SendCommandApiApi;

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKDELETECUSTOMCOMMAND body = ; // LKDELETECUSTOMCOMMAND | 
        try {
            apiInstance.apiDeleteCustomPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiDeleteCustomPost");
            e.printStackTrace();
        }
    }
}
LKDELETECUSTOMCOMMAND *body = ; //  (optional)

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

// Deletes one or several records in file. Recover Custom item IDs.
[apiInstance apiDeleteCustomPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LinkarRestApi = require('linkar_rest_api');

var api = new LinkarRestApi.SendCommandApiApi()
var opts = { 
  'body':  // {{LKDELETECUSTOMCOMMAND}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiDeleteCustomPost(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiDeleteCustomPostExample
    {
        public void main()
        {

            var apiInstance = new SendCommandApiApi();
            var body = new LKDELETECUSTOMCOMMAND(); // LKDELETECUSTOMCOMMAND |  (optional) 

            try
            {
                // Deletes one or several records in file. Recover Custom item IDs.
                apiInstance.apiDeleteCustomPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SendCommandApiApi.apiDeleteCustomPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSendCommandApiApi();
$body = ; // LKDELETECUSTOMCOMMAND | 

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

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

eval { 
    $api_instance->apiDeleteCustomPost(body => $body);
};
if ($@) {
    warn "Exception when calling SendCommandApiApi->apiDeleteCustomPost: $@\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.SendCommandApiApi()
body =  # LKDELETECUSTOMCOMMAND |  (optional)

try: 
    # Deletes one or several records in file. Recover Custom item IDs.
    api_instance.api_delete_custom_post(body=body)
except ApiException as e:
    print("Exception when calling SendCommandApiApi->apiDeleteCustomPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Success

Status: 400 - Error:Bad Request


apiDeleteLinkarPost

Deletes one or several records in file. Recover Linkar item IDs.


/api/DeleteLinkar

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json,application/xml"\
"//api/DeleteLinkar"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SendCommandApiApi;

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

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKDELETELINKARCOMMAND body = ; // LKDELETELINKARCOMMAND | 
        try {
            apiInstance.apiDeleteLinkarPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiDeleteLinkarPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SendCommandApiApi;

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKDELETELINKARCOMMAND body = ; // LKDELETELINKARCOMMAND | 
        try {
            apiInstance.apiDeleteLinkarPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiDeleteLinkarPost");
            e.printStackTrace();
        }
    }
}
LKDELETELINKARCOMMAND *body = ; //  (optional)

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

// Deletes one or several records in file. Recover Linkar item IDs.
[apiInstance apiDeleteLinkarPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LinkarRestApi = require('linkar_rest_api');

var api = new LinkarRestApi.SendCommandApiApi()
var opts = { 
  'body':  // {{LKDELETELINKARCOMMAND}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiDeleteLinkarPost(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiDeleteLinkarPostExample
    {
        public void main()
        {

            var apiInstance = new SendCommandApiApi();
            var body = new LKDELETELINKARCOMMAND(); // LKDELETELINKARCOMMAND |  (optional) 

            try
            {
                // Deletes one or several records in file. Recover Linkar item IDs.
                apiInstance.apiDeleteLinkarPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SendCommandApiApi.apiDeleteLinkarPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSendCommandApiApi();
$body = ; // LKDELETELINKARCOMMAND | 

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

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

eval { 
    $api_instance->apiDeleteLinkarPost(body => $body);
};
if ($@) {
    warn "Exception when calling SendCommandApiApi->apiDeleteLinkarPost: $@\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.SendCommandApiApi()
body =  # LKDELETELINKARCOMMAND |  (optional)

try: 
    # Deletes one or several records in file. Recover Linkar item IDs.
    api_instance.api_delete_linkar_post(body=body)
except ApiException as e:
    print("Exception when calling SendCommandApiApi->apiDeleteLinkarPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Success

Status: 400 - Error:Bad Request


apiDeletePost

Deletes one or several records in file.


/api/Delete

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json,application/xml"\
"//api/Delete"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SendCommandApiApi;

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

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKDELETECOMMAND body = ; // LKDELETECOMMAND | 
        try {
            apiInstance.apiDeletePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiDeletePost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SendCommandApiApi;

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKDELETECOMMAND body = ; // LKDELETECOMMAND | 
        try {
            apiInstance.apiDeletePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiDeletePost");
            e.printStackTrace();
        }
    }
}
LKDELETECOMMAND *body = ; //  (optional)

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

// Deletes one or several records in file.
[apiInstance apiDeletePostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LinkarRestApi = require('linkar_rest_api');

var api = new LinkarRestApi.SendCommandApiApi()
var opts = { 
  'body':  // {{LKDELETECOMMAND}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiDeletePost(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiDeletePostExample
    {
        public void main()
        {

            var apiInstance = new SendCommandApiApi();
            var body = new LKDELETECOMMAND(); // LKDELETECOMMAND |  (optional) 

            try
            {
                // Deletes one or several records in file.
                apiInstance.apiDeletePost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SendCommandApiApi.apiDeletePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSendCommandApiApi();
$body = ; // LKDELETECOMMAND | 

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

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

eval { 
    $api_instance->apiDeletePost(body => $body);
};
if ($@) {
    warn "Exception when calling SendCommandApiApi->apiDeletePost: $@\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.SendCommandApiApi()
body =  # LKDELETECOMMAND |  (optional)

try: 
    # Deletes one or several records in file.
    api_instance.api_delete_post(body=body)
except ApiException as e:
    print("Exception when calling SendCommandApiApi->apiDeletePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Success

Status: 400 - Error:Bad Request


apiDictionariesPost

Returns all the dictionaries of a file.


/api/Dictionaries

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json,application/xml"\
"//api/Dictionaries"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SendCommandApiApi;

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

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKDICTIONARIESCOMMAND body = ; // LKDICTIONARIESCOMMAND | 
        try {
            apiInstance.apiDictionariesPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiDictionariesPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SendCommandApiApi;

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKDICTIONARIESCOMMAND body = ; // LKDICTIONARIESCOMMAND | 
        try {
            apiInstance.apiDictionariesPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiDictionariesPost");
            e.printStackTrace();
        }
    }
}
LKDICTIONARIESCOMMAND *body = ; //  (optional)

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

// Returns all the dictionaries of a file.
[apiInstance apiDictionariesPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LinkarRestApi = require('linkar_rest_api');

var api = new LinkarRestApi.SendCommandApiApi()
var opts = { 
  'body':  // {{LKDICTIONARIESCOMMAND}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiDictionariesPost(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiDictionariesPostExample
    {
        public void main()
        {

            var apiInstance = new SendCommandApiApi();
            var body = new LKDICTIONARIESCOMMAND(); // LKDICTIONARIESCOMMAND |  (optional) 

            try
            {
                // Returns all the dictionaries of a file.
                apiInstance.apiDictionariesPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SendCommandApiApi.apiDictionariesPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSendCommandApiApi();
$body = ; // LKDICTIONARIESCOMMAND | 

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

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

eval { 
    $api_instance->apiDictionariesPost(body => $body);
};
if ($@) {
    warn "Exception when calling SendCommandApiApi->apiDictionariesPost: $@\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.SendCommandApiApi()
body =  # LKDICTIONARIESCOMMAND |  (optional)

try: 
    # Returns all the dictionaries of a file.
    api_instance.api_dictionaries_post(body=body)
except ApiException as e:
    print("Exception when calling SendCommandApiApi->apiDictionariesPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Success

Status: 400 - Error:Bad Request


apiExecutePost

Allows the execution of any command from the Database.


/api/Execute

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json,application/xml"\
"//api/Execute"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SendCommandApiApi;

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

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKEXECUTECOMMAND body = ; // LKEXECUTECOMMAND | 
        try {
            apiInstance.apiExecutePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiExecutePost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SendCommandApiApi;

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKEXECUTECOMMAND body = ; // LKEXECUTECOMMAND | 
        try {
            apiInstance.apiExecutePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiExecutePost");
            e.printStackTrace();
        }
    }
}
LKEXECUTECOMMAND *body = ; //  (optional)

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

// Allows the execution of any command from the Database.
[apiInstance apiExecutePostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LinkarRestApi = require('linkar_rest_api');

var api = new LinkarRestApi.SendCommandApiApi()
var opts = { 
  'body':  // {{LKEXECUTECOMMAND}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiExecutePost(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiExecutePostExample
    {
        public void main()
        {

            var apiInstance = new SendCommandApiApi();
            var body = new LKEXECUTECOMMAND(); // LKEXECUTECOMMAND |  (optional) 

            try
            {
                // Allows the execution of any command from the Database.
                apiInstance.apiExecutePost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SendCommandApiApi.apiExecutePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSendCommandApiApi();
$body = ; // LKEXECUTECOMMAND | 

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

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

eval { 
    $api_instance->apiExecutePost(body => $body);
};
if ($@) {
    warn "Exception when calling SendCommandApiApi->apiExecutePost: $@\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.SendCommandApiApi()
body =  # LKEXECUTECOMMAND |  (optional)

try: 
    # Allows the execution of any command from the Database.
    api_instance.api_execute_post(body=body)
except ApiException as e:
    print("Exception when calling SendCommandApiApi->apiExecutePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Success

Status: 400 - Error:Bad Request


apiFormatPost

Returns the result of executing the FMT function in a expressions list in the Database.


/api/Format

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json,application/xml"\
"//api/Format"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SendCommandApiApi;

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

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKFORMATCOMMAND body = ; // LKFORMATCOMMAND | 
        try {
            apiInstance.apiFormatPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiFormatPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SendCommandApiApi;

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKFORMATCOMMAND body = ; // LKFORMATCOMMAND | 
        try {
            apiInstance.apiFormatPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiFormatPost");
            e.printStackTrace();
        }
    }
}
LKFORMATCOMMAND *body = ; //  (optional)

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

// Returns the result of executing the FMT function in a expressions list in the Database.
[apiInstance apiFormatPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LinkarRestApi = require('linkar_rest_api');

var api = new LinkarRestApi.SendCommandApiApi()
var opts = { 
  'body':  // {{LKFORMATCOMMAND}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiFormatPost(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiFormatPostExample
    {
        public void main()
        {

            var apiInstance = new SendCommandApiApi();
            var body = new LKFORMATCOMMAND(); // LKFORMATCOMMAND |  (optional) 

            try
            {
                // Returns the result of executing the FMT function in a expressions list in the Database.
                apiInstance.apiFormatPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SendCommandApiApi.apiFormatPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSendCommandApiApi();
$body = ; // LKFORMATCOMMAND | 

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

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

eval { 
    $api_instance->apiFormatPost(body => $body);
};
if ($@) {
    warn "Exception when calling SendCommandApiApi->apiFormatPost: $@\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.SendCommandApiApi()
body =  # LKFORMATCOMMAND |  (optional)

try: 
    # Returns the result of executing the FMT function in a expressions list in the Database.
    api_instance.api_format_post(body=body)
except ApiException as e:
    print("Exception when calling SendCommandApiApi->apiFormatPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Success

Status: 400 - Error:Bad Request


apiGetTableDictionariesPost

Returns a query result in a table format in Dictionaries mode.


/api/GetTableDictionaries

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json,application/xml"\
"//api/GetTableDictionaries"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SendCommandApiApi;

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

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKGETTABLEDICTIONARIESCOMMAND body = ; // LKGETTABLEDICTIONARIESCOMMAND | 
        try {
            apiInstance.apiGetTableDictionariesPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiGetTableDictionariesPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SendCommandApiApi;

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKGETTABLEDICTIONARIESCOMMAND body = ; // LKGETTABLEDICTIONARIESCOMMAND | 
        try {
            apiInstance.apiGetTableDictionariesPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiGetTableDictionariesPost");
            e.printStackTrace();
        }
    }
}
LKGETTABLEDICTIONARIESCOMMAND *body = ; //  (optional)

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

// Returns a query result in a table format in Dictionaries mode.
[apiInstance apiGetTableDictionariesPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LinkarRestApi = require('linkar_rest_api');

var api = new LinkarRestApi.SendCommandApiApi()
var opts = { 
  'body':  // {{LKGETTABLEDICTIONARIESCOMMAND}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiGetTableDictionariesPost(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiGetTableDictionariesPostExample
    {
        public void main()
        {

            var apiInstance = new SendCommandApiApi();
            var body = new LKGETTABLEDICTIONARIESCOMMAND(); // LKGETTABLEDICTIONARIESCOMMAND |  (optional) 

            try
            {
                // Returns a query result in a table format in Dictionaries mode.
                apiInstance.apiGetTableDictionariesPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SendCommandApiApi.apiGetTableDictionariesPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSendCommandApiApi();
$body = ; // LKGETTABLEDICTIONARIESCOMMAND | 

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

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

eval { 
    $api_instance->apiGetTableDictionariesPost(body => $body);
};
if ($@) {
    warn "Exception when calling SendCommandApiApi->apiGetTableDictionariesPost: $@\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.SendCommandApiApi()
body =  # LKGETTABLEDICTIONARIESCOMMAND |  (optional)

try: 
    # Returns a query result in a table format in Dictionaries mode.
    api_instance.api_get_table_dictionaries_post(body=body)
except ApiException as e:
    print("Exception when calling SendCommandApiApi->apiGetTableDictionariesPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Success

Status: 400 - Error:Bad Request


apiGetTableNonePost

Returns a query result in a table format in None mode.


/api/GetTableNone

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json,application/xml"\
"//api/GetTableNone"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SendCommandApiApi;

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

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKGETTABLENONECOMMAND body = ; // LKGETTABLENONECOMMAND | 
        try {
            apiInstance.apiGetTableNonePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiGetTableNonePost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SendCommandApiApi;

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKGETTABLENONECOMMAND body = ; // LKGETTABLENONECOMMAND | 
        try {
            apiInstance.apiGetTableNonePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiGetTableNonePost");
            e.printStackTrace();
        }
    }
}
LKGETTABLENONECOMMAND *body = ; //  (optional)

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

// Returns a query result in a table format in None mode.
[apiInstance apiGetTableNonePostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LinkarRestApi = require('linkar_rest_api');

var api = new LinkarRestApi.SendCommandApiApi()
var opts = { 
  'body':  // {{LKGETTABLENONECOMMAND}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiGetTableNonePost(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiGetTableNonePostExample
    {
        public void main()
        {

            var apiInstance = new SendCommandApiApi();
            var body = new LKGETTABLENONECOMMAND(); // LKGETTABLENONECOMMAND |  (optional) 

            try
            {
                // Returns a query result in a table format in None mode.
                apiInstance.apiGetTableNonePost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SendCommandApiApi.apiGetTableNonePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSendCommandApiApi();
$body = ; // LKGETTABLENONECOMMAND | 

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

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

eval { 
    $api_instance->apiGetTableNonePost(body => $body);
};
if ($@) {
    warn "Exception when calling SendCommandApiApi->apiGetTableNonePost: $@\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.SendCommandApiApi()
body =  # LKGETTABLENONECOMMAND |  (optional)

try: 
    # Returns a query result in a table format in None mode.
    api_instance.api_get_table_none_post(body=body)
except ApiException as e:
    print("Exception when calling SendCommandApiApi->apiGetTableNonePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Success

Status: 400 - Error:Bad Request


apiGetTablePost

Returns a query result in a table format.


/api/GetTable

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json,application/xml"\
"//api/GetTable"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SendCommandApiApi;

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

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKGETTABLECOMMAND body = ; // LKGETTABLECOMMAND | 
        try {
            apiInstance.apiGetTablePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiGetTablePost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SendCommandApiApi;

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKGETTABLECOMMAND body = ; // LKGETTABLECOMMAND | 
        try {
            apiInstance.apiGetTablePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiGetTablePost");
            e.printStackTrace();
        }
    }
}
LKGETTABLECOMMAND *body = ; //  (optional)

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

// Returns a query result in a table format.
[apiInstance apiGetTablePostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LinkarRestApi = require('linkar_rest_api');

var api = new LinkarRestApi.SendCommandApiApi()
var opts = { 
  'body':  // {{LKGETTABLECOMMAND}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiGetTablePost(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiGetTablePostExample
    {
        public void main()
        {

            var apiInstance = new SendCommandApiApi();
            var body = new LKGETTABLECOMMAND(); // LKGETTABLECOMMAND |  (optional) 

            try
            {
                // Returns a query result in a table format.
                apiInstance.apiGetTablePost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SendCommandApiApi.apiGetTablePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSendCommandApiApi();
$body = ; // LKGETTABLECOMMAND | 

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

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

eval { 
    $api_instance->apiGetTablePost(body => $body);
};
if ($@) {
    warn "Exception when calling SendCommandApiApi->apiGetTablePost: $@\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.SendCommandApiApi()
body =  # LKGETTABLECOMMAND |  (optional)

try: 
    # Returns a query result in a table format.
    api_instance.api_get_table_post(body=body)
except ApiException as e:
    print("Exception when calling SendCommandApiApi->apiGetTablePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Success

Status: 400 - Error:Bad Request


apiGetTableSqlModePost

Returns a query result in a table format in SQL mode.


/api/GetTableSqlMode

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json,application/xml"\
"//api/GetTableSqlMode"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SendCommandApiApi;

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

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKGETTABLESQLMODECOMMAND body = ; // LKGETTABLESQLMODECOMMAND | 
        try {
            apiInstance.apiGetTableSqlModePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiGetTableSqlModePost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SendCommandApiApi;

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKGETTABLESQLMODECOMMAND body = ; // LKGETTABLESQLMODECOMMAND | 
        try {
            apiInstance.apiGetTableSqlModePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiGetTableSqlModePost");
            e.printStackTrace();
        }
    }
}
LKGETTABLESQLMODECOMMAND *body = ; //  (optional)

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

// Returns a query result in a table format in SQL mode.
[apiInstance apiGetTableSqlModePostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LinkarRestApi = require('linkar_rest_api');

var api = new LinkarRestApi.SendCommandApiApi()
var opts = { 
  'body':  // {{LKGETTABLESQLMODECOMMAND}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiGetTableSqlModePost(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiGetTableSqlModePostExample
    {
        public void main()
        {

            var apiInstance = new SendCommandApiApi();
            var body = new LKGETTABLESQLMODECOMMAND(); // LKGETTABLESQLMODECOMMAND |  (optional) 

            try
            {
                // Returns a query result in a table format in SQL mode.
                apiInstance.apiGetTableSqlModePost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SendCommandApiApi.apiGetTableSqlModePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSendCommandApiApi();
$body = ; // LKGETTABLESQLMODECOMMAND | 

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

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

eval { 
    $api_instance->apiGetTableSqlModePost(body => $body);
};
if ($@) {
    warn "Exception when calling SendCommandApiApi->apiGetTableSqlModePost: $@\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.SendCommandApiApi()
body =  # LKGETTABLESQLMODECOMMAND |  (optional)

try: 
    # Returns a query result in a table format in SQL mode.
    api_instance.api_get_table_sql_mode_post(body=body)
except ApiException as e:
    print("Exception when calling SendCommandApiApi->apiGetTableSqlModePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Success

Status: 400 - Error:Bad Request


apiGetVersionPost

Allows getting the server version.


/api/GetVersion

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json,application/xml"\
"//api/GetVersion"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SendCommandApiApi;

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

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKGETVERSIONCOMMAND body = ; // LKGETVERSIONCOMMAND | 
        try {
            apiInstance.apiGetVersionPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiGetVersionPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SendCommandApiApi;

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKGETVERSIONCOMMAND body = ; // LKGETVERSIONCOMMAND | 
        try {
            apiInstance.apiGetVersionPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiGetVersionPost");
            e.printStackTrace();
        }
    }
}
LKGETVERSIONCOMMAND *body = ; //  (optional)

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

// Allows getting the server version.
[apiInstance apiGetVersionPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LinkarRestApi = require('linkar_rest_api');

var api = new LinkarRestApi.SendCommandApiApi()
var opts = { 
  'body':  // {{LKGETVERSIONCOMMAND}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiGetVersionPost(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiGetVersionPostExample
    {
        public void main()
        {

            var apiInstance = new SendCommandApiApi();
            var body = new LKGETVERSIONCOMMAND(); // LKGETVERSIONCOMMAND |  (optional) 

            try
            {
                // Allows getting the server version.
                apiInstance.apiGetVersionPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SendCommandApiApi.apiGetVersionPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSendCommandApiApi();
$body = ; // LKGETVERSIONCOMMAND | 

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

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

eval { 
    $api_instance->apiGetVersionPost(body => $body);
};
if ($@) {
    warn "Exception when calling SendCommandApiApi->apiGetVersionPost: $@\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.SendCommandApiApi()
body =  # LKGETVERSIONCOMMAND |  (optional)

try: 
    # Allows getting the server version.
    api_instance.api_get_version_post(body=body)
except ApiException as e:
    print("Exception when calling SendCommandApiApi->apiGetVersionPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Success

Status: 400 - Error:Bad Request


apiLKSchemasDictionariesPost

Returns a list of all the Schemas defined in Linkar Schemas, or the EntryPoint account data files in Dictionaries mode.


/api/LKSchemasDictionaries

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json,application/xml"\
"//api/LKSchemasDictionaries"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SendCommandApiApi;

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

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKSCHEMASDICTIONARIESCOMMAND body = ; // LKSCHEMASDICTIONARIESCOMMAND | 
        try {
            apiInstance.apiLKSchemasDictionariesPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiLKSchemasDictionariesPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SendCommandApiApi;

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKSCHEMASDICTIONARIESCOMMAND body = ; // LKSCHEMASDICTIONARIESCOMMAND | 
        try {
            apiInstance.apiLKSchemasDictionariesPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiLKSchemasDictionariesPost");
            e.printStackTrace();
        }
    }
}
LKSCHEMASDICTIONARIESCOMMAND *body = ; //  (optional)

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

// Returns a list of all the Schemas defined in Linkar Schemas, or the EntryPoint account data files in Dictionaries mode.
[apiInstance apiLKSchemasDictionariesPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LinkarRestApi = require('linkar_rest_api');

var api = new LinkarRestApi.SendCommandApiApi()
var opts = { 
  'body':  // {{LKSCHEMASDICTIONARIESCOMMAND}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiLKSchemasDictionariesPost(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiLKSchemasDictionariesPostExample
    {
        public void main()
        {

            var apiInstance = new SendCommandApiApi();
            var body = new LKSCHEMASDICTIONARIESCOMMAND(); // LKSCHEMASDICTIONARIESCOMMAND |  (optional) 

            try
            {
                // Returns a list of all the Schemas defined in Linkar Schemas, or the EntryPoint account data files in Dictionaries mode.
                apiInstance.apiLKSchemasDictionariesPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SendCommandApiApi.apiLKSchemasDictionariesPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSendCommandApiApi();
$body = ; // LKSCHEMASDICTIONARIESCOMMAND | 

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

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

eval { 
    $api_instance->apiLKSchemasDictionariesPost(body => $body);
};
if ($@) {
    warn "Exception when calling SendCommandApiApi->apiLKSchemasDictionariesPost: $@\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.SendCommandApiApi()
body =  # LKSCHEMASDICTIONARIESCOMMAND |  (optional)

try: 
    # Returns a list of all the Schemas defined in Linkar Schemas, or the EntryPoint account data files in Dictionaries mode.
    api_instance.api_lk_schemas_dictionaries_post(body=body)
except ApiException as e:
    print("Exception when calling SendCommandApiApi->apiLKSchemasDictionariesPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Success

Status: 400 - Error:Bad Request


apiLkPropertiesDictionariesPost

Returns the Schema properties list defined in Linkar Schemas or the file dictionaries in Dictionaries Mode.


/api/LkPropertiesDictionaries

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json,application/xml"\
"//api/LkPropertiesDictionaries"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SendCommandApiApi;

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

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKPROPERTIESDICTIONARIESCOMMAND body = ; // LKPROPERTIESDICTIONARIESCOMMAND | 
        try {
            apiInstance.apiLkPropertiesDictionariesPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiLkPropertiesDictionariesPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SendCommandApiApi;

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKPROPERTIESDICTIONARIESCOMMAND body = ; // LKPROPERTIESDICTIONARIESCOMMAND | 
        try {
            apiInstance.apiLkPropertiesDictionariesPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiLkPropertiesDictionariesPost");
            e.printStackTrace();
        }
    }
}
LKPROPERTIESDICTIONARIESCOMMAND *body = ; //  (optional)

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

// Returns the Schema properties list defined in Linkar Schemas or the file dictionaries in Dictionaries Mode.
[apiInstance apiLkPropertiesDictionariesPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LinkarRestApi = require('linkar_rest_api');

var api = new LinkarRestApi.SendCommandApiApi()
var opts = { 
  'body':  // {{LKPROPERTIESDICTIONARIESCOMMAND}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiLkPropertiesDictionariesPost(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiLkPropertiesDictionariesPostExample
    {
        public void main()
        {

            var apiInstance = new SendCommandApiApi();
            var body = new LKPROPERTIESDICTIONARIESCOMMAND(); // LKPROPERTIESDICTIONARIESCOMMAND |  (optional) 

            try
            {
                // Returns the Schema properties list defined in Linkar Schemas or the file dictionaries in Dictionaries Mode.
                apiInstance.apiLkPropertiesDictionariesPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SendCommandApiApi.apiLkPropertiesDictionariesPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSendCommandApiApi();
$body = ; // LKPROPERTIESDICTIONARIESCOMMAND | 

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

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

eval { 
    $api_instance->apiLkPropertiesDictionariesPost(body => $body);
};
if ($@) {
    warn "Exception when calling SendCommandApiApi->apiLkPropertiesDictionariesPost: $@\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.SendCommandApiApi()
body =  # LKPROPERTIESDICTIONARIESCOMMAND |  (optional)

try: 
    # Returns the Schema properties list defined in Linkar Schemas or the file dictionaries in Dictionaries Mode.
    api_instance.api_lk_properties_dictionaries_post(body=body)
except ApiException as e:
    print("Exception when calling SendCommandApiApi->apiLkPropertiesDictionariesPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Success

Status: 400 - Error:Bad Request


apiLkPropertiesPost

Returns the Schema properties list defined in Linkar Schemas or the file dictionaries.


/api/LkProperties

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json,application/xml"\
"//api/LkProperties"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SendCommandApiApi;

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

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKPROPERTIESCOMMAND body = ; // LKPROPERTIESCOMMAND | 
        try {
            apiInstance.apiLkPropertiesPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiLkPropertiesPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SendCommandApiApi;

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKPROPERTIESCOMMAND body = ; // LKPROPERTIESCOMMAND | 
        try {
            apiInstance.apiLkPropertiesPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiLkPropertiesPost");
            e.printStackTrace();
        }
    }
}
LKPROPERTIESCOMMAND *body = ; //  (optional)

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

// Returns the Schema properties list defined in Linkar Schemas or the file dictionaries.
[apiInstance apiLkPropertiesPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LinkarRestApi = require('linkar_rest_api');

var api = new LinkarRestApi.SendCommandApiApi()
var opts = { 
  'body':  // {{LKPROPERTIESCOMMAND}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiLkPropertiesPost(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiLkPropertiesPostExample
    {
        public void main()
        {

            var apiInstance = new SendCommandApiApi();
            var body = new LKPROPERTIESCOMMAND(); // LKPROPERTIESCOMMAND |  (optional) 

            try
            {
                // Returns the Schema properties list defined in Linkar Schemas or the file dictionaries.
                apiInstance.apiLkPropertiesPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SendCommandApiApi.apiLkPropertiesPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSendCommandApiApi();
$body = ; // LKPROPERTIESCOMMAND | 

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

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

eval { 
    $api_instance->apiLkPropertiesPost(body => $body);
};
if ($@) {
    warn "Exception when calling SendCommandApiApi->apiLkPropertiesPost: $@\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.SendCommandApiApi()
body =  # LKPROPERTIESCOMMAND |  (optional)

try: 
    # Returns the Schema properties list defined in Linkar Schemas or the file dictionaries.
    api_instance.api_lk_properties_post(body=body)
except ApiException as e:
    print("Exception when calling SendCommandApiApi->apiLkPropertiesPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Success

Status: 400 - Error:Bad Request


apiLkPropertiesSqlModePost

Returns the Schema properties list defined in Linkar Schemas or the file dictionaries in SQL mode.


/api/LkPropertiesSqlMode

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json,application/xml"\
"//api/LkPropertiesSqlMode"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SendCommandApiApi;

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

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKPROPERTIESSQLMODECOMMAND body = ; // LKPROPERTIESSQLMODECOMMAND | 
        try {
            apiInstance.apiLkPropertiesSqlModePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiLkPropertiesSqlModePost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SendCommandApiApi;

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKPROPERTIESSQLMODECOMMAND body = ; // LKPROPERTIESSQLMODECOMMAND | 
        try {
            apiInstance.apiLkPropertiesSqlModePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiLkPropertiesSqlModePost");
            e.printStackTrace();
        }
    }
}
LKPROPERTIESSQLMODECOMMAND *body = ; //  (optional)

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

// Returns the Schema properties list defined in Linkar Schemas or the file dictionaries in SQL mode.
[apiInstance apiLkPropertiesSqlModePostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LinkarRestApi = require('linkar_rest_api');

var api = new LinkarRestApi.SendCommandApiApi()
var opts = { 
  'body':  // {{LKPROPERTIESSQLMODECOMMAND}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiLkPropertiesSqlModePost(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiLkPropertiesSqlModePostExample
    {
        public void main()
        {

            var apiInstance = new SendCommandApiApi();
            var body = new LKPROPERTIESSQLMODECOMMAND(); // LKPROPERTIESSQLMODECOMMAND |  (optional) 

            try
            {
                // Returns the Schema properties list defined in Linkar Schemas or the file dictionaries in SQL mode.
                apiInstance.apiLkPropertiesSqlModePost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SendCommandApiApi.apiLkPropertiesSqlModePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSendCommandApiApi();
$body = ; // LKPROPERTIESSQLMODECOMMAND | 

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

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

eval { 
    $api_instance->apiLkPropertiesSqlModePost(body => $body);
};
if ($@) {
    warn "Exception when calling SendCommandApiApi->apiLkPropertiesSqlModePost: $@\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.SendCommandApiApi()
body =  # LKPROPERTIESSQLMODECOMMAND |  (optional)

try: 
    # Returns the Schema properties list defined in Linkar Schemas or the file dictionaries in SQL mode.
    api_instance.api_lk_properties_sql_mode_post(body=body)
except ApiException as e:
    print("Exception when calling SendCommandApiApi->apiLkPropertiesSqlModePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Success

Status: 400 - Error:Bad Request


apiLkSchemasPost

Returns a list of all the Schemas defined in Linkar Schemas, or the EntryPoint account data files.


/api/LkSchemas

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json,application/xml"\
"//api/LkSchemas"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SendCommandApiApi;

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

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKSCHEMASCOMMAND body = ; // LKSCHEMASCOMMAND | 
        try {
            apiInstance.apiLkSchemasPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiLkSchemasPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SendCommandApiApi;

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKSCHEMASCOMMAND body = ; // LKSCHEMASCOMMAND | 
        try {
            apiInstance.apiLkSchemasPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiLkSchemasPost");
            e.printStackTrace();
        }
    }
}
LKSCHEMASCOMMAND *body = ; //  (optional)

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

// Returns a list of all the Schemas defined in Linkar Schemas, or the EntryPoint account data files.
[apiInstance apiLkSchemasPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LinkarRestApi = require('linkar_rest_api');

var api = new LinkarRestApi.SendCommandApiApi()
var opts = { 
  'body':  // {{LKSCHEMASCOMMAND}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiLkSchemasPost(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiLkSchemasPostExample
    {
        public void main()
        {

            var apiInstance = new SendCommandApiApi();
            var body = new LKSCHEMASCOMMAND(); // LKSCHEMASCOMMAND |  (optional) 

            try
            {
                // Returns a list of all the Schemas defined in Linkar Schemas, or the EntryPoint account data files.
                apiInstance.apiLkSchemasPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SendCommandApiApi.apiLkSchemasPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSendCommandApiApi();
$body = ; // LKSCHEMASCOMMAND | 

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

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

eval { 
    $api_instance->apiLkSchemasPost(body => $body);
};
if ($@) {
    warn "Exception when calling SendCommandApiApi->apiLkSchemasPost: $@\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.SendCommandApiApi()
body =  # LKSCHEMASCOMMAND |  (optional)

try: 
    # Returns a list of all the Schemas defined in Linkar Schemas, or the EntryPoint account data files.
    api_instance.api_lk_schemas_post(body=body)
except ApiException as e:
    print("Exception when calling SendCommandApiApi->apiLkSchemasPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Success

Status: 400 - Error:Bad Request


apiLkSchemasSqlModePost

Returns a list of all the Schemas defined in Linkar Schemas, or the EntryPoint account data files in SQL mode.


/api/LkSchemasSqlMode

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json,application/xml"\
"//api/LkSchemasSqlMode"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SendCommandApiApi;

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

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKSCHEMASSQLMODECOMMAND body = ; // LKSCHEMASSQLMODECOMMAND | 
        try {
            apiInstance.apiLkSchemasSqlModePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiLkSchemasSqlModePost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SendCommandApiApi;

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKSCHEMASSQLMODECOMMAND body = ; // LKSCHEMASSQLMODECOMMAND | 
        try {
            apiInstance.apiLkSchemasSqlModePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiLkSchemasSqlModePost");
            e.printStackTrace();
        }
    }
}
LKSCHEMASSQLMODECOMMAND *body = ; //  (optional)

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

// Returns a list of all the Schemas defined in Linkar Schemas, or the EntryPoint account data files in SQL mode.
[apiInstance apiLkSchemasSqlModePostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LinkarRestApi = require('linkar_rest_api');

var api = new LinkarRestApi.SendCommandApiApi()
var opts = { 
  'body':  // {{LKSCHEMASSQLMODECOMMAND}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiLkSchemasSqlModePost(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiLkSchemasSqlModePostExample
    {
        public void main()
        {

            var apiInstance = new SendCommandApiApi();
            var body = new LKSCHEMASSQLMODECOMMAND(); // LKSCHEMASSQLMODECOMMAND |  (optional) 

            try
            {
                // Returns a list of all the Schemas defined in Linkar Schemas, or the EntryPoint account data files in SQL mode.
                apiInstance.apiLkSchemasSqlModePost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SendCommandApiApi.apiLkSchemasSqlModePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSendCommandApiApi();
$body = ; // LKSCHEMASSQLMODECOMMAND | 

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

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

eval { 
    $api_instance->apiLkSchemasSqlModePost(body => $body);
};
if ($@) {
    warn "Exception when calling SendCommandApiApi->apiLkSchemasSqlModePost: $@\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.SendCommandApiApi()
body =  # LKSCHEMASSQLMODECOMMAND |  (optional)

try: 
    # Returns a list of all the Schemas defined in Linkar Schemas, or the EntryPoint account data files in SQL mode.
    api_instance.api_lk_schemas_sql_mode_post(body=body)
except ApiException as e:
    print("Exception when calling SendCommandApiApi->apiLkSchemasSqlModePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Success

Status: 400 - Error:Bad Request


apiNewCustomPost

Creates one or several records of a file. Generate Custom item IDs.


/api/NewCustom

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json,application/xml"\
"//api/NewCustom"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SendCommandApiApi;

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

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKNEWCUSTOMCOMMAND body = ; // LKNEWCUSTOMCOMMAND | 
        try {
            apiInstance.apiNewCustomPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiNewCustomPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SendCommandApiApi;

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKNEWCUSTOMCOMMAND body = ; // LKNEWCUSTOMCOMMAND | 
        try {
            apiInstance.apiNewCustomPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiNewCustomPost");
            e.printStackTrace();
        }
    }
}
LKNEWCUSTOMCOMMAND *body = ; //  (optional)

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

// Creates one or several records of a file. Generate Custom item IDs.
[apiInstance apiNewCustomPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LinkarRestApi = require('linkar_rest_api');

var api = new LinkarRestApi.SendCommandApiApi()
var opts = { 
  'body':  // {{LKNEWCUSTOMCOMMAND}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiNewCustomPost(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiNewCustomPostExample
    {
        public void main()
        {

            var apiInstance = new SendCommandApiApi();
            var body = new LKNEWCUSTOMCOMMAND(); // LKNEWCUSTOMCOMMAND |  (optional) 

            try
            {
                // Creates one or several records of a file. Generate Custom item IDs.
                apiInstance.apiNewCustomPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SendCommandApiApi.apiNewCustomPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSendCommandApiApi();
$body = ; // LKNEWCUSTOMCOMMAND | 

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

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

eval { 
    $api_instance->apiNewCustomPost(body => $body);
};
if ($@) {
    warn "Exception when calling SendCommandApiApi->apiNewCustomPost: $@\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.SendCommandApiApi()
body =  # LKNEWCUSTOMCOMMAND |  (optional)

try: 
    # Creates one or several records of a file. Generate Custom item IDs.
    api_instance.api_new_custom_post(body=body)
except ApiException as e:
    print("Exception when calling SendCommandApiApi->apiNewCustomPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Success

Status: 400 - Error:Bad Request


apiNewLinkarPost

Creates one or several records of a file. Generate Linkar item IDs.


/api/NewLinkar

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json,application/xml"\
"//api/NewLinkar"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SendCommandApiApi;

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

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKNEWLINKARCOMMAND body = ; // LKNEWLINKARCOMMAND | 
        try {
            apiInstance.apiNewLinkarPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiNewLinkarPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SendCommandApiApi;

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKNEWLINKARCOMMAND body = ; // LKNEWLINKARCOMMAND | 
        try {
            apiInstance.apiNewLinkarPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiNewLinkarPost");
            e.printStackTrace();
        }
    }
}
LKNEWLINKARCOMMAND *body = ; //  (optional)

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

// Creates one or several records of a file. Generate Linkar item IDs.
[apiInstance apiNewLinkarPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LinkarRestApi = require('linkar_rest_api');

var api = new LinkarRestApi.SendCommandApiApi()
var opts = { 
  'body':  // {{LKNEWLINKARCOMMAND}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiNewLinkarPost(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiNewLinkarPostExample
    {
        public void main()
        {

            var apiInstance = new SendCommandApiApi();
            var body = new LKNEWLINKARCOMMAND(); // LKNEWLINKARCOMMAND |  (optional) 

            try
            {
                // Creates one or several records of a file. Generate Linkar item IDs.
                apiInstance.apiNewLinkarPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SendCommandApiApi.apiNewLinkarPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSendCommandApiApi();
$body = ; // LKNEWLINKARCOMMAND | 

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

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

eval { 
    $api_instance->apiNewLinkarPost(body => $body);
};
if ($@) {
    warn "Exception when calling SendCommandApiApi->apiNewLinkarPost: $@\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.SendCommandApiApi()
body =  # LKNEWLINKARCOMMAND |  (optional)

try: 
    # Creates one or several records of a file. Generate Linkar item IDs.
    api_instance.api_new_linkar_post(body=body)
except ApiException as e:
    print("Exception when calling SendCommandApiApi->apiNewLinkarPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Success

Status: 400 - Error:Bad Request


apiNewPost

Creates one or several records of a file.


/api/New

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json,application/xml"\
"//api/New"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SendCommandApiApi;

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

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKNEWCOMMAND body = ; // LKNEWCOMMAND | 
        try {
            apiInstance.apiNewPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiNewPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SendCommandApiApi;

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKNEWCOMMAND body = ; // LKNEWCOMMAND | 
        try {
            apiInstance.apiNewPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiNewPost");
            e.printStackTrace();
        }
    }
}
LKNEWCOMMAND *body = ; //  (optional)

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

// Creates one or several records of a file.
[apiInstance apiNewPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LinkarRestApi = require('linkar_rest_api');

var api = new LinkarRestApi.SendCommandApiApi()
var opts = { 
  'body':  // {{LKNEWCOMMAND}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiNewPost(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiNewPostExample
    {
        public void main()
        {

            var apiInstance = new SendCommandApiApi();
            var body = new LKNEWCOMMAND(); // LKNEWCOMMAND |  (optional) 

            try
            {
                // Creates one or several records of a file.
                apiInstance.apiNewPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SendCommandApiApi.apiNewPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSendCommandApiApi();
$body = ; // LKNEWCOMMAND | 

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

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

eval { 
    $api_instance->apiNewPost(body => $body);
};
if ($@) {
    warn "Exception when calling SendCommandApiApi->apiNewPost: $@\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.SendCommandApiApi()
body =  # LKNEWCOMMAND |  (optional)

try: 
    # Creates one or several records of a file.
    api_instance.api_new_post(body=body)
except ApiException as e:
    print("Exception when calling SendCommandApiApi->apiNewPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Success

Status: 400 - Error:Bad Request


apiNewRandomPost

Creates one or several records of a file. Generate Random item IDs.


/api/NewRandom

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json,application/xml"\
"//api/NewRandom"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SendCommandApiApi;

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

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKNEWRANDOMCOMMAND body = ; // LKNEWRANDOMCOMMAND | 
        try {
            apiInstance.apiNewRandomPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiNewRandomPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SendCommandApiApi;

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKNEWRANDOMCOMMAND body = ; // LKNEWRANDOMCOMMAND | 
        try {
            apiInstance.apiNewRandomPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiNewRandomPost");
            e.printStackTrace();
        }
    }
}
LKNEWRANDOMCOMMAND *body = ; //  (optional)

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

// Creates one or several records of a file. Generate Random item IDs.
[apiInstance apiNewRandomPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LinkarRestApi = require('linkar_rest_api');

var api = new LinkarRestApi.SendCommandApiApi()
var opts = { 
  'body':  // {{LKNEWRANDOMCOMMAND}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiNewRandomPost(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiNewRandomPostExample
    {
        public void main()
        {

            var apiInstance = new SendCommandApiApi();
            var body = new LKNEWRANDOMCOMMAND(); // LKNEWRANDOMCOMMAND |  (optional) 

            try
            {
                // Creates one or several records of a file. Generate Random item IDs.
                apiInstance.apiNewRandomPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SendCommandApiApi.apiNewRandomPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSendCommandApiApi();
$body = ; // LKNEWRANDOMCOMMAND | 

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

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

eval { 
    $api_instance->apiNewRandomPost(body => $body);
};
if ($@) {
    warn "Exception when calling SendCommandApiApi->apiNewRandomPost: $@\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.SendCommandApiApi()
body =  # LKNEWRANDOMCOMMAND |  (optional)

try: 
    # Creates one or several records of a file. Generate Random item IDs.
    api_instance.api_new_random_post(body=body)
except ApiException as e:
    print("Exception when calling SendCommandApiApi->apiNewRandomPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Success

Status: 400 - Error:Bad Request


apiReadPost

Reads one or several records of a file.


/api/Read

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json,application/xml"\
"//api/Read"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SendCommandApiApi;

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

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKREADCOMMAND body = ; // LKREADCOMMAND | 
        try {
            apiInstance.apiReadPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiReadPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SendCommandApiApi;

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKREADCOMMAND body = ; // LKREADCOMMAND | 
        try {
            apiInstance.apiReadPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiReadPost");
            e.printStackTrace();
        }
    }
}
LKREADCOMMAND *body = ; //  (optional)

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

// Reads one or several records of a file.
[apiInstance apiReadPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LinkarRestApi = require('linkar_rest_api');

var api = new LinkarRestApi.SendCommandApiApi()
var opts = { 
  'body':  // {{LKREADCOMMAND}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiReadPost(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiReadPostExample
    {
        public void main()
        {

            var apiInstance = new SendCommandApiApi();
            var body = new LKREADCOMMAND(); // LKREADCOMMAND |  (optional) 

            try
            {
                // Reads one or several records of a file.
                apiInstance.apiReadPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SendCommandApiApi.apiReadPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSendCommandApiApi();
$body = ; // LKREADCOMMAND | 

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

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

eval { 
    $api_instance->apiReadPost(body => $body);
};
if ($@) {
    warn "Exception when calling SendCommandApiApi->apiReadPost: $@\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.SendCommandApiApi()
body =  # LKREADCOMMAND |  (optional)

try: 
    # Reads one or several records of a file.
    api_instance.api_read_post(body=body)
except ApiException as e:
    print("Exception when calling SendCommandApiApi->apiReadPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Success

Status: 400 - Error:Bad Request


apiResetCommonBlocksPost

Resets the COMMON variables with the 100 most used files


/api/ResetCommonBlocks

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json,application/xml"\
"//api/ResetCommonBlocks"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SendCommandApiApi;

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

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKRESETCOMMONBLOCKSCOMMAND body = ; // LKRESETCOMMONBLOCKSCOMMAND | 
        try {
            apiInstance.apiResetCommonBlocksPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiResetCommonBlocksPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SendCommandApiApi;

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKRESETCOMMONBLOCKSCOMMAND body = ; // LKRESETCOMMONBLOCKSCOMMAND | 
        try {
            apiInstance.apiResetCommonBlocksPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiResetCommonBlocksPost");
            e.printStackTrace();
        }
    }
}
LKRESETCOMMONBLOCKSCOMMAND *body = ; //  (optional)

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

// Resets the COMMON variables with the 100 most used files
[apiInstance apiResetCommonBlocksPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LinkarRestApi = require('linkar_rest_api');

var api = new LinkarRestApi.SendCommandApiApi()
var opts = { 
  'body':  // {{LKRESETCOMMONBLOCKSCOMMAND}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiResetCommonBlocksPost(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiResetCommonBlocksPostExample
    {
        public void main()
        {

            var apiInstance = new SendCommandApiApi();
            var body = new LKRESETCOMMONBLOCKSCOMMAND(); // LKRESETCOMMONBLOCKSCOMMAND |  (optional) 

            try
            {
                // Resets the COMMON variables with the 100 most used files
                apiInstance.apiResetCommonBlocksPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SendCommandApiApi.apiResetCommonBlocksPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSendCommandApiApi();
$body = ; // LKRESETCOMMONBLOCKSCOMMAND | 

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

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

eval { 
    $api_instance->apiResetCommonBlocksPost(body => $body);
};
if ($@) {
    warn "Exception when calling SendCommandApiApi->apiResetCommonBlocksPost: $@\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.SendCommandApiApi()
body =  # LKRESETCOMMONBLOCKSCOMMAND |  (optional)

try: 
    # Resets the COMMON variables with the 100 most used files
    api_instance.api_reset_common_blocks_post(body=body)
except ApiException as e:
    print("Exception when calling SendCommandApiApi->apiResetCommonBlocksPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Success

Status: 400 - Error:Bad Request


apiSelectPost

Executes a Query in the Database.


/api/Select

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json,application/xml"\
"//api/Select"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SendCommandApiApi;

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

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKSELECTCOMMAND body = ; // LKSELECTCOMMAND | 
        try {
            apiInstance.apiSelectPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiSelectPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SendCommandApiApi;

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKSELECTCOMMAND body = ; // LKSELECTCOMMAND | 
        try {
            apiInstance.apiSelectPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiSelectPost");
            e.printStackTrace();
        }
    }
}
LKSELECTCOMMAND *body = ; //  (optional)

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

// Executes a Query in the Database.
[apiInstance apiSelectPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LinkarRestApi = require('linkar_rest_api');

var api = new LinkarRestApi.SendCommandApiApi()
var opts = { 
  'body':  // {{LKSELECTCOMMAND}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiSelectPost(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiSelectPostExample
    {
        public void main()
        {

            var apiInstance = new SendCommandApiApi();
            var body = new LKSELECTCOMMAND(); // LKSELECTCOMMAND |  (optional) 

            try
            {
                // Executes a Query in the Database.
                apiInstance.apiSelectPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SendCommandApiApi.apiSelectPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSendCommandApiApi();
$body = ; // LKSELECTCOMMAND | 

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

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

eval { 
    $api_instance->apiSelectPost(body => $body);
};
if ($@) {
    warn "Exception when calling SendCommandApiApi->apiSelectPost: $@\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.SendCommandApiApi()
body =  # LKSELECTCOMMAND |  (optional)

try: 
    # Executes a Query in the Database.
    api_instance.api_select_post(body=body)
except ApiException as e:
    print("Exception when calling SendCommandApiApi->apiSelectPost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Success

Status: 400 - Error:Bad Request


apiSubroutinePost

Executes a subroutine.


/api/Subroutine

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json,application/xml"\
"//api/Subroutine"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SendCommandApiApi;

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

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKSUBROUTINECOMMAND body = ; // LKSUBROUTINECOMMAND | 
        try {
            apiInstance.apiSubroutinePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiSubroutinePost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SendCommandApiApi;

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKSUBROUTINECOMMAND body = ; // LKSUBROUTINECOMMAND | 
        try {
            apiInstance.apiSubroutinePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiSubroutinePost");
            e.printStackTrace();
        }
    }
}
LKSUBROUTINECOMMAND *body = ; //  (optional)

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

// Executes a subroutine.
[apiInstance apiSubroutinePostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LinkarRestApi = require('linkar_rest_api');

var api = new LinkarRestApi.SendCommandApiApi()
var opts = { 
  'body':  // {{LKSUBROUTINECOMMAND}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiSubroutinePost(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiSubroutinePostExample
    {
        public void main()
        {

            var apiInstance = new SendCommandApiApi();
            var body = new LKSUBROUTINECOMMAND(); // LKSUBROUTINECOMMAND |  (optional) 

            try
            {
                // Executes a subroutine.
                apiInstance.apiSubroutinePost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SendCommandApiApi.apiSubroutinePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSendCommandApiApi();
$body = ; // LKSUBROUTINECOMMAND | 

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

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

eval { 
    $api_instance->apiSubroutinePost(body => $body);
};
if ($@) {
    warn "Exception when calling SendCommandApiApi->apiSubroutinePost: $@\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.SendCommandApiApi()
body =  # LKSUBROUTINECOMMAND |  (optional)

try: 
    # Executes a subroutine.
    api_instance.api_subroutine_post(body=body)
except ApiException as e:
    print("Exception when calling SendCommandApiApi->apiSubroutinePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Success

Status: 400 - Error:Bad Request


apiUpdatePost

Update one or several records of a file.


/api/Update

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json,application/xml"\
"//api/Update"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SendCommandApiApi;

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

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKUPDATECOMMAND body = ; // LKUPDATECOMMAND | 
        try {
            apiInstance.apiUpdatePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiUpdatePost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SendCommandApiApi;

public class SendCommandApiApiExample {

    public static void main(String[] args) {
        SendCommandApiApi apiInstance = new SendCommandApiApi();
        LKUPDATECOMMAND body = ; // LKUPDATECOMMAND | 
        try {
            apiInstance.apiUpdatePost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling SendCommandApiApi#apiUpdatePost");
            e.printStackTrace();
        }
    }
}
LKUPDATECOMMAND *body = ; //  (optional)

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

// Update one or several records of a file.
[apiInstance apiUpdatePostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var LinkarRestApi = require('linkar_rest_api');

var api = new LinkarRestApi.SendCommandApiApi()
var opts = { 
  'body':  // {{LKUPDATECOMMAND}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.apiUpdatePost(opts, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class apiUpdatePostExample
    {
        public void main()
        {

            var apiInstance = new SendCommandApiApi();
            var body = new LKUPDATECOMMAND(); // LKUPDATECOMMAND |  (optional) 

            try
            {
                // Update one or several records of a file.
                apiInstance.apiUpdatePost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SendCommandApiApi.apiUpdatePost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiSendCommandApiApi();
$body = ; // LKUPDATECOMMAND | 

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

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

eval { 
    $api_instance->apiUpdatePost(body => $body);
};
if ($@) {
    warn "Exception when calling SendCommandApiApi->apiUpdatePost: $@\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.SendCommandApiApi()
body =  # LKUPDATECOMMAND |  (optional)

try: 
    # Update one or several records of a file.
    api_instance.api_update_post(body=body)
except ApiException as e:
    print("Exception when calling SendCommandApiApi->apiUpdatePost: %s\n" % e)

Parameters

Body parameters
Name Description
body

Responses

Status: 200 - Success

Status: 400 - Error:Bad Request