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

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

public class AdminsApiExample {

    public static void main(String[] args) {
        
        AdminsApi apiInstance = new AdminsApi();
        String adminId = adminId_example; // String | Admin Username (ADM_ID)
        AdminPushToken Object body = ; // AdminPushToken Object | Admin Push Token Object
        try {
            apiInstance.createAdminPushToken(adminId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminsApi#createAdminPushToken");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdminsApi;

public class AdminsApiExample {

    public static void main(String[] args) {
        AdminsApi apiInstance = new AdminsApi();
        String adminId = adminId_example; // String | Admin Username (ADM_ID)
        AdminPushToken Object body = ; // AdminPushToken Object | Admin Push Token Object
        try {
            apiInstance.createAdminPushToken(adminId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminsApi#createAdminPushToken");
            e.printStackTrace();
        }
    }
}

String *adminId = adminId_example; // Admin Username (ADM_ID)
AdminPushToken Object *body = ; // Admin Push Token Object

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

// Generate a push token of a specific administrator
[apiInstance createAdminPushTokenWith:adminId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GenianNacRestApiFor3rdParty = require('genian_nac_rest_api_for_3rd_party');

var api = new GenianNacRestApiFor3rdParty.AdminsApi()

var adminId = adminId_example; // {String} Admin Username (ADM_ID)

var body = ; // {AdminPushToken Object} Admin Push Token Object


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

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

namespace Example
{
    public class createAdminPushTokenExample
    {
        public void main()
        {
            
            var apiInstance = new AdminsApi();
            var adminId = adminId_example;  // String | Admin Username (ADM_ID)
            var body = new AdminPushToken Object(); // AdminPushToken Object | Admin Push Token Object

            try
            {
                // Generate a push token of a specific administrator
                apiInstance.createAdminPushToken(adminId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdminsApi.createAdminPushToken: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AdminsApi();
$adminId = adminId_example; // String | Admin Username (ADM_ID)
$body = ; // AdminPushToken Object | Admin Push Token Object

try {
    $api_instance->createAdminPushToken($adminId, $body);
} catch (Exception $e) {
    echo 'Exception when calling AdminsApi->createAdminPushToken: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::AdminsApi->new();
my $adminId = adminId_example; # String | Admin Username (ADM_ID)
my $body = WWW::SwaggerClient::Object::AdminPushToken Object->new(); # AdminPushToken Object | Admin Push Token Object

eval { 
    $api_instance->createAdminPushToken(adminId => $adminId, body => $body);
};
if ($@) {
    warn "Exception when calling AdminsApi->createAdminPushToken: $@\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.AdminsApi()
adminId = adminId_example # String | Admin Username (ADM_ID)
body =  # AdminPushToken Object | Admin Push Token Object

try: 
    # Generate a push token of a specific administrator
    api_instance.create_admin_push_token(adminId, body)
except ApiException as e:
    print("Exception when calling AdminsApi->createAdminPushToken: %s\n" % e)

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

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

public class AdminsApiExample {

    public static void main(String[] args) {
        
        AdminsApi apiInstance = new AdminsApi();
        String adminId = adminId_example; // String | Admin Username (ADM_ID)
        String deviceIds = deviceIds_example; // String | DeviceId
        try {
            apiInstance.deleteAdminPushTokens(adminId, deviceIds);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminsApi#deleteAdminPushTokens");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdminsApi;

public class AdminsApiExample {

    public static void main(String[] args) {
        AdminsApi apiInstance = new AdminsApi();
        String adminId = adminId_example; // String | Admin Username (ADM_ID)
        String deviceIds = deviceIds_example; // String | DeviceId
        try {
            apiInstance.deleteAdminPushTokens(adminId, deviceIds);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminsApi#deleteAdminPushTokens");
            e.printStackTrace();
        }
    }
}

String *adminId = adminId_example; // Admin Username (ADM_ID)
String *deviceIds = deviceIds_example; // DeviceId

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

// Remove a push token of a specific administrator
[apiInstance deleteAdminPushTokensWith:adminId
    deviceIds:deviceIds
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GenianNacRestApiFor3rdParty = require('genian_nac_rest_api_for_3rd_party');

var api = new GenianNacRestApiFor3rdParty.AdminsApi()

var adminId = adminId_example; // {String} Admin Username (ADM_ID)

var deviceIds = deviceIds_example; // {String} DeviceId


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteAdminPushTokens(adminId, deviceIds, callback);

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

namespace Example
{
    public class deleteAdminPushTokensExample
    {
        public void main()
        {
            
            var apiInstance = new AdminsApi();
            var adminId = adminId_example;  // String | Admin Username (ADM_ID)
            var deviceIds = deviceIds_example;  // String | DeviceId

            try
            {
                // Remove a push token of a specific administrator
                apiInstance.deleteAdminPushTokens(adminId, deviceIds);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdminsApi.deleteAdminPushTokens: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AdminsApi();
$adminId = adminId_example; // String | Admin Username (ADM_ID)
$deviceIds = deviceIds_example; // String | DeviceId

try {
    $api_instance->deleteAdminPushTokens($adminId, $deviceIds);
} catch (Exception $e) {
    echo 'Exception when calling AdminsApi->deleteAdminPushTokens: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::AdminsApi->new();
my $adminId = adminId_example; # String | Admin Username (ADM_ID)
my $deviceIds = deviceIds_example; # String | DeviceId

eval { 
    $api_instance->deleteAdminPushTokens(adminId => $adminId, deviceIds => $deviceIds);
};
if ($@) {
    warn "Exception when calling AdminsApi->deleteAdminPushTokens: $@\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.AdminsApi()
adminId = adminId_example # String | Admin Username (ADM_ID)
deviceIds = deviceIds_example # String | DeviceId

try: 
    # Remove a push token of a specific administrator
    api_instance.delete_admin_push_tokens(adminId, deviceIds)
except ApiException as e:
    print("Exception when calling AdminsApi->deleteAdminPushTokens: %s\n" % e)

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

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

public class AdminsApiExample {

    public static void main(String[] args) {
        
        AdminsApi apiInstance = new AdminsApi();
        String adminId = adminId_example; // String | Admin Username (ADM_ID)
        String deviceId = deviceId_example; // String | DeviceId
        try {
            apiInstance.getAdminPushTokens(adminId, deviceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminsApi#getAdminPushTokens");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdminsApi;

public class AdminsApiExample {

    public static void main(String[] args) {
        AdminsApi apiInstance = new AdminsApi();
        String adminId = adminId_example; // String | Admin Username (ADM_ID)
        String deviceId = deviceId_example; // String | DeviceId
        try {
            apiInstance.getAdminPushTokens(adminId, deviceId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminsApi#getAdminPushTokens");
            e.printStackTrace();
        }
    }
}

String *adminId = adminId_example; // Admin Username (ADM_ID)
String *deviceId = deviceId_example; // DeviceId (optional)

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

// Retrieve a specific administrator's push token
[apiInstance getAdminPushTokensWith:adminId
    deviceId:deviceId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GenianNacRestApiFor3rdParty = require('genian_nac_rest_api_for_3rd_party');

var api = new GenianNacRestApiFor3rdParty.AdminsApi()

var adminId = adminId_example; // {String} Admin Username (ADM_ID)

var opts = { 
  'deviceId': deviceId_example // {String} DeviceId
};

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

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

namespace Example
{
    public class getAdminPushTokensExample
    {
        public void main()
        {
            
            var apiInstance = new AdminsApi();
            var adminId = adminId_example;  // String | Admin Username (ADM_ID)
            var deviceId = deviceId_example;  // String | DeviceId (optional) 

            try
            {
                // Retrieve a specific administrator's push token
                apiInstance.getAdminPushTokens(adminId, deviceId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdminsApi.getAdminPushTokens: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AdminsApi();
$adminId = adminId_example; // String | Admin Username (ADM_ID)
$deviceId = deviceId_example; // String | DeviceId

try {
    $api_instance->getAdminPushTokens($adminId, $deviceId);
} catch (Exception $e) {
    echo 'Exception when calling AdminsApi->getAdminPushTokens: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::AdminsApi->new();
my $adminId = adminId_example; # String | Admin Username (ADM_ID)
my $deviceId = deviceId_example; # String | DeviceId

eval { 
    $api_instance->getAdminPushTokens(adminId => $adminId, deviceId => $deviceId);
};
if ($@) {
    warn "Exception when calling AdminsApi->getAdminPushTokens: $@\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.AdminsApi()
adminId = adminId_example # String | Admin Username (ADM_ID)
deviceId = deviceId_example # String | DeviceId (optional)

try: 
    # Retrieve a specific administrator's push token
    api_instance.get_admin_push_tokens(adminId, deviceId=deviceId)
except ApiException as e:
    print("Exception when calling AdminsApi->getAdminPushTokens: %s\n" % e)

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

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

public class AdminsApiExample {

    public static void main(String[] args) {
        
        AdminsApi apiInstance = new AdminsApi();
        String adminId = adminId_example; // String | Admin Username (ADM_ID)
        AdminPushToken Object body = ; // AdminPushToken Object | Admin Push Token Object
        try {
            apiInstance.updateAdminPushToken(adminId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminsApi#updateAdminPushToken");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdminsApi;

public class AdminsApiExample {

    public static void main(String[] args) {
        AdminsApi apiInstance = new AdminsApi();
        String adminId = adminId_example; // String | Admin Username (ADM_ID)
        AdminPushToken Object body = ; // AdminPushToken Object | Admin Push Token Object
        try {
            apiInstance.updateAdminPushToken(adminId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminsApi#updateAdminPushToken");
            e.printStackTrace();
        }
    }
}

String *adminId = adminId_example; // Admin Username (ADM_ID)
AdminPushToken Object *body = ; // Admin Push Token Object

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

// Update an existing push token of a specific administrator
[apiInstance updateAdminPushTokenWith:adminId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GenianNacRestApiFor3rdParty = require('genian_nac_rest_api_for_3rd_party');

var api = new GenianNacRestApiFor3rdParty.AdminsApi()

var adminId = adminId_example; // {String} Admin Username (ADM_ID)

var body = ; // {AdminPushToken Object} Admin Push Token Object


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

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

namespace Example
{
    public class updateAdminPushTokenExample
    {
        public void main()
        {
            
            var apiInstance = new AdminsApi();
            var adminId = adminId_example;  // String | Admin Username (ADM_ID)
            var body = new AdminPushToken Object(); // AdminPushToken Object | Admin Push Token Object

            try
            {
                // Update an existing push token of a specific administrator
                apiInstance.updateAdminPushToken(adminId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdminsApi.updateAdminPushToken: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\AdminsApi();
$adminId = adminId_example; // String | Admin Username (ADM_ID)
$body = ; // AdminPushToken Object | Admin Push Token Object

try {
    $api_instance->updateAdminPushToken($adminId, $body);
} catch (Exception $e) {
    echo 'Exception when calling AdminsApi->updateAdminPushToken: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::AdminsApi->new();
my $adminId = adminId_example; # String | Admin Username (ADM_ID)
my $body = WWW::SwaggerClient::Object::AdminPushToken Object->new(); # AdminPushToken Object | Admin Push Token Object

eval { 
    $api_instance->updateAdminPushToken(adminId => $adminId, body => $body);
};
if ($@) {
    warn "Exception when calling AdminsApi->updateAdminPushToken: $@\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.AdminsApi()
adminId = adminId_example # String | Admin Username (ADM_ID)
body =  # AdminPushToken Object | Admin Push Token Object

try: 
    # Update an existing push token of a specific administrator
    api_instance.update_admin_push_token(adminId, body)
except ApiException as e:
    print("Exception when calling AdminsApi->updateAdminPushToken: %s\n" % e)

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

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

public class CommondataApiExample {

    public static void main(String[] args) {
        
        CommondataApi apiInstance = new CommondataApi();
        String type = type_example; // String | CM_TYPE
        String code = code_example; // String | CM_CODE
        try {
            apiInstance.getCodeMap(type, code);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommondataApi#getCodeMap");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CommondataApi;

public class CommondataApiExample {

    public static void main(String[] args) {
        CommondataApi apiInstance = new CommondataApi();
        String type = type_example; // String | CM_TYPE
        String code = code_example; // String | CM_CODE
        try {
            apiInstance.getCodeMap(type, code);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommondataApi#getCodeMap");
            e.printStackTrace();
        }
    }
}

String *type = type_example; // CM_TYPE
String *code = code_example; // CM_CODE

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

// Retrieve a specific CODEMAP's data
[apiInstance getCodeMapWith:type
    code:code
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GenianNacRestApiFor3rdParty = require('genian_nac_rest_api_for_3rd_party');

var api = new GenianNacRestApiFor3rdParty.CommondataApi()

var type = type_example; // {String} CM_TYPE

var code = code_example; // {String} CM_CODE


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.getCodeMap(type, code, callback);

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

namespace Example
{
    public class getCodeMapExample
    {
        public void main()
        {
            
            var apiInstance = new CommondataApi();
            var type = type_example;  // String | CM_TYPE
            var code = code_example;  // String | CM_CODE

            try
            {
                // Retrieve a specific CODEMAP's data
                apiInstance.getCodeMap(type, code);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CommondataApi.getCodeMap: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\CommondataApi();
$type = type_example; // String | CM_TYPE
$code = code_example; // String | CM_CODE

try {
    $api_instance->getCodeMap($type, $code);
} catch (Exception $e) {
    echo 'Exception when calling CommondataApi->getCodeMap: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::CommondataApi->new();
my $type = type_example; # String | CM_TYPE
my $code = code_example; # String | CM_CODE

eval { 
    $api_instance->getCodeMap(type => $type, code => $code);
};
if ($@) {
    warn "Exception when calling CommondataApi->getCodeMap: $@\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.CommondataApi()
type = type_example # String | CM_TYPE
code = code_example # String | CM_CODE

try: 
    # Retrieve a specific CODEMAP's data
    api_instance.get_code_map(type, code)
except ApiException as e:
    print("Exception when calling CommondataApi->getCodeMap: %s\n" % e)

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

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

public class CommondataApiExample {

    public static void main(String[] args) {
        
        CommondataApi apiInstance = new CommondataApi();
        String type = type_example; // String | CM_TYPE
        try {
            apiInstance.getCodeMaps(type);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommondataApi#getCodeMaps");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CommondataApi;

public class CommondataApiExample {

    public static void main(String[] args) {
        CommondataApi apiInstance = new CommondataApi();
        String type = type_example; // String | CM_TYPE
        try {
            apiInstance.getCodeMaps(type);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommondataApi#getCodeMaps");
            e.printStackTrace();
        }
    }
}

String *type = type_example; // CM_TYPE

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

// Retrieve a specific CODEMAP's data
[apiInstance getCodeMapsWith:type
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GenianNacRestApiFor3rdParty = require('genian_nac_rest_api_for_3rd_party');

var api = new GenianNacRestApiFor3rdParty.CommondataApi()

var type = type_example; // {String} CM_TYPE


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.getCodeMaps(type, callback);

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

namespace Example
{
    public class getCodeMapsExample
    {
        public void main()
        {
            
            var apiInstance = new CommondataApi();
            var type = type_example;  // String | CM_TYPE

            try
            {
                // Retrieve a specific CODEMAP's data
                apiInstance.getCodeMaps(type);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CommondataApi.getCodeMaps: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\CommondataApi();
$type = type_example; // String | CM_TYPE

try {
    $api_instance->getCodeMaps($type);
} catch (Exception $e) {
    echo 'Exception when calling CommondataApi->getCodeMaps: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::CommondataApi->new();
my $type = type_example; # String | CM_TYPE

eval { 
    $api_instance->getCodeMaps(type => $type);
};
if ($@) {
    warn "Exception when calling CommondataApi->getCodeMaps: $@\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.CommondataApi()
type = type_example # String | CM_TYPE

try: 
    # Retrieve a specific CODEMAP's data
    api_instance.get_code_maps(type)
except ApiException as e:
    print("Exception when calling CommondataApi->getCodeMaps: %s\n" % e)

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

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

public class CommondataApiExample {

    public static void main(String[] args) {
        
        CommondataApi apiInstance = new CommondataApi();
        String catgry = catgry_example; // String | CONF_CATGRY
        String key = key_example; // String | CONF_KEY
        try {
            apiInstance.getConf(catgry, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommondataApi#getConf");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CommondataApi;

public class CommondataApiExample {

    public static void main(String[] args) {
        CommondataApi apiInstance = new CommondataApi();
        String catgry = catgry_example; // String | CONF_CATGRY
        String key = key_example; // String | CONF_KEY
        try {
            apiInstance.getConf(catgry, key);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommondataApi#getConf");
            e.printStackTrace();
        }
    }
}

String *catgry = catgry_example; // CONF_CATGRY
String *key = key_example; // CONF_KEY

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

// Retrieve a specific CONF's data
[apiInstance getConfWith:catgry
    key:key
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GenianNacRestApiFor3rdParty = require('genian_nac_rest_api_for_3rd_party');

var api = new GenianNacRestApiFor3rdParty.CommondataApi()

var catgry = catgry_example; // {String} CONF_CATGRY

var key = key_example; // {String} CONF_KEY


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.getConf(catgry, key, callback);

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

namespace Example
{
    public class getConfExample
    {
        public void main()
        {
            
            var apiInstance = new CommondataApi();
            var catgry = catgry_example;  // String | CONF_CATGRY
            var key = key_example;  // String | CONF_KEY

            try
            {
                // Retrieve a specific CONF's data
                apiInstance.getConf(catgry, key);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CommondataApi.getConf: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\CommondataApi();
$catgry = catgry_example; // String | CONF_CATGRY
$key = key_example; // String | CONF_KEY

try {
    $api_instance->getConf($catgry, $key);
} catch (Exception $e) {
    echo 'Exception when calling CommondataApi->getConf: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::CommondataApi->new();
my $catgry = catgry_example; # String | CONF_CATGRY
my $key = key_example; # String | CONF_KEY

eval { 
    $api_instance->getConf(catgry => $catgry, key => $key);
};
if ($@) {
    warn "Exception when calling CommondataApi->getConf: $@\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.CommondataApi()
catgry = catgry_example # String | CONF_CATGRY
key = key_example # String | CONF_KEY

try: 
    # Retrieve a specific CONF's data
    api_instance.get_conf(catgry, key)
except ApiException as e:
    print("Exception when calling CommondataApi->getConf: %s\n" % e)

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

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

public class CommondataApiExample {

    public static void main(String[] args) {
        
        CommondataApi apiInstance = new CommondataApi();
        String item = item_example; // String | CONFUI_ITEM
        String value = value_example; // String | CONFUI_VALUE
        try {
            apiInstance.getConfUi(item, value);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommondataApi#getConfUi");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CommondataApi;

public class CommondataApiExample {

    public static void main(String[] args) {
        CommondataApi apiInstance = new CommondataApi();
        String item = item_example; // String | CONFUI_ITEM
        String value = value_example; // String | CONFUI_VALUE
        try {
            apiInstance.getConfUi(item, value);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommondataApi#getConfUi");
            e.printStackTrace();
        }
    }
}

String *item = item_example; // CONFUI_ITEM
String *value = value_example; // CONFUI_VALUE

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

// Retrieve a specific CONFUI's data
[apiInstance getConfUiWith:item
    value:value
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GenianNacRestApiFor3rdParty = require('genian_nac_rest_api_for_3rd_party');

var api = new GenianNacRestApiFor3rdParty.CommondataApi()

var item = item_example; // {String} CONFUI_ITEM

var value = value_example; // {String} CONFUI_VALUE


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.getConfUi(item, value, callback);

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

namespace Example
{
    public class getConfUiExample
    {
        public void main()
        {
            
            var apiInstance = new CommondataApi();
            var item = item_example;  // String | CONFUI_ITEM
            var value = value_example;  // String | CONFUI_VALUE

            try
            {
                // Retrieve a specific CONFUI's data
                apiInstance.getConfUi(item, value);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CommondataApi.getConfUi: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\CommondataApi();
$item = item_example; // String | CONFUI_ITEM
$value = value_example; // String | CONFUI_VALUE

try {
    $api_instance->getConfUi($item, $value);
} catch (Exception $e) {
    echo 'Exception when calling CommondataApi->getConfUi: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::CommondataApi->new();
my $item = item_example; # String | CONFUI_ITEM
my $value = value_example; # String | CONFUI_VALUE

eval { 
    $api_instance->getConfUi(item => $item, value => $value);
};
if ($@) {
    warn "Exception when calling CommondataApi->getConfUi: $@\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.CommondataApi()
item = item_example # String | CONFUI_ITEM
value = value_example # String | CONFUI_VALUE

try: 
    # Retrieve a specific CONFUI's data
    api_instance.get_conf_ui(item, value)
except ApiException as e:
    print("Exception when calling CommondataApi->getConfUi: %s\n" % e)

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

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

public class CommondataApiExample {

    public static void main(String[] args) {
        
        CommondataApi apiInstance = new CommondataApi();
        String item = item_example; // String | CONFUI_ITEM
        try {
            apiInstance.getConfUis(item);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommondataApi#getConfUis");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CommondataApi;

public class CommondataApiExample {

    public static void main(String[] args) {
        CommondataApi apiInstance = new CommondataApi();
        String item = item_example; // String | CONFUI_ITEM
        try {
            apiInstance.getConfUis(item);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommondataApi#getConfUis");
            e.printStackTrace();
        }
    }
}

String *item = item_example; // CONFUI_ITEM

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

// Retrieve a specific CONFUI's data
[apiInstance getConfUisWith:item
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GenianNacRestApiFor3rdParty = require('genian_nac_rest_api_for_3rd_party');

var api = new GenianNacRestApiFor3rdParty.CommondataApi()

var item = item_example; // {String} CONFUI_ITEM


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.getConfUis(item, callback);

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

namespace Example
{
    public class getConfUisExample
    {
        public void main()
        {
            
            var apiInstance = new CommondataApi();
            var item = item_example;  // String | CONFUI_ITEM

            try
            {
                // Retrieve a specific CONFUI's data
                apiInstance.getConfUis(item);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CommondataApi.getConfUis: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\CommondataApi();
$item = item_example; // String | CONFUI_ITEM

try {
    $api_instance->getConfUis($item);
} catch (Exception $e) {
    echo 'Exception when calling CommondataApi->getConfUis: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::CommondataApi->new();
my $item = item_example; # String | CONFUI_ITEM

eval { 
    $api_instance->getConfUis(item => $item);
};
if ($@) {
    warn "Exception when calling CommondataApi->getConfUis: $@\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.CommondataApi()
item = item_example # String | CONFUI_ITEM

try: 
    # Retrieve a specific CONFUI's data
    api_instance.get_conf_uis(item)
except ApiException as e:
    print("Exception when calling CommondataApi->getConfUis: %s\n" % e)

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

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

public class CommondataApiExample {

    public static void main(String[] args) {
        
        CommondataApi apiInstance = new CommondataApi();
        String catgry = catgry_example; // String | CONF_CATGRY
        try {
            apiInstance.getConfs(catgry);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommondataApi#getConfs");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CommondataApi;

public class CommondataApiExample {

    public static void main(String[] args) {
        CommondataApi apiInstance = new CommondataApi();
        String catgry = catgry_example; // String | CONF_CATGRY
        try {
            apiInstance.getConfs(catgry);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommondataApi#getConfs");
            e.printStackTrace();
        }
    }
}

String *catgry = catgry_example; // CONF_CATGRY

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

// Retrieve the data of the CONF
[apiInstance getConfsWith:catgry
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GenianNacRestApiFor3rdParty = require('genian_nac_rest_api_for_3rd_party');

var api = new GenianNacRestApiFor3rdParty.CommondataApi()

var catgry = catgry_example; // {String} CONF_CATGRY


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.getConfs(catgry, callback);

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

namespace Example
{
    public class getConfsExample
    {
        public void main()
        {
            
            var apiInstance = new CommondataApi();
            var catgry = catgry_example;  // String | CONF_CATGRY

            try
            {
                // Retrieve the data of the CONF
                apiInstance.getConfs(catgry);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CommondataApi.getConfs: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\CommondataApi();
$catgry = catgry_example; // String | CONF_CATGRY

try {
    $api_instance->getConfs($catgry);
} catch (Exception $e) {
    echo 'Exception when calling CommondataApi->getConfs: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::CommondataApi->new();
my $catgry = catgry_example; # String | CONF_CATGRY

eval { 
    $api_instance->getConfs(catgry => $catgry);
};
if ($@) {
    warn "Exception when calling CommondataApi->getConfs: $@\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.CommondataApi()
catgry = catgry_example # String | CONF_CATGRY

try: 
    # Retrieve the data of the CONF
    api_instance.get_confs(catgry)
except ApiException as e:
    print("Exception when calling CommondataApi->getConfs: %s\n" % e)

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

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

public class CommondataApiExample {

    public static void main(String[] args) {
        
        CommondataApi apiInstance = new CommondataApi();
        String customkey = customkey_example; // String | CustomKey
        String customvalue = customvalue_example; // String | CustomValue
        try {
            apiInstance.getCustomData(customkey, customvalue);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommondataApi#getCustomData");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CommondataApi;

public class CommondataApiExample {

    public static void main(String[] args) {
        CommondataApi apiInstance = new CommondataApi();
        String customkey = customkey_example; // String | CustomKey
        String customvalue = customvalue_example; // String | CustomValue
        try {
            apiInstance.getCustomData(customkey, customvalue);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommondataApi#getCustomData");
            e.printStackTrace();
        }
    }
}

String *customkey = customkey_example; // CustomKey
String *customvalue = customvalue_example; // CustomValue

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

// Retrieve a specific CustomData
[apiInstance getCustomDataWith:customkey
    customvalue:customvalue
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GenianNacRestApiFor3rdParty = require('genian_nac_rest_api_for_3rd_party');

var api = new GenianNacRestApiFor3rdParty.CommondataApi()

var customkey = customkey_example; // {String} CustomKey

var customvalue = customvalue_example; // {String} CustomValue


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.getCustomData(customkey, customvalue, callback);

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

namespace Example
{
    public class getCustomDataExample
    {
        public void main()
        {
            
            var apiInstance = new CommondataApi();
            var customkey = customkey_example;  // String | CustomKey
            var customvalue = customvalue_example;  // String | CustomValue

            try
            {
                // Retrieve a specific CustomData
                apiInstance.getCustomData(customkey, customvalue);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CommondataApi.getCustomData: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\CommondataApi();
$customkey = customkey_example; // String | CustomKey
$customvalue = customvalue_example; // String | CustomValue

try {
    $api_instance->getCustomData($customkey, $customvalue);
} catch (Exception $e) {
    echo 'Exception when calling CommondataApi->getCustomData: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::CommondataApi->new();
my $customkey = customkey_example; # String | CustomKey
my $customvalue = customvalue_example; # String | CustomValue

eval { 
    $api_instance->getCustomData(customkey => $customkey, customvalue => $customvalue);
};
if ($@) {
    warn "Exception when calling CommondataApi->getCustomData: $@\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.CommondataApi()
customkey = customkey_example # String | CustomKey
customvalue = customvalue_example # String | CustomValue

try: 
    # Retrieve a specific CustomData
    api_instance.get_custom_data(customkey, customvalue)
except ApiException as e:
    print("Exception when calling CommondataApi->getCustomData: %s\n" % e)

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

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

public class CommondataApiExample {

    public static void main(String[] args) {
        
        CommondataApi apiInstance = new CommondataApi();
        String customkey = customkey_example; // String | CustomKey
        try {
            apiInstance.getCustomDatas(customkey);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommondataApi#getCustomDatas");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CommondataApi;

public class CommondataApiExample {

    public static void main(String[] args) {
        CommondataApi apiInstance = new CommondataApi();
        String customkey = customkey_example; // String | CustomKey
        try {
            apiInstance.getCustomDatas(customkey);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommondataApi#getCustomDatas");
            e.printStackTrace();
        }
    }
}

String *customkey = customkey_example; // CustomKey

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

// Retrieve a specific CustomData List
[apiInstance getCustomDatasWith:customkey
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GenianNacRestApiFor3rdParty = require('genian_nac_rest_api_for_3rd_party');

var api = new GenianNacRestApiFor3rdParty.CommondataApi()

var customkey = customkey_example; // {String} CustomKey


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.getCustomDatas(customkey, callback);

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

namespace Example
{
    public class getCustomDatasExample
    {
        public void main()
        {
            
            var apiInstance = new CommondataApi();
            var customkey = customkey_example;  // String | CustomKey

            try
            {
                // Retrieve a specific CustomData List
                apiInstance.getCustomDatas(customkey);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CommondataApi.getCustomDatas: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\CommondataApi();
$customkey = customkey_example; // String | CustomKey

try {
    $api_instance->getCustomDatas($customkey);
} catch (Exception $e) {
    echo 'Exception when calling CommondataApi->getCustomDatas: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::CommondataApi->new();
my $customkey = customkey_example; # String | CustomKey

eval { 
    $api_instance->getCustomDatas(customkey => $customkey);
};
if ($@) {
    warn "Exception when calling CommondataApi->getCustomDatas: $@\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.CommondataApi()
customkey = customkey_example # String | CustomKey

try: 
    # Retrieve a specific CustomData List
    api_instance.get_custom_datas(customkey)
except ApiException as e:
    print("Exception when calling CommondataApi->getCustomDatas: %s\n" % e)

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

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

public class CommondataApiExample {

    public static void main(String[] args) {
        
        CommondataApi apiInstance = new CommondataApi();
        String locale = locale_example; // String | LanguageCode
        try {
            map['String', Object] result = apiInstance.getResourceBundle(locale);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommondataApi#getResourceBundle");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CommondataApi;

public class CommondataApiExample {

    public static void main(String[] args) {
        CommondataApi apiInstance = new CommondataApi();
        String locale = locale_example; // String | LanguageCode
        try {
            map['String', Object] result = apiInstance.getResourceBundle(locale);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommondataApi#getResourceBundle");
            e.printStackTrace();
        }
    }
}

String *locale = locale_example; // LanguageCode (optional)

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

// List ResourceBundle Messages
[apiInstance getResourceBundleWith:locale
              completionHandler: ^(map['String', Object] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GenianNacRestApiFor3rdParty = require('genian_nac_rest_api_for_3rd_party');

var api = new GenianNacRestApiFor3rdParty.CommondataApi()

var opts = { 
  'locale': locale_example // {String} LanguageCode
};

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

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

namespace Example
{
    public class getResourceBundleExample
    {
        public void main()
        {
            
            var apiInstance = new CommondataApi();
            var locale = locale_example;  // String | LanguageCode (optional) 

            try
            {
                // List ResourceBundle Messages
                map['String', Object] result = apiInstance.getResourceBundle(locale);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CommondataApi.getResourceBundle: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\CommondataApi();
$locale = locale_example; // String | LanguageCode

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

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

my $api_instance = WWW::SwaggerClient::CommondataApi->new();
my $locale = locale_example; # String | LanguageCode

eval { 
    my $result = $api_instance->getResourceBundle(locale => $locale);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CommondataApi->getResourceBundle: $@\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.CommondataApi()
locale = locale_example # String | LanguageCode (optional)

try: 
    # List ResourceBundle Messages
    api_response = api_instance.get_resource_bundle(locale=locale)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommondataApi->getResourceBundle: %s\n" % e)

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

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

public class CommondataApiExample {

    public static void main(String[] args) {
        
        CommondataApi apiInstance = new CommondataApi();
        String bundle = bundle_example; // String | Bundle
        String locale = locale_example; // String | LanguageCode
        try {
            map['String', Object] result = apiInstance.getResourceBundleByBundle(bundle, locale);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommondataApi#getResourceBundleByBundle");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CommondataApi;

public class CommondataApiExample {

    public static void main(String[] args) {
        CommondataApi apiInstance = new CommondataApi();
        String bundle = bundle_example; // String | Bundle
        String locale = locale_example; // String | LanguageCode
        try {
            map['String', Object] result = apiInstance.getResourceBundleByBundle(bundle, locale);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommondataApi#getResourceBundleByBundle");
            e.printStackTrace();
        }
    }
}

String *bundle = bundle_example; // Bundle
String *locale = locale_example; // LanguageCode (optional)

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

// Retrieve a specific ResourceBundle's Message(s)
[apiInstance getResourceBundleByBundleWith:bundle
    locale:locale
              completionHandler: ^(map['String', Object] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GenianNacRestApiFor3rdParty = require('genian_nac_rest_api_for_3rd_party');

var api = new GenianNacRestApiFor3rdParty.CommondataApi()

var bundle = bundle_example; // {String} Bundle

var opts = { 
  'locale': locale_example // {String} LanguageCode
};

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

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

namespace Example
{
    public class getResourceBundleByBundleExample
    {
        public void main()
        {
            
            var apiInstance = new CommondataApi();
            var bundle = bundle_example;  // String | Bundle
            var locale = locale_example;  // String | LanguageCode (optional) 

            try
            {
                // Retrieve a specific ResourceBundle's Message(s)
                map['String', Object] result = apiInstance.getResourceBundleByBundle(bundle, locale);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CommondataApi.getResourceBundleByBundle: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\CommondataApi();
$bundle = bundle_example; // String | Bundle
$locale = locale_example; // String | LanguageCode

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

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

my $api_instance = WWW::SwaggerClient::CommondataApi->new();
my $bundle = bundle_example; # String | Bundle
my $locale = locale_example; # String | LanguageCode

eval { 
    my $result = $api_instance->getResourceBundleByBundle(bundle => $bundle, locale => $locale);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CommondataApi->getResourceBundleByBundle: $@\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.CommondataApi()
bundle = bundle_example # String | Bundle
locale = locale_example # String | LanguageCode (optional)

try: 
    # Retrieve a specific ResourceBundle's Message(s)
    api_response = api_instance.get_resource_bundle_by_bundle(bundle, locale=locale)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommondataApi->getResourceBundleByBundle: %s\n" % e)

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

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

public class CommondataApiExample {

    public static void main(String[] args) {
        
        CommondataApi apiInstance = new CommondataApi();
        String messageId = messageId_example; // String | MessageID with the LIKE operator
        String bundle = bundle_example; // String | Bundle
        String locale = locale_example; // String | LanguageCode
        try {
            map['String', Object] result = apiInstance.getResourceBundleByMessageId(messageId, bundle, locale);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommondataApi#getResourceBundleByMessageId");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CommondataApi;

public class CommondataApiExample {

    public static void main(String[] args) {
        CommondataApi apiInstance = new CommondataApi();
        String messageId = messageId_example; // String | MessageID with the LIKE operator
        String bundle = bundle_example; // String | Bundle
        String locale = locale_example; // String | LanguageCode
        try {
            map['String', Object] result = apiInstance.getResourceBundleByMessageId(messageId, bundle, locale);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommondataApi#getResourceBundleByMessageId");
            e.printStackTrace();
        }
    }
}

String *messageId = messageId_example; // MessageID with the LIKE operator
String *bundle = bundle_example; // Bundle
String *locale = locale_example; // LanguageCode (optional)

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

// Retrieve a specific ResourceBundle's Message
[apiInstance getResourceBundleByMessageIdWith:messageId
    bundle:bundle
    locale:locale
              completionHandler: ^(map['String', Object] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GenianNacRestApiFor3rdParty = require('genian_nac_rest_api_for_3rd_party');

var api = new GenianNacRestApiFor3rdParty.CommondataApi()

var messageId = messageId_example; // {String} MessageID with the LIKE operator

var bundle = bundle_example; // {String} Bundle

var opts = { 
  'locale': locale_example // {String} LanguageCode
};

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

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

namespace Example
{
    public class getResourceBundleByMessageIdExample
    {
        public void main()
        {
            
            var apiInstance = new CommondataApi();
            var messageId = messageId_example;  // String | MessageID with the LIKE operator
            var bundle = bundle_example;  // String | Bundle
            var locale = locale_example;  // String | LanguageCode (optional) 

            try
            {
                // Retrieve a specific ResourceBundle's Message
                map['String', Object] result = apiInstance.getResourceBundleByMessageId(messageId, bundle, locale);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CommondataApi.getResourceBundleByMessageId: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\CommondataApi();
$messageId = messageId_example; // String | MessageID with the LIKE operator
$bundle = bundle_example; // String | Bundle
$locale = locale_example; // String | LanguageCode

try {
    $result = $api_instance->getResourceBundleByMessageId($messageId, $bundle, $locale);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CommondataApi->getResourceBundleByMessageId: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::CommondataApi->new();
my $messageId = messageId_example; # String | MessageID with the LIKE operator
my $bundle = bundle_example; # String | Bundle
my $locale = locale_example; # String | LanguageCode

eval { 
    my $result = $api_instance->getResourceBundleByMessageId(messageId => $messageId, bundle => $bundle, locale => $locale);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CommondataApi->getResourceBundleByMessageId: $@\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.CommondataApi()
messageId = messageId_example # String | MessageID with the LIKE operator
bundle = bundle_example # String | Bundle
locale = locale_example # String | LanguageCode (optional)

try: 
    # Retrieve a specific ResourceBundle's Message
    api_response = api_instance.get_resource_bundle_by_message_id(messageId, bundle, locale=locale)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommondataApi->getResourceBundleByMessageId: %s\n" % e)

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

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

public class CommondataApiExample {

    public static void main(String[] args) {
        
        CommondataApi apiInstance = new CommondataApi();
        String type = type_example; // String | System
        try {
            apiInstance.getVersion(type);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommondataApi#getVersion");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.CommondataApi;

public class CommondataApiExample {

    public static void main(String[] args) {
        CommondataApi apiInstance = new CommondataApi();
        String type = type_example; // String | System
        try {
            apiInstance.getVersion(type);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommondataApi#getVersion");
            e.printStackTrace();
        }
    }
}

String *type = type_example; // System

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

// Retrieve a specific system's version information
[apiInstance getVersionWith:type
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GenianNacRestApiFor3rdParty = require('genian_nac_rest_api_for_3rd_party');

var api = new GenianNacRestApiFor3rdParty.CommondataApi()

var type = type_example; // {String} System


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.getVersion(type, callback);

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

namespace Example
{
    public class getVersionExample
    {
        public void main()
        {
            
            var apiInstance = new CommondataApi();
            var type = type_example;  // String | System

            try
            {
                // Retrieve a specific system's version information
                apiInstance.getVersion(type);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling CommondataApi.getVersion: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\CommondataApi();
$type = type_example; // String | System

try {
    $api_instance->getVersion($type);
} catch (Exception $e) {
    echo 'Exception when calling CommondataApi->getVersion: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::CommondataApi->new();
my $type = type_example; # String | System

eval { 
    $api_instance->getVersion(type => $type);
};
if ($@) {
    warn "Exception when calling CommondataApi->getVersion: $@\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.CommondataApi()
type = type_example # String | System

try: 
    # Retrieve a specific system's version information
    api_instance.get_version(type)
except ApiException as e:
    print("Exception when calling CommondataApi->getVersion: %s\n" % e)

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

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

public class InformationApiExample {

    public static void main(String[] args) {
        
        InformationApi apiInstance = new InformationApi();
        String type = type_example; // String | System
        try {
            apiInstance.getVersion(type);
        } catch (ApiException e) {
            System.err.println("Exception when calling InformationApi#getVersion");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.InformationApi;

public class InformationApiExample {

    public static void main(String[] args) {
        InformationApi apiInstance = new InformationApi();
        String type = type_example; // String | System
        try {
            apiInstance.getVersion(type);
        } catch (ApiException e) {
            System.err.println("Exception when calling InformationApi#getVersion");
            e.printStackTrace();
        }
    }
}

String *type = type_example; // System

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

// Retrieve a specific system's version information
[apiInstance getVersionWith:type
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GenianNacRestApiFor3rdParty = require('genian_nac_rest_api_for_3rd_party');

var api = new GenianNacRestApiFor3rdParty.InformationApi()

var type = type_example; // {String} System


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.getVersion(type, callback);

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

namespace Example
{
    public class getVersionExample
    {
        public void main()
        {
            
            var apiInstance = new InformationApi();
            var type = type_example;  // String | System

            try
            {
                // Retrieve a specific system's version information
                apiInstance.getVersion(type);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling InformationApi.getVersion: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\InformationApi();
$type = type_example; // String | System

try {
    $api_instance->getVersion($type);
} catch (Exception $e) {
    echo 'Exception when calling InformationApi->getVersion: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::InformationApi->new();
my $type = type_example; # String | System

eval { 
    $api_instance->getVersion(type => $type);
};
if ($@) {
    warn "Exception when calling InformationApi->getVersion: $@\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.InformationApi()
type = type_example # String | System

try: 
    # Retrieve a specific system's version information
    api_instance.get_version(type)
except ApiException as e:
    print("Exception when calling InformationApi->getVersion: %s\n" % e)