iKnow REST APIs

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

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

public class BlacklistsApiExample {

    public static void main(String[] args) {

        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String name = name_example; // String | name of the new blacklist
        try {
            BlacklistDetails result = apiInstance./domain/{domain}/blacklists/new/{name}GET(domain, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/new/{name}GET");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BlacklistsApi;

public class BlacklistsApiExample {

    public static void main(String[] args) {
        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String name = name_example; // String | name of the new blacklist
        try {
            BlacklistDetails result = apiInstance./domain/{domain}/blacklists/new/{name}GET(domain, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/new/{name}GET");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
String *name = name_example; // name of the new blacklist

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

// Creates a new blacklist

[apiInstance /domain/{domain}/blacklists/new/{name}GETWith:domain
    name:name
              completionHandler: ^(BlacklistDetails output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.BlacklistsApi()

var domain = 56; // {Integer} the ID of the domain to query

var name = name_example; // {String} name of the new blacklist


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api./domain/{domain}/blacklists/new/{name}GET(domainname, callback);

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

namespace Example
{
    public class /domain/{domain}/blacklists/new/{name}GETExample
    {
        public void main()
        {

            var apiInstance = new BlacklistsApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var name = name_example;  // String | name of the new blacklist

            try
            {
                // Creates a new blacklist

                BlacklistDetails result = apiInstance./domain/{domain}/blacklists/new/{name}GET(domain, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlacklistsApi./domain/{domain}/blacklists/new/{name}GET: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\BlacklistsApi();
$domain = 56; // Integer | the ID of the domain to query
$name = name_example; // String | name of the new blacklist

try {
    $result = $api_instance->/domain/{domain}/blacklists/new/{name}GET($domain, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlacklistsApi->/domain/{domain}/blacklists/new/{name}GET: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::BlacklistsApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $name = name_example; # String | name of the new blacklist

eval {
    my $result = $api_instance->/domain/{domain}/blacklists/new/{name}GET(domain => $domain, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlacklistsApi->/domain/{domain}/blacklists/new/{name}GET: $@\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.BlacklistsApi()
domain = 56 # Integer | the ID of the domain to query
name = name_example # String | name of the new blacklist

try:
    # Creates a new blacklist

    api_response = api_instance./domain/{domain}/blacklists/new/{name}get(domain, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlacklistsApi->/domain/{domain}/blacklists/new/{name}GET: %s\n" % e)

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

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

public class BlacklistsApiExample {

    public static void main(String[] args) {

        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String name = name_example; // String | name of the new blacklist
        RequestBody_26 requestBody = ; // RequestBody_26 | JSON object with a list of query-specific arguments
        try {
            BlacklistDetails result = apiInstance./domain/{domain}/blacklists/new/{name}POST(domain, name, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/new/{name}POST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BlacklistsApi;

public class BlacklistsApiExample {

    public static void main(String[] args) {
        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String name = name_example; // String | name of the new blacklist
        RequestBody_26 requestBody = ; // RequestBody_26 | JSON object with a list of query-specific arguments
        try {
            BlacklistDetails result = apiInstance./domain/{domain}/blacklists/new/{name}POST(domain, name, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/new/{name}POST");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
String *name = name_example; // name of the new blacklist
RequestBody_26 *requestBody = ; // JSON object with a list of query-specific arguments (optional)

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

// Creates a new blacklist

[apiInstance /domain/{domain}/blacklists/new/{name}POSTWith:domain
    name:name
    requestBody:requestBody
              completionHandler: ^(BlacklistDetails output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.BlacklistsApi()

var domain = 56; // {Integer} the ID of the domain to query

var name = name_example; // {String} name of the new blacklist

var opts = {
  'requestBody':  // {RequestBody_26} JSON object with a list of query-specific arguments
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api./domain/{domain}/blacklists/new/{name}POST(domainname, opts, callback);

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

namespace Example
{
    public class /domain/{domain}/blacklists/new/{name}POSTExample
    {
        public void main()
        {

            var apiInstance = new BlacklistsApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var name = name_example;  // String | name of the new blacklist
            var requestBody = new RequestBody_26(); // RequestBody_26 | JSON object with a list of query-specific arguments (optional)

            try
            {
                // Creates a new blacklist

                BlacklistDetails result = apiInstance./domain/{domain}/blacklists/new/{name}POST(domain, name, requestBody);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlacklistsApi./domain/{domain}/blacklists/new/{name}POST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\BlacklistsApi();
$domain = 56; // Integer | the ID of the domain to query
$name = name_example; // String | name of the new blacklist
$requestBody = ; // RequestBody_26 | JSON object with a list of query-specific arguments

try {
    $result = $api_instance->/domain/{domain}/blacklists/new/{name}POST($domain, $name, $requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlacklistsApi->/domain/{domain}/blacklists/new/{name}POST: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::BlacklistsApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $name = name_example; # String | name of the new blacklist
my $requestBody = WWW::SwaggerClient::Object::RequestBody_26->new(); # RequestBody_26 | JSON object with a list of query-specific arguments

eval {
    my $result = $api_instance->/domain/{domain}/blacklists/new/{name}POST(domain => $domain, name => $name, requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlacklistsApi->/domain/{domain}/blacklists/new/{name}POST: $@\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.BlacklistsApi()
domain = 56 # Integer | the ID of the domain to query
name = name_example # String | name of the new blacklist
requestBody =  # RequestBody_26 | JSON object with a list of query-specific arguments (optional)

try:
    # Creates a new blacklist

    api_response = api_instance./domain/{domain}/blacklists/new/{name}post(domain, name, requestBody=requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlacklistsApi->/domain/{domain}/blacklists/new/{name}POST: %s\n" % e)

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

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

public class BlacklistsApiExample {

    public static void main(String[] args) {

        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        RequestBody_27 requestBody = ; // RequestBody_27 | JSON object with a list of query-specific arguments
        try {
            BlacklistDetails result = apiInstance./domain/{domain}/blacklists/newPOST(domain, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/newPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BlacklistsApi;

public class BlacklistsApiExample {

    public static void main(String[] args) {
        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        RequestBody_27 requestBody = ; // RequestBody_27 | JSON object with a list of query-specific arguments
        try {
            BlacklistDetails result = apiInstance./domain/{domain}/blacklists/newPOST(domain, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/newPOST");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
RequestBody_27 *requestBody = ; // JSON object with a list of query-specific arguments

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

// Creates a new blacklist

[apiInstance /domain/{domain}/blacklists/newPOSTWith:domain
    requestBody:requestBody
              completionHandler: ^(BlacklistDetails output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.BlacklistsApi()

var domain = 56; // {Integer} the ID of the domain to query

var requestBody = ; // {RequestBody_27} JSON object with a list of query-specific arguments


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

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

namespace Example
{
    public class /domain/{domain}/blacklists/newPOSTExample
    {
        public void main()
        {

            var apiInstance = new BlacklistsApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var requestBody = new RequestBody_27(); // RequestBody_27 | JSON object with a list of query-specific arguments

            try
            {
                // Creates a new blacklist

                BlacklistDetails result = apiInstance./domain/{domain}/blacklists/newPOST(domain, requestBody);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlacklistsApi./domain/{domain}/blacklists/newPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\BlacklistsApi();
$domain = 56; // Integer | the ID of the domain to query
$requestBody = ; // RequestBody_27 | JSON object with a list of query-specific arguments

try {
    $result = $api_instance->/domain/{domain}/blacklists/newPOST($domain, $requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlacklistsApi->/domain/{domain}/blacklists/newPOST: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::BlacklistsApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $requestBody = WWW::SwaggerClient::Object::RequestBody_27->new(); # RequestBody_27 | JSON object with a list of query-specific arguments

eval {
    my $result = $api_instance->/domain/{domain}/blacklists/newPOST(domain => $domain, requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlacklistsApi->/domain/{domain}/blacklists/newPOST: $@\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.BlacklistsApi()
domain = 56 # Integer | the ID of the domain to query
requestBody =  # RequestBody_27 | JSON object with a list of query-specific arguments

try:
    # Creates a new blacklist

    api_response = api_instance./domain/{domain}/blacklists/new_post(domain, requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlacklistsApi->/domain/{domain}/blacklists/newPOST: %s\n" % e)

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

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

public class BlacklistsApiExample {

    public static void main(String[] args) {

        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String id = id_example; // String | ID of the blacklist to extend
        String string = string_example; // String | element to add to the blacklist
        try {
            inline_response_200_6 result = apiInstance./domain/{domain}/blacklists/{id}/add/{string}GET(domain, id, string);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/{id}/add/{string}GET");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BlacklistsApi;

public class BlacklistsApiExample {

    public static void main(String[] args) {
        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String id = id_example; // String | ID of the blacklist to extend
        String string = string_example; // String | element to add to the blacklist
        try {
            inline_response_200_6 result = apiInstance./domain/{domain}/blacklists/{id}/add/{string}GET(domain, id, string);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/{id}/add/{string}GET");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
String *id = id_example; // ID of the blacklist to extend
String *string = string_example; // element to add to the blacklist

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

// Adds new elements to a given blacklist

[apiInstance /domain/{domain}/blacklists/{id}/add/{string}GETWith:domain
    id:id
    string:string
              completionHandler: ^(inline_response_200_6 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.BlacklistsApi()

var domain = 56; // {Integer} the ID of the domain to query

var id = id_example; // {String} ID of the blacklist to extend

var string = string_example; // {String} element to add to the blacklist


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api./domain/{domain}/blacklists/{id}/add/{string}GET(domainid, string, callback);

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

namespace Example
{
    public class /domain/{domain}/blacklists/{id}/add/{string}GETExample
    {
        public void main()
        {

            var apiInstance = new BlacklistsApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var id = id_example;  // String | ID of the blacklist to extend
            var string = string_example;  // String | element to add to the blacklist

            try
            {
                // Adds new elements to a given blacklist

                inline_response_200_6 result = apiInstance./domain/{domain}/blacklists/{id}/add/{string}GET(domain, id, string);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlacklistsApi./domain/{domain}/blacklists/{id}/add/{string}GET: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\BlacklistsApi();
$domain = 56; // Integer | the ID of the domain to query
$id = id_example; // String | ID of the blacklist to extend
$string = string_example; // String | element to add to the blacklist

try {
    $result = $api_instance->/domain/{domain}/blacklists/{id}/add/{string}GET($domain, $id, $string);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/add/{string}GET: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::BlacklistsApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $id = id_example; # String | ID of the blacklist to extend
my $string = string_example; # String | element to add to the blacklist

eval {
    my $result = $api_instance->/domain/{domain}/blacklists/{id}/add/{string}GET(domain => $domain, id => $id, string => $string);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/add/{string}GET: $@\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.BlacklistsApi()
domain = 56 # Integer | the ID of the domain to query
id = id_example # String | ID of the blacklist to extend
string = string_example # String | element to add to the blacklist

try:
    # Adds new elements to a given blacklist

    api_response = api_instance./domain/{domain}/blacklists/{id}/add/{string}get(domain, id, string)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/add/{string}GET: %s\n" % e)

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

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

public class BlacklistsApiExample {

    public static void main(String[] args) {

        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String id = id_example; // String | ID of the blacklist to extend
        String string = string_example; // String | element to add to the blacklist
        RequestBody_28 requestBody = ; // RequestBody_28 | JSON object with a list of query-specific arguments
        try {
            inline_response_200_6 result = apiInstance./domain/{domain}/blacklists/{id}/add/{string}POST(domain, id, string, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/{id}/add/{string}POST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BlacklistsApi;

public class BlacklistsApiExample {

    public static void main(String[] args) {
        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String id = id_example; // String | ID of the blacklist to extend
        String string = string_example; // String | element to add to the blacklist
        RequestBody_28 requestBody = ; // RequestBody_28 | JSON object with a list of query-specific arguments
        try {
            inline_response_200_6 result = apiInstance./domain/{domain}/blacklists/{id}/add/{string}POST(domain, id, string, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/{id}/add/{string}POST");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
String *id = id_example; // ID of the blacklist to extend
String *string = string_example; // element to add to the blacklist
RequestBody_28 *requestBody = ; // JSON object with a list of query-specific arguments (optional)

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

// Adds new elements to a given blacklist

[apiInstance /domain/{domain}/blacklists/{id}/add/{string}POSTWith:domain
    id:id
    string:string
    requestBody:requestBody
              completionHandler: ^(inline_response_200_6 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.BlacklistsApi()

var domain = 56; // {Integer} the ID of the domain to query

var id = id_example; // {String} ID of the blacklist to extend

var string = string_example; // {String} element to add to the blacklist

var opts = {
  'requestBody':  // {RequestBody_28} JSON object with a list of query-specific arguments
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api./domain/{domain}/blacklists/{id}/add/{string}POST(domainid, string, opts, callback);

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

namespace Example
{
    public class /domain/{domain}/blacklists/{id}/add/{string}POSTExample
    {
        public void main()
        {

            var apiInstance = new BlacklistsApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var id = id_example;  // String | ID of the blacklist to extend
            var string = string_example;  // String | element to add to the blacklist
            var requestBody = new RequestBody_28(); // RequestBody_28 | JSON object with a list of query-specific arguments (optional)

            try
            {
                // Adds new elements to a given blacklist

                inline_response_200_6 result = apiInstance./domain/{domain}/blacklists/{id}/add/{string}POST(domain, id, string, requestBody);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlacklistsApi./domain/{domain}/blacklists/{id}/add/{string}POST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\BlacklistsApi();
$domain = 56; // Integer | the ID of the domain to query
$id = id_example; // String | ID of the blacklist to extend
$string = string_example; // String | element to add to the blacklist
$requestBody = ; // RequestBody_28 | JSON object with a list of query-specific arguments

try {
    $result = $api_instance->/domain/{domain}/blacklists/{id}/add/{string}POST($domain, $id, $string, $requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/add/{string}POST: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::BlacklistsApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $id = id_example; # String | ID of the blacklist to extend
my $string = string_example; # String | element to add to the blacklist
my $requestBody = WWW::SwaggerClient::Object::RequestBody_28->new(); # RequestBody_28 | JSON object with a list of query-specific arguments

eval {
    my $result = $api_instance->/domain/{domain}/blacklists/{id}/add/{string}POST(domain => $domain, id => $id, string => $string, requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/add/{string}POST: $@\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.BlacklistsApi()
domain = 56 # Integer | the ID of the domain to query
id = id_example # String | ID of the blacklist to extend
string = string_example # String | element to add to the blacklist
requestBody =  # RequestBody_28 | JSON object with a list of query-specific arguments (optional)

try:
    # Adds new elements to a given blacklist

    api_response = api_instance./domain/{domain}/blacklists/{id}/add/{string}post(domain, id, string, requestBody=requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/add/{string}POST: %s\n" % e)

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

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

public class BlacklistsApiExample {

    public static void main(String[] args) {

        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String id = id_example; // String | ID of the blacklist to extend
        RequestBody_29 requestBody = ; // RequestBody_29 | JSON object with a list of query-specific arguments
        try {
            inline_response_200_6 result = apiInstance./domain/{domain}/blacklists/{id}/addPOST(domain, id, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/{id}/addPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BlacklistsApi;

public class BlacklistsApiExample {

    public static void main(String[] args) {
        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String id = id_example; // String | ID of the blacklist to extend
        RequestBody_29 requestBody = ; // RequestBody_29 | JSON object with a list of query-specific arguments
        try {
            inline_response_200_6 result = apiInstance./domain/{domain}/blacklists/{id}/addPOST(domain, id, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/{id}/addPOST");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
String *id = id_example; // ID of the blacklist to extend
RequestBody_29 *requestBody = ; // JSON object with a list of query-specific arguments

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

// Adds new elements to a given blacklist

[apiInstance /domain/{domain}/blacklists/{id}/addPOSTWith:domain
    id:id
    requestBody:requestBody
              completionHandler: ^(inline_response_200_6 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.BlacklistsApi()

var domain = 56; // {Integer} the ID of the domain to query

var id = id_example; // {String} ID of the blacklist to extend

var requestBody = ; // {RequestBody_29} JSON object with a list of query-specific arguments


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api./domain/{domain}/blacklists/{id}/addPOST(domainid, requestBody, callback);

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

namespace Example
{
    public class /domain/{domain}/blacklists/{id}/addPOSTExample
    {
        public void main()
        {

            var apiInstance = new BlacklistsApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var id = id_example;  // String | ID of the blacklist to extend
            var requestBody = new RequestBody_29(); // RequestBody_29 | JSON object with a list of query-specific arguments

            try
            {
                // Adds new elements to a given blacklist

                inline_response_200_6 result = apiInstance./domain/{domain}/blacklists/{id}/addPOST(domain, id, requestBody);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlacklistsApi./domain/{domain}/blacklists/{id}/addPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\BlacklistsApi();
$domain = 56; // Integer | the ID of the domain to query
$id = id_example; // String | ID of the blacklist to extend
$requestBody = ; // RequestBody_29 | JSON object with a list of query-specific arguments

try {
    $result = $api_instance->/domain/{domain}/blacklists/{id}/addPOST($domain, $id, $requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/addPOST: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::BlacklistsApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $id = id_example; # String | ID of the blacklist to extend
my $requestBody = WWW::SwaggerClient::Object::RequestBody_29->new(); # RequestBody_29 | JSON object with a list of query-specific arguments

eval {
    my $result = $api_instance->/domain/{domain}/blacklists/{id}/addPOST(domain => $domain, id => $id, requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/addPOST: $@\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.BlacklistsApi()
domain = 56 # Integer | the ID of the domain to query
id = id_example # String | ID of the blacklist to extend
requestBody =  # RequestBody_29 | JSON object with a list of query-specific arguments

try:
    # Adds new elements to a given blacklist

    api_response = api_instance./domain/{domain}/blacklists/{id}/add_post(domain, id, requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/addPOST: %s\n" % e)

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

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

public class BlacklistsApiExample {

    public static void main(String[] args) {

        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String id = id_example; // String | ID of the blacklist to clear
        try {
            inline_response_200_5 result = apiInstance./domain/{domain}/blacklists/{id}/clearGET(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/{id}/clearGET");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BlacklistsApi;

public class BlacklistsApiExample {

    public static void main(String[] args) {
        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String id = id_example; // String | ID of the blacklist to clear
        try {
            inline_response_200_5 result = apiInstance./domain/{domain}/blacklists/{id}/clearGET(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/{id}/clearGET");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
String *id = id_example; // ID of the blacklist to clear

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

// Clears all entries for a given blacklist

[apiInstance /domain/{domain}/blacklists/{id}/clearGETWith:domain
    id:id
              completionHandler: ^(inline_response_200_5 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.BlacklistsApi()

var domain = 56; // {Integer} the ID of the domain to query

var id = id_example; // {String} ID of the blacklist to clear


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

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

namespace Example
{
    public class /domain/{domain}/blacklists/{id}/clearGETExample
    {
        public void main()
        {

            var apiInstance = new BlacklistsApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var id = id_example;  // String | ID of the blacklist to clear

            try
            {
                // Clears all entries for a given blacklist

                inline_response_200_5 result = apiInstance./domain/{domain}/blacklists/{id}/clearGET(domain, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlacklistsApi./domain/{domain}/blacklists/{id}/clearGET: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\BlacklistsApi();
$domain = 56; // Integer | the ID of the domain to query
$id = id_example; // String | ID of the blacklist to clear

try {
    $result = $api_instance->/domain/{domain}/blacklists/{id}/clearGET($domain, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/clearGET: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::BlacklistsApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $id = id_example; # String | ID of the blacklist to clear

eval {
    my $result = $api_instance->/domain/{domain}/blacklists/{id}/clearGET(domain => $domain, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/clearGET: $@\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.BlacklistsApi()
domain = 56 # Integer | the ID of the domain to query
id = id_example # String | ID of the blacklist to clear

try:
    # Clears all entries for a given blacklist

    api_response = api_instance./domain/{domain}/blacklists/{id}/clear_get(domain, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/clearGET: %s\n" % e)

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

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

public class BlacklistsApiExample {

    public static void main(String[] args) {

        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String id = id_example; // String | ID of the blacklist to clear
        try {
            inline_response_200_5 result = apiInstance./domain/{domain}/blacklists/{id}/clearPOST(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/{id}/clearPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BlacklistsApi;

public class BlacklistsApiExample {

    public static void main(String[] args) {
        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String id = id_example; // String | ID of the blacklist to clear
        try {
            inline_response_200_5 result = apiInstance./domain/{domain}/blacklists/{id}/clearPOST(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/{id}/clearPOST");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
String *id = id_example; // ID of the blacklist to clear

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

// Clears all entries for a given blacklist

[apiInstance /domain/{domain}/blacklists/{id}/clearPOSTWith:domain
    id:id
              completionHandler: ^(inline_response_200_5 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.BlacklistsApi()

var domain = 56; // {Integer} the ID of the domain to query

var id = id_example; // {String} ID of the blacklist to clear


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

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

namespace Example
{
    public class /domain/{domain}/blacklists/{id}/clearPOSTExample
    {
        public void main()
        {

            var apiInstance = new BlacklistsApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var id = id_example;  // String | ID of the blacklist to clear

            try
            {
                // Clears all entries for a given blacklist

                inline_response_200_5 result = apiInstance./domain/{domain}/blacklists/{id}/clearPOST(domain, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlacklistsApi./domain/{domain}/blacklists/{id}/clearPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\BlacklistsApi();
$domain = 56; // Integer | the ID of the domain to query
$id = id_example; // String | ID of the blacklist to clear

try {
    $result = $api_instance->/domain/{domain}/blacklists/{id}/clearPOST($domain, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/clearPOST: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::BlacklistsApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $id = id_example; # String | ID of the blacklist to clear

eval {
    my $result = $api_instance->/domain/{domain}/blacklists/{id}/clearPOST(domain => $domain, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/clearPOST: $@\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.BlacklistsApi()
domain = 56 # Integer | the ID of the domain to query
id = id_example # String | ID of the blacklist to clear

try:
    # Clears all entries for a given blacklist

    api_response = api_instance./domain/{domain}/blacklists/{id}/clear_post(domain, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/clearPOST: %s\n" % e)

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

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

public class BlacklistsApiExample {

    public static void main(String[] args) {

        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        Integer id = 56; // Integer | ID of the blacklist being queried
        try {
            BlacklistDetails result = apiInstance./domain/{domain}/blacklists/{id}/detailsGET(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/{id}/detailsGET");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BlacklistsApi;

public class BlacklistsApiExample {

    public static void main(String[] args) {
        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        Integer id = 56; // Integer | ID of the blacklist being queried
        try {
            BlacklistDetails result = apiInstance./domain/{domain}/blacklists/{id}/detailsGET(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/{id}/detailsGET");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
Integer *id = 56; // ID of the blacklist being queried

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

// Retrieves a particular blacklist's contents

[apiInstance /domain/{domain}/blacklists/{id}/detailsGETWith:domain
    id:id
              completionHandler: ^(BlacklistDetails output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.BlacklistsApi()

var domain = 56; // {Integer} the ID of the domain to query

var id = 56; // {Integer} ID of the blacklist being queried


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

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

namespace Example
{
    public class /domain/{domain}/blacklists/{id}/detailsGETExample
    {
        public void main()
        {

            var apiInstance = new BlacklistsApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var id = 56;  // Integer | ID of the blacklist being queried

            try
            {
                // Retrieves a particular blacklist's contents

                BlacklistDetails result = apiInstance./domain/{domain}/blacklists/{id}/detailsGET(domain, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlacklistsApi./domain/{domain}/blacklists/{id}/detailsGET: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\BlacklistsApi();
$domain = 56; // Integer | the ID of the domain to query
$id = 56; // Integer | ID of the blacklist being queried

try {
    $result = $api_instance->/domain/{domain}/blacklists/{id}/detailsGET($domain, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/detailsGET: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::BlacklistsApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $id = 56; # Integer | ID of the blacklist being queried

eval {
    my $result = $api_instance->/domain/{domain}/blacklists/{id}/detailsGET(domain => $domain, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/detailsGET: $@\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.BlacklistsApi()
domain = 56 # Integer | the ID of the domain to query
id = 56 # Integer | ID of the blacklist being queried

try:
    # Retrieves a particular blacklist's contents

    api_response = api_instance./domain/{domain}/blacklists/{id}/details_get(domain, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/detailsGET: %s\n" % e)

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

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

public class BlacklistsApiExample {

    public static void main(String[] args) {

        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        Integer id = 56; // Integer | ID of the blacklist being queried
        try {
            BlacklistDetails result = apiInstance./domain/{domain}/blacklists/{id}/detailsPOST(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/{id}/detailsPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BlacklistsApi;

public class BlacklistsApiExample {

    public static void main(String[] args) {
        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        Integer id = 56; // Integer | ID of the blacklist being queried
        try {
            BlacklistDetails result = apiInstance./domain/{domain}/blacklists/{id}/detailsPOST(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/{id}/detailsPOST");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
Integer *id = 56; // ID of the blacklist being queried

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

// Retrieves a particular blacklist's contents

[apiInstance /domain/{domain}/blacklists/{id}/detailsPOSTWith:domain
    id:id
              completionHandler: ^(BlacklistDetails output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.BlacklistsApi()

var domain = 56; // {Integer} the ID of the domain to query

var id = 56; // {Integer} ID of the blacklist being queried


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

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

namespace Example
{
    public class /domain/{domain}/blacklists/{id}/detailsPOSTExample
    {
        public void main()
        {

            var apiInstance = new BlacklistsApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var id = 56;  // Integer | ID of the blacklist being queried

            try
            {
                // Retrieves a particular blacklist's contents

                BlacklistDetails result = apiInstance./domain/{domain}/blacklists/{id}/detailsPOST(domain, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlacklistsApi./domain/{domain}/blacklists/{id}/detailsPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\BlacklistsApi();
$domain = 56; // Integer | the ID of the domain to query
$id = 56; // Integer | ID of the blacklist being queried

try {
    $result = $api_instance->/domain/{domain}/blacklists/{id}/detailsPOST($domain, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/detailsPOST: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::BlacklistsApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $id = 56; # Integer | ID of the blacklist being queried

eval {
    my $result = $api_instance->/domain/{domain}/blacklists/{id}/detailsPOST(domain => $domain, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/detailsPOST: $@\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.BlacklistsApi()
domain = 56 # Integer | the ID of the domain to query
id = 56 # Integer | ID of the blacklist being queried

try:
    # Retrieves a particular blacklist's contents

    api_response = api_instance./domain/{domain}/blacklists/{id}/details_post(domain, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/detailsPOST: %s\n" % e)

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

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

public class BlacklistsApiExample {

    public static void main(String[] args) {

        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String id = id_example; // String | ID of the blacklist to drop
        try {
            inline_response_200_4 result = apiInstance./domain/{domain}/blacklists/{id}/dropGET(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/{id}/dropGET");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BlacklistsApi;

public class BlacklistsApiExample {

    public static void main(String[] args) {
        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String id = id_example; // String | ID of the blacklist to drop
        try {
            inline_response_200_4 result = apiInstance./domain/{domain}/blacklists/{id}/dropGET(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/{id}/dropGET");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
String *id = id_example; // ID of the blacklist to drop

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

// Drops a given blacklist

[apiInstance /domain/{domain}/blacklists/{id}/dropGETWith:domain
    id:id
              completionHandler: ^(inline_response_200_4 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.BlacklistsApi()

var domain = 56; // {Integer} the ID of the domain to query

var id = id_example; // {String} ID of the blacklist to drop


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

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

namespace Example
{
    public class /domain/{domain}/blacklists/{id}/dropGETExample
    {
        public void main()
        {

            var apiInstance = new BlacklistsApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var id = id_example;  // String | ID of the blacklist to drop

            try
            {
                // Drops a given blacklist

                inline_response_200_4 result = apiInstance./domain/{domain}/blacklists/{id}/dropGET(domain, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlacklistsApi./domain/{domain}/blacklists/{id}/dropGET: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\BlacklistsApi();
$domain = 56; // Integer | the ID of the domain to query
$id = id_example; // String | ID of the blacklist to drop

try {
    $result = $api_instance->/domain/{domain}/blacklists/{id}/dropGET($domain, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/dropGET: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::BlacklistsApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $id = id_example; # String | ID of the blacklist to drop

eval {
    my $result = $api_instance->/domain/{domain}/blacklists/{id}/dropGET(domain => $domain, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/dropGET: $@\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.BlacklistsApi()
domain = 56 # Integer | the ID of the domain to query
id = id_example # String | ID of the blacklist to drop

try:
    # Drops a given blacklist

    api_response = api_instance./domain/{domain}/blacklists/{id}/drop_get(domain, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/dropGET: %s\n" % e)

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

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

public class BlacklistsApiExample {

    public static void main(String[] args) {

        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String id = id_example; // String | ID of the blacklist to drop
        try {
            inline_response_200_4 result = apiInstance./domain/{domain}/blacklists/{id}/dropPOST(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/{id}/dropPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BlacklistsApi;

public class BlacklistsApiExample {

    public static void main(String[] args) {
        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String id = id_example; // String | ID of the blacklist to drop
        try {
            inline_response_200_4 result = apiInstance./domain/{domain}/blacklists/{id}/dropPOST(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/{id}/dropPOST");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
String *id = id_example; // ID of the blacklist to drop

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

// Drops a given blacklist

[apiInstance /domain/{domain}/blacklists/{id}/dropPOSTWith:domain
    id:id
              completionHandler: ^(inline_response_200_4 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.BlacklistsApi()

var domain = 56; // {Integer} the ID of the domain to query

var id = id_example; // {String} ID of the blacklist to drop


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

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

namespace Example
{
    public class /domain/{domain}/blacklists/{id}/dropPOSTExample
    {
        public void main()
        {

            var apiInstance = new BlacklistsApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var id = id_example;  // String | ID of the blacklist to drop

            try
            {
                // Drops a given blacklist

                inline_response_200_4 result = apiInstance./domain/{domain}/blacklists/{id}/dropPOST(domain, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlacklistsApi./domain/{domain}/blacklists/{id}/dropPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\BlacklistsApi();
$domain = 56; // Integer | the ID of the domain to query
$id = id_example; // String | ID of the blacklist to drop

try {
    $result = $api_instance->/domain/{domain}/blacklists/{id}/dropPOST($domain, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/dropPOST: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::BlacklistsApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $id = id_example; # String | ID of the blacklist to drop

eval {
    my $result = $api_instance->/domain/{domain}/blacklists/{id}/dropPOST(domain => $domain, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/dropPOST: $@\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.BlacklistsApi()
domain = 56 # Integer | the ID of the domain to query
id = id_example # String | ID of the blacklist to drop

try:
    # Drops a given blacklist

    api_response = api_instance./domain/{domain}/blacklists/{id}/drop_post(domain, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/dropPOST: %s\n" % e)

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

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

public class BlacklistsApiExample {

    public static void main(String[] args) {

        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String id = id_example; // String | ID of the blacklist to modify
        String string = string_example; // String | element to remove from the blacklist
        try {
            inline_response_200_7 result = apiInstance./domain/{domain}/blacklists/{id}/remove/{string}GET(domain, id, string);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/{id}/remove/{string}GET");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BlacklistsApi;

public class BlacklistsApiExample {

    public static void main(String[] args) {
        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String id = id_example; // String | ID of the blacklist to modify
        String string = string_example; // String | element to remove from the blacklist
        try {
            inline_response_200_7 result = apiInstance./domain/{domain}/blacklists/{id}/remove/{string}GET(domain, id, string);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/{id}/remove/{string}GET");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
String *id = id_example; // ID of the blacklist to modify
String *string = string_example; // element to remove from the blacklist

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

// Removes elements from a given blacklist

[apiInstance /domain/{domain}/blacklists/{id}/remove/{string}GETWith:domain
    id:id
    string:string
              completionHandler: ^(inline_response_200_7 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.BlacklistsApi()

var domain = 56; // {Integer} the ID of the domain to query

var id = id_example; // {String} ID of the blacklist to modify

var string = string_example; // {String} element to remove from the blacklist


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api./domain/{domain}/blacklists/{id}/remove/{string}GET(domainid, string, callback);

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

namespace Example
{
    public class /domain/{domain}/blacklists/{id}/remove/{string}GETExample
    {
        public void main()
        {

            var apiInstance = new BlacklistsApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var id = id_example;  // String | ID of the blacklist to modify
            var string = string_example;  // String | element to remove from the blacklist

            try
            {
                // Removes elements from a given blacklist

                inline_response_200_7 result = apiInstance./domain/{domain}/blacklists/{id}/remove/{string}GET(domain, id, string);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlacklistsApi./domain/{domain}/blacklists/{id}/remove/{string}GET: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\BlacklistsApi();
$domain = 56; // Integer | the ID of the domain to query
$id = id_example; // String | ID of the blacklist to modify
$string = string_example; // String | element to remove from the blacklist

try {
    $result = $api_instance->/domain/{domain}/blacklists/{id}/remove/{string}GET($domain, $id, $string);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/remove/{string}GET: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::BlacklistsApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $id = id_example; # String | ID of the blacklist to modify
my $string = string_example; # String | element to remove from the blacklist

eval {
    my $result = $api_instance->/domain/{domain}/blacklists/{id}/remove/{string}GET(domain => $domain, id => $id, string => $string);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/remove/{string}GET: $@\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.BlacklistsApi()
domain = 56 # Integer | the ID of the domain to query
id = id_example # String | ID of the blacklist to modify
string = string_example # String | element to remove from the blacklist

try:
    # Removes elements from a given blacklist

    api_response = api_instance./domain/{domain}/blacklists/{id}/remove/{string}get(domain, id, string)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/remove/{string}GET: %s\n" % e)

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

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

public class BlacklistsApiExample {

    public static void main(String[] args) {

        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String id = id_example; // String | ID of the blacklist to modify
        String string = string_example; // String | element to remove from the blacklist
        RequestBody_30 requestBody = ; // RequestBody_30 | JSON object with a list of query-specific arguments
        try {
            inline_response_200_7 result = apiInstance./domain/{domain}/blacklists/{id}/remove/{string}POST(domain, id, string, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/{id}/remove/{string}POST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BlacklistsApi;

public class BlacklistsApiExample {

    public static void main(String[] args) {
        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String id = id_example; // String | ID of the blacklist to modify
        String string = string_example; // String | element to remove from the blacklist
        RequestBody_30 requestBody = ; // RequestBody_30 | JSON object with a list of query-specific arguments
        try {
            inline_response_200_7 result = apiInstance./domain/{domain}/blacklists/{id}/remove/{string}POST(domain, id, string, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/{id}/remove/{string}POST");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
String *id = id_example; // ID of the blacklist to modify
String *string = string_example; // element to remove from the blacklist
RequestBody_30 *requestBody = ; // JSON object with a list of query-specific arguments (optional)

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

// Removes elements from a given blacklist

[apiInstance /domain/{domain}/blacklists/{id}/remove/{string}POSTWith:domain
    id:id
    string:string
    requestBody:requestBody
              completionHandler: ^(inline_response_200_7 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.BlacklistsApi()

var domain = 56; // {Integer} the ID of the domain to query

var id = id_example; // {String} ID of the blacklist to modify

var string = string_example; // {String} element to remove from the blacklist

var opts = {
  'requestBody':  // {RequestBody_30} JSON object with a list of query-specific arguments
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api./domain/{domain}/blacklists/{id}/remove/{string}POST(domainid, string, opts, callback);

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

namespace Example
{
    public class /domain/{domain}/blacklists/{id}/remove/{string}POSTExample
    {
        public void main()
        {

            var apiInstance = new BlacklistsApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var id = id_example;  // String | ID of the blacklist to modify
            var string = string_example;  // String | element to remove from the blacklist
            var requestBody = new RequestBody_30(); // RequestBody_30 | JSON object with a list of query-specific arguments (optional)

            try
            {
                // Removes elements from a given blacklist

                inline_response_200_7 result = apiInstance./domain/{domain}/blacklists/{id}/remove/{string}POST(domain, id, string, requestBody);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlacklistsApi./domain/{domain}/blacklists/{id}/remove/{string}POST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\BlacklistsApi();
$domain = 56; // Integer | the ID of the domain to query
$id = id_example; // String | ID of the blacklist to modify
$string = string_example; // String | element to remove from the blacklist
$requestBody = ; // RequestBody_30 | JSON object with a list of query-specific arguments

try {
    $result = $api_instance->/domain/{domain}/blacklists/{id}/remove/{string}POST($domain, $id, $string, $requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/remove/{string}POST: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::BlacklistsApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $id = id_example; # String | ID of the blacklist to modify
my $string = string_example; # String | element to remove from the blacklist
my $requestBody = WWW::SwaggerClient::Object::RequestBody_30->new(); # RequestBody_30 | JSON object with a list of query-specific arguments

eval {
    my $result = $api_instance->/domain/{domain}/blacklists/{id}/remove/{string}POST(domain => $domain, id => $id, string => $string, requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/remove/{string}POST: $@\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.BlacklistsApi()
domain = 56 # Integer | the ID of the domain to query
id = id_example # String | ID of the blacklist to modify
string = string_example # String | element to remove from the blacklist
requestBody =  # RequestBody_30 | JSON object with a list of query-specific arguments (optional)

try:
    # Removes elements from a given blacklist

    api_response = api_instance./domain/{domain}/blacklists/{id}/remove/{string}post(domain, id, string, requestBody=requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/remove/{string}POST: %s\n" % e)

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

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

public class BlacklistsApiExample {

    public static void main(String[] args) {

        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String id = id_example; // String | ID of the blacklist to modify
        RequestBody_31 requestBody = ; // RequestBody_31 | JSON object with a list of query-specific arguments
        try {
            inline_response_200_7 result = apiInstance./domain/{domain}/blacklists/{id}/removePOST(domain, id, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/{id}/removePOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BlacklistsApi;

public class BlacklistsApiExample {

    public static void main(String[] args) {
        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String id = id_example; // String | ID of the blacklist to modify
        RequestBody_31 requestBody = ; // RequestBody_31 | JSON object with a list of query-specific arguments
        try {
            inline_response_200_7 result = apiInstance./domain/{domain}/blacklists/{id}/removePOST(domain, id, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/{id}/removePOST");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
String *id = id_example; // ID of the blacklist to modify
RequestBody_31 *requestBody = ; // JSON object with a list of query-specific arguments

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

// Removes elements from a given blacklist

[apiInstance /domain/{domain}/blacklists/{id}/removePOSTWith:domain
    id:id
    requestBody:requestBody
              completionHandler: ^(inline_response_200_7 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.BlacklistsApi()

var domain = 56; // {Integer} the ID of the domain to query

var id = id_example; // {String} ID of the blacklist to modify

var requestBody = ; // {RequestBody_31} JSON object with a list of query-specific arguments


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api./domain/{domain}/blacklists/{id}/removePOST(domainid, requestBody, callback);

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

namespace Example
{
    public class /domain/{domain}/blacklists/{id}/removePOSTExample
    {
        public void main()
        {

            var apiInstance = new BlacklistsApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var id = id_example;  // String | ID of the blacklist to modify
            var requestBody = new RequestBody_31(); // RequestBody_31 | JSON object with a list of query-specific arguments

            try
            {
                // Removes elements from a given blacklist

                inline_response_200_7 result = apiInstance./domain/{domain}/blacklists/{id}/removePOST(domain, id, requestBody);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlacklistsApi./domain/{domain}/blacklists/{id}/removePOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\BlacklistsApi();
$domain = 56; // Integer | the ID of the domain to query
$id = id_example; // String | ID of the blacklist to modify
$requestBody = ; // RequestBody_31 | JSON object with a list of query-specific arguments

try {
    $result = $api_instance->/domain/{domain}/blacklists/{id}/removePOST($domain, $id, $requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/removePOST: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::BlacklistsApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $id = id_example; # String | ID of the blacklist to modify
my $requestBody = WWW::SwaggerClient::Object::RequestBody_31->new(); # RequestBody_31 | JSON object with a list of query-specific arguments

eval {
    my $result = $api_instance->/domain/{domain}/blacklists/{id}/removePOST(domain => $domain, id => $id, requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/removePOST: $@\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.BlacklistsApi()
domain = 56 # Integer | the ID of the domain to query
id = id_example # String | ID of the blacklist to modify
requestBody =  # RequestBody_31 | JSON object with a list of query-specific arguments

try:
    # Removes elements from a given blacklist

    api_response = api_instance./domain/{domain}/blacklists/{id}/remove_post(domain, id, requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}/removePOST: %s\n" % e)

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

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

public class BlacklistsApiExample {

    public static void main(String[] args) {

        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String id = id_example; // String | ID of the blacklist to drop
        try {
            inline_response_200_4 result = apiInstance./domain/{domain}/blacklists/{id}DELETE(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/{id}DELETE");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BlacklistsApi;

public class BlacklistsApiExample {

    public static void main(String[] args) {
        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String id = id_example; // String | ID of the blacklist to drop
        try {
            inline_response_200_4 result = apiInstance./domain/{domain}/blacklists/{id}DELETE(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklists/{id}DELETE");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
String *id = id_example; // ID of the blacklist to drop

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

// Drops a given blacklist

[apiInstance /domain/{domain}/blacklists/{id}DELETEWith:domain
    id:id
              completionHandler: ^(inline_response_200_4 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.BlacklistsApi()

var domain = 56; // {Integer} the ID of the domain to query

var id = id_example; // {String} ID of the blacklist to drop


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

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

namespace Example
{
    public class /domain/{domain}/blacklists/{id}DELETEExample
    {
        public void main()
        {

            var apiInstance = new BlacklistsApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var id = id_example;  // String | ID of the blacklist to drop

            try
            {
                // Drops a given blacklist

                inline_response_200_4 result = apiInstance./domain/{domain}/blacklists/{id}DELETE(domain, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlacklistsApi./domain/{domain}/blacklists/{id}DELETE: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\BlacklistsApi();
$domain = 56; // Integer | the ID of the domain to query
$id = id_example; // String | ID of the blacklist to drop

try {
    $result = $api_instance->/domain/{domain}/blacklists/{id}DELETE($domain, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}DELETE: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::BlacklistsApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $id = id_example; # String | ID of the blacklist to drop

eval {
    my $result = $api_instance->/domain/{domain}/blacklists/{id}DELETE(domain => $domain, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}DELETE: $@\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.BlacklistsApi()
domain = 56 # Integer | the ID of the domain to query
id = id_example # String | ID of the blacklist to drop

try:
    # Drops a given blacklist

    api_response = api_instance./domain/{domain}/blacklists/{id}delete(domain, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlacklistsApi->/domain/{domain}/blacklists/{id}DELETE: %s\n" % e)

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

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

public class BlacklistsApiExample {

    public static void main(String[] args) {

        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        try {
            BlacklistList result = apiInstance./domain/{domain}/blacklistsGET(domain);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklistsGET");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BlacklistsApi;

public class BlacklistsApiExample {

    public static void main(String[] args) {
        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        try {
            BlacklistList result = apiInstance./domain/{domain}/blacklistsGET(domain);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklistsGET");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query

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

// Retrieves a list of available blacklists

[apiInstance /domain/{domain}/blacklistsGETWith:domain
              completionHandler: ^(BlacklistList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.BlacklistsApi()

var domain = 56; // {Integer} the ID of the domain to query


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

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

namespace Example
{
    public class /domain/{domain}/blacklistsGETExample
    {
        public void main()
        {

            var apiInstance = new BlacklistsApi();
            var domain = 56;  // Integer | the ID of the domain to query

            try
            {
                // Retrieves a list of available blacklists

                BlacklistList result = apiInstance./domain/{domain}/blacklistsGET(domain);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlacklistsApi./domain/{domain}/blacklistsGET: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\BlacklistsApi();
$domain = 56; // Integer | the ID of the domain to query

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

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

my $api_instance = WWW::SwaggerClient::BlacklistsApi->new();
my $domain = 56; # Integer | the ID of the domain to query

eval {
    my $result = $api_instance->/domain/{domain}/blacklistsGET(domain => $domain);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlacklistsApi->/domain/{domain}/blacklistsGET: $@\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.BlacklistsApi()
domain = 56 # Integer | the ID of the domain to query

try:
    # Retrieves a list of available blacklists

    api_response = api_instance./domain/{domain}/blacklists_get(domain)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlacklistsApi->/domain/{domain}/blacklistsGET: %s\n" % e)

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

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

public class BlacklistsApiExample {

    public static void main(String[] args) {

        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        RequestBody_25 requestBody = ; // RequestBody_25 | JSON object with a list of query-specific arguments
        try {
            BlacklistList result = apiInstance./domain/{domain}/blacklistsPOST(domain, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklistsPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BlacklistsApi;

public class BlacklistsApiExample {

    public static void main(String[] args) {
        BlacklistsApi apiInstance = new BlacklistsApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        RequestBody_25 requestBody = ; // RequestBody_25 | JSON object with a list of query-specific arguments
        try {
            BlacklistList result = apiInstance./domain/{domain}/blacklistsPOST(domain, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BlacklistsApi#/domain/{domain}/blacklistsPOST");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
RequestBody_25 *requestBody = ; // JSON object with a list of query-specific arguments (optional)

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

// Retrieves a list of available blacklists

[apiInstance /domain/{domain}/blacklistsPOSTWith:domain
    requestBody:requestBody
              completionHandler: ^(BlacklistList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.BlacklistsApi()

var domain = 56; // {Integer} the ID of the domain to query

var opts = {
  'requestBody':  // {RequestBody_25} JSON object with a list of query-specific arguments
};

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

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

namespace Example
{
    public class /domain/{domain}/blacklistsPOSTExample
    {
        public void main()
        {

            var apiInstance = new BlacklistsApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var requestBody = new RequestBody_25(); // RequestBody_25 | JSON object with a list of query-specific arguments (optional)

            try
            {
                // Retrieves a list of available blacklists

                BlacklistList result = apiInstance./domain/{domain}/blacklistsPOST(domain, requestBody);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BlacklistsApi./domain/{domain}/blacklistsPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\BlacklistsApi();
$domain = 56; // Integer | the ID of the domain to query
$requestBody = ; // RequestBody_25 | JSON object with a list of query-specific arguments

try {
    $result = $api_instance->/domain/{domain}/blacklistsPOST($domain, $requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling BlacklistsApi->/domain/{domain}/blacklistsPOST: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::BlacklistsApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $requestBody = WWW::SwaggerClient::Object::RequestBody_25->new(); # RequestBody_25 | JSON object with a list of query-specific arguments

eval {
    my $result = $api_instance->/domain/{domain}/blacklistsPOST(domain => $domain, requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling BlacklistsApi->/domain/{domain}/blacklistsPOST: $@\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.BlacklistsApi()
domain = 56 # Integer | the ID of the domain to query
requestBody =  # RequestBody_25 | JSON object with a list of query-specific arguments (optional)

try:
    # Retrieves a list of available blacklists

    api_response = api_instance./domain/{domain}/blacklists_post(domain, requestBody=requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BlacklistsApi->/domain/{domain}/blacklistsPOST: %s\n" % e)

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

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

public class DefaultApiExample {

    public static void main(String[] args) {

        DefaultApi apiInstance = new DefaultApi();
        try {
            apiInstance./swaggerGET();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#/swaggerGET");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

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

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

// Retrieves Swagger definition in YAML
[apiInstance /swaggerGETWithCompletionHandler:
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.DefaultApi()

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

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

namespace Example
{
    public class /swaggerGETExample
    {
        public void main()
        {

            var apiInstance = new DefaultApi();

            try
            {
                // Retrieves Swagger definition in YAML
                apiInstance./swaggerGET();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi./swaggerGET: " + e.Message );
            }
        }
    }
}

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

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

try {
    $api_instance->/swaggerGET();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->/swaggerGET: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

eval {
    $api_instance->/swaggerGET();
};
if ($@) {
    warn "Exception when calling DefaultApi->/swaggerGET: $@\n";
}

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

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

try:
    # Retrieves Swagger definition in YAML
    api_instance./swagger_get()
except ApiException as e:
    print("Exception when calling DefaultApi->/swaggerGET: %s\n" % e)

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

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

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {

        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String name = name_example; // String | name for the new dictionary
        try {
            inline_response_200_8 result = apiInstance./domain/{domain}/matching/dictionaries/new/{name}GET(domain, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/dictionaries/new/{name}GET");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesAndMatchingApi;

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {
        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String name = name_example; // String | name for the new dictionary
        try {
            inline_response_200_8 result = apiInstance./domain/{domain}/matching/dictionaries/new/{name}GET(domain, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/dictionaries/new/{name}GET");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
String *name = name_example; // name for the new dictionary

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

// Create a new dictionary

[apiInstance /domain/{domain}/matching/dictionaries/new/{name}GETWith:domain
    name:name
              completionHandler: ^(inline_response_200_8 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.DictionariesAndMatchingApi()

var domain = 56; // {Integer} the ID of the domain to query

var name = name_example; // {String} name for the new dictionary


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api./domain/{domain}/matching/dictionaries/new/{name}GET(domainname, callback);

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

namespace Example
{
    public class /domain/{domain}/matching/dictionaries/new/{name}GETExample
    {
        public void main()
        {

            var apiInstance = new DictionariesAndMatchingApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var name = name_example;  // String | name for the new dictionary

            try
            {
                // Create a new dictionary

                inline_response_200_8 result = apiInstance./domain/{domain}/matching/dictionaries/new/{name}GET(domain, name);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesAndMatchingApi./domain/{domain}/matching/dictionaries/new/{name}GET: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DictionariesAndMatchingApi();
$domain = 56; // Integer | the ID of the domain to query
$name = name_example; // String | name for the new dictionary

try {
    $result = $api_instance->/domain/{domain}/matching/dictionaries/new/{name}GET($domain, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionaries/new/{name}GET: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DictionariesAndMatchingApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $name = name_example; # String | name for the new dictionary

eval {
    my $result = $api_instance->/domain/{domain}/matching/dictionaries/new/{name}GET(domain => $domain, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionaries/new/{name}GET: $@\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.DictionariesAndMatchingApi()
domain = 56 # Integer | the ID of the domain to query
name = name_example # String | name for the new dictionary

try:
    # Create a new dictionary

    api_response = api_instance./domain/{domain}/matching/dictionaries/new/{name}get(domain, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionaries/new/{name}GET: %s\n" % e)

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

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

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {

        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String name = name_example; // String | name for the new dictionary
        RequestBody_33 requestBody = ; // RequestBody_33 | JSON object with a list of query-specific arguments
        try {
            inline_response_200_8 result = apiInstance./domain/{domain}/matching/dictionaries/new/{name}POST(domain, name, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/dictionaries/new/{name}POST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesAndMatchingApi;

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {
        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String name = name_example; // String | name for the new dictionary
        RequestBody_33 requestBody = ; // RequestBody_33 | JSON object with a list of query-specific arguments
        try {
            inline_response_200_8 result = apiInstance./domain/{domain}/matching/dictionaries/new/{name}POST(domain, name, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/dictionaries/new/{name}POST");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
String *name = name_example; // name for the new dictionary
RequestBody_33 *requestBody = ; // JSON object with a list of query-specific arguments (optional)

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

// Create a new dictionary

[apiInstance /domain/{domain}/matching/dictionaries/new/{name}POSTWith:domain
    name:name
    requestBody:requestBody
              completionHandler: ^(inline_response_200_8 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.DictionariesAndMatchingApi()

var domain = 56; // {Integer} the ID of the domain to query

var name = name_example; // {String} name for the new dictionary

var opts = {
  'requestBody':  // {RequestBody_33} JSON object with a list of query-specific arguments
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api./domain/{domain}/matching/dictionaries/new/{name}POST(domainname, opts, callback);

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

namespace Example
{
    public class /domain/{domain}/matching/dictionaries/new/{name}POSTExample
    {
        public void main()
        {

            var apiInstance = new DictionariesAndMatchingApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var name = name_example;  // String | name for the new dictionary
            var requestBody = new RequestBody_33(); // RequestBody_33 | JSON object with a list of query-specific arguments (optional)

            try
            {
                // Create a new dictionary

                inline_response_200_8 result = apiInstance./domain/{domain}/matching/dictionaries/new/{name}POST(domain, name, requestBody);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesAndMatchingApi./domain/{domain}/matching/dictionaries/new/{name}POST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DictionariesAndMatchingApi();
$domain = 56; // Integer | the ID of the domain to query
$name = name_example; // String | name for the new dictionary
$requestBody = ; // RequestBody_33 | JSON object with a list of query-specific arguments

try {
    $result = $api_instance->/domain/{domain}/matching/dictionaries/new/{name}POST($domain, $name, $requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionaries/new/{name}POST: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DictionariesAndMatchingApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $name = name_example; # String | name for the new dictionary
my $requestBody = WWW::SwaggerClient::Object::RequestBody_33->new(); # RequestBody_33 | JSON object with a list of query-specific arguments

eval {
    my $result = $api_instance->/domain/{domain}/matching/dictionaries/new/{name}POST(domain => $domain, name => $name, requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionaries/new/{name}POST: $@\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.DictionariesAndMatchingApi()
domain = 56 # Integer | the ID of the domain to query
name = name_example # String | name for the new dictionary
requestBody =  # RequestBody_33 | JSON object with a list of query-specific arguments (optional)

try:
    # Create a new dictionary

    api_response = api_instance./domain/{domain}/matching/dictionaries/new/{name}post(domain, name, requestBody=requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionaries/new/{name}POST: %s\n" % e)

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

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

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {

        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        RequestBody_34 requestBody = ; // RequestBody_34 | JSON object with a list of query-specific arguments
        try {
            inline_response_200_8 result = apiInstance./domain/{domain}/matching/dictionaries/newPOST(domain, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/dictionaries/newPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesAndMatchingApi;

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {
        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        RequestBody_34 requestBody = ; // RequestBody_34 | JSON object with a list of query-specific arguments
        try {
            inline_response_200_8 result = apiInstance./domain/{domain}/matching/dictionaries/newPOST(domain, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/dictionaries/newPOST");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
RequestBody_34 *requestBody = ; // JSON object with a list of query-specific arguments

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

// Create a new dictionary

[apiInstance /domain/{domain}/matching/dictionaries/newPOSTWith:domain
    requestBody:requestBody
              completionHandler: ^(inline_response_200_8 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.DictionariesAndMatchingApi()

var domain = 56; // {Integer} the ID of the domain to query

var requestBody = ; // {RequestBody_34} JSON object with a list of query-specific arguments


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api./domain/{domain}/matching/dictionaries/newPOST(domainrequestBody, callback);

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

namespace Example
{
    public class /domain/{domain}/matching/dictionaries/newPOSTExample
    {
        public void main()
        {

            var apiInstance = new DictionariesAndMatchingApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var requestBody = new RequestBody_34(); // RequestBody_34 | JSON object with a list of query-specific arguments

            try
            {
                // Create a new dictionary

                inline_response_200_8 result = apiInstance./domain/{domain}/matching/dictionaries/newPOST(domain, requestBody);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesAndMatchingApi./domain/{domain}/matching/dictionaries/newPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DictionariesAndMatchingApi();
$domain = 56; // Integer | the ID of the domain to query
$requestBody = ; // RequestBody_34 | JSON object with a list of query-specific arguments

try {
    $result = $api_instance->/domain/{domain}/matching/dictionaries/newPOST($domain, $requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionaries/newPOST: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DictionariesAndMatchingApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $requestBody = WWW::SwaggerClient::Object::RequestBody_34->new(); # RequestBody_34 | JSON object with a list of query-specific arguments

eval {
    my $result = $api_instance->/domain/{domain}/matching/dictionaries/newPOST(domain => $domain, requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionaries/newPOST: $@\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.DictionariesAndMatchingApi()
domain = 56 # Integer | the ID of the domain to query
requestBody =  # RequestBody_34 | JSON object with a list of query-specific arguments

try:
    # Create a new dictionary

    api_response = api_instance./domain/{domain}/matching/dictionaries/new_post(domain, requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionaries/newPOST: %s\n" % e)

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

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

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {

        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String id = id_example; // String | ID of the dictionary to which to add the new item
        RequestBody_35 requestBody = ; // RequestBody_35 | JSON object with a list of query-specific arguments
        try {
            AddItemsResult result = apiInstance./domain/{domain}/matching/dictionaries/{id}/add/itemsPOST(domain, id, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/dictionaries/{id}/add/itemsPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesAndMatchingApi;

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {
        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String id = id_example; // String | ID of the dictionary to which to add the new item
        RequestBody_35 requestBody = ; // RequestBody_35 | JSON object with a list of query-specific arguments
        try {
            AddItemsResult result = apiInstance./domain/{domain}/matching/dictionaries/{id}/add/itemsPOST(domain, id, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/dictionaries/{id}/add/itemsPOST");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
String *id = id_example; // ID of the dictionary to which to add the new item
RequestBody_35 *requestBody = ; // JSON object with a list of query-specific arguments

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

// Create new dictionary items

[apiInstance /domain/{domain}/matching/dictionaries/{id}/add/itemsPOSTWith:domain
    id:id
    requestBody:requestBody
              completionHandler: ^(AddItemsResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.DictionariesAndMatchingApi()

var domain = 56; // {Integer} the ID of the domain to query

var id = id_example; // {String} ID of the dictionary to which to add the new item

var requestBody = ; // {RequestBody_35} JSON object with a list of query-specific arguments


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api./domain/{domain}/matching/dictionaries/{id}/add/itemsPOST(domainid, requestBody, callback);

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

namespace Example
{
    public class /domain/{domain}/matching/dictionaries/{id}/add/itemsPOSTExample
    {
        public void main()
        {

            var apiInstance = new DictionariesAndMatchingApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var id = id_example;  // String | ID of the dictionary to which to add the new item
            var requestBody = new RequestBody_35(); // RequestBody_35 | JSON object with a list of query-specific arguments

            try
            {
                // Create new dictionary items

                AddItemsResult result = apiInstance./domain/{domain}/matching/dictionaries/{id}/add/itemsPOST(domain, id, requestBody);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesAndMatchingApi./domain/{domain}/matching/dictionaries/{id}/add/itemsPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DictionariesAndMatchingApi();
$domain = 56; // Integer | the ID of the domain to query
$id = id_example; // String | ID of the dictionary to which to add the new item
$requestBody = ; // RequestBody_35 | JSON object with a list of query-specific arguments

try {
    $result = $api_instance->/domain/{domain}/matching/dictionaries/{id}/add/itemsPOST($domain, $id, $requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionaries/{id}/add/itemsPOST: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DictionariesAndMatchingApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $id = id_example; # String | ID of the dictionary to which to add the new item
my $requestBody = WWW::SwaggerClient::Object::RequestBody_35->new(); # RequestBody_35 | JSON object with a list of query-specific arguments

eval {
    my $result = $api_instance->/domain/{domain}/matching/dictionaries/{id}/add/itemsPOST(domain => $domain, id => $id, requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionaries/{id}/add/itemsPOST: $@\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.DictionariesAndMatchingApi()
domain = 56 # Integer | the ID of the domain to query
id = id_example # String | ID of the dictionary to which to add the new item
requestBody =  # RequestBody_35 | JSON object with a list of query-specific arguments

try:
    # Create new dictionary items

    api_response = api_instance./domain/{domain}/matching/dictionaries/{id}/add/items_post(domain, id, requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionaries/{id}/add/itemsPOST: %s\n" % e)

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

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

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {

        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        Integer id = 56; // Integer | ID of the dictionary to retrieve
        try {
            DictionaryDetails result = apiInstance./domain/{domain}/matching/dictionaries/{id}/detailsGET(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/dictionaries/{id}/detailsGET");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesAndMatchingApi;

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {
        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        Integer id = 56; // Integer | ID of the dictionary to retrieve
        try {
            DictionaryDetails result = apiInstance./domain/{domain}/matching/dictionaries/{id}/detailsGET(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/dictionaries/{id}/detailsGET");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
Integer *id = 56; // ID of the dictionary to retrieve

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

// Retrieves the detailed contents for a given Dictionary

[apiInstance /domain/{domain}/matching/dictionaries/{id}/detailsGETWith:domain
    id:id
              completionHandler: ^(DictionaryDetails output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.DictionariesAndMatchingApi()

var domain = 56; // {Integer} the ID of the domain to query

var id = 56; // {Integer} ID of the dictionary to retrieve


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api./domain/{domain}/matching/dictionaries/{id}/detailsGET(domainid, callback);

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

namespace Example
{
    public class /domain/{domain}/matching/dictionaries/{id}/detailsGETExample
    {
        public void main()
        {

            var apiInstance = new DictionariesAndMatchingApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var id = 56;  // Integer | ID of the dictionary to retrieve

            try
            {
                // Retrieves the detailed contents for a given Dictionary

                DictionaryDetails result = apiInstance./domain/{domain}/matching/dictionaries/{id}/detailsGET(domain, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesAndMatchingApi./domain/{domain}/matching/dictionaries/{id}/detailsGET: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DictionariesAndMatchingApi();
$domain = 56; // Integer | the ID of the domain to query
$id = 56; // Integer | ID of the dictionary to retrieve

try {
    $result = $api_instance->/domain/{domain}/matching/dictionaries/{id}/detailsGET($domain, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionaries/{id}/detailsGET: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DictionariesAndMatchingApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $id = 56; # Integer | ID of the dictionary to retrieve

eval {
    my $result = $api_instance->/domain/{domain}/matching/dictionaries/{id}/detailsGET(domain => $domain, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionaries/{id}/detailsGET: $@\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.DictionariesAndMatchingApi()
domain = 56 # Integer | the ID of the domain to query
id = 56 # Integer | ID of the dictionary to retrieve

try:
    # Retrieves the detailed contents for a given Dictionary

    api_response = api_instance./domain/{domain}/matching/dictionaries/{id}/details_get(domain, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionaries/{id}/detailsGET: %s\n" % e)

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

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

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {

        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        Integer id = 56; // Integer | ID of the dictionary to retrieve
        try {
            DictionaryDetails result = apiInstance./domain/{domain}/matching/dictionaries/{id}/detailsPOST(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/dictionaries/{id}/detailsPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesAndMatchingApi;

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {
        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        Integer id = 56; // Integer | ID of the dictionary to retrieve
        try {
            DictionaryDetails result = apiInstance./domain/{domain}/matching/dictionaries/{id}/detailsPOST(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/dictionaries/{id}/detailsPOST");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
Integer *id = 56; // ID of the dictionary to retrieve

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

// Retrieves the detailed contents for a given Dictionary

[apiInstance /domain/{domain}/matching/dictionaries/{id}/detailsPOSTWith:domain
    id:id
              completionHandler: ^(DictionaryDetails output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.DictionariesAndMatchingApi()

var domain = 56; // {Integer} the ID of the domain to query

var id = 56; // {Integer} ID of the dictionary to retrieve


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api./domain/{domain}/matching/dictionaries/{id}/detailsPOST(domainid, callback);

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

namespace Example
{
    public class /domain/{domain}/matching/dictionaries/{id}/detailsPOSTExample
    {
        public void main()
        {

            var apiInstance = new DictionariesAndMatchingApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var id = 56;  // Integer | ID of the dictionary to retrieve

            try
            {
                // Retrieves the detailed contents for a given Dictionary

                DictionaryDetails result = apiInstance./domain/{domain}/matching/dictionaries/{id}/detailsPOST(domain, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesAndMatchingApi./domain/{domain}/matching/dictionaries/{id}/detailsPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DictionariesAndMatchingApi();
$domain = 56; // Integer | the ID of the domain to query
$id = 56; // Integer | ID of the dictionary to retrieve

try {
    $result = $api_instance->/domain/{domain}/matching/dictionaries/{id}/detailsPOST($domain, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionaries/{id}/detailsPOST: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DictionariesAndMatchingApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $id = 56; # Integer | ID of the dictionary to retrieve

eval {
    my $result = $api_instance->/domain/{domain}/matching/dictionaries/{id}/detailsPOST(domain => $domain, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionaries/{id}/detailsPOST: $@\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.DictionariesAndMatchingApi()
domain = 56 # Integer | the ID of the domain to query
id = 56 # Integer | ID of the dictionary to retrieve

try:
    # Retrieves the detailed contents for a given Dictionary

    api_response = api_instance./domain/{domain}/matching/dictionaries/{id}/details_post(domain, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionaries/{id}/detailsPOST: %s\n" % e)

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

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

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {

        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        Integer id = 56; // Integer | ID of the dictionary to drop
        try {
            inline_response_200_4 result = apiInstance./domain/{domain}/matching/dictionaries/{id}/dropGET(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/dictionaries/{id}/dropGET");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesAndMatchingApi;

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {
        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        Integer id = 56; // Integer | ID of the dictionary to drop
        try {
            inline_response_200_4 result = apiInstance./domain/{domain}/matching/dictionaries/{id}/dropGET(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/dictionaries/{id}/dropGET");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
Integer *id = 56; // ID of the dictionary to drop

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

// Drops a dictionary

[apiInstance /domain/{domain}/matching/dictionaries/{id}/dropGETWith:domain
    id:id
              completionHandler: ^(inline_response_200_4 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.DictionariesAndMatchingApi()

var domain = 56; // {Integer} the ID of the domain to query

var id = 56; // {Integer} ID of the dictionary to drop


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api./domain/{domain}/matching/dictionaries/{id}/dropGET(domainid, callback);

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

namespace Example
{
    public class /domain/{domain}/matching/dictionaries/{id}/dropGETExample
    {
        public void main()
        {

            var apiInstance = new DictionariesAndMatchingApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var id = 56;  // Integer | ID of the dictionary to drop

            try
            {
                // Drops a dictionary

                inline_response_200_4 result = apiInstance./domain/{domain}/matching/dictionaries/{id}/dropGET(domain, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesAndMatchingApi./domain/{domain}/matching/dictionaries/{id}/dropGET: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DictionariesAndMatchingApi();
$domain = 56; // Integer | the ID of the domain to query
$id = 56; // Integer | ID of the dictionary to drop

try {
    $result = $api_instance->/domain/{domain}/matching/dictionaries/{id}/dropGET($domain, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionaries/{id}/dropGET: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DictionariesAndMatchingApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $id = 56; # Integer | ID of the dictionary to drop

eval {
    my $result = $api_instance->/domain/{domain}/matching/dictionaries/{id}/dropGET(domain => $domain, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionaries/{id}/dropGET: $@\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.DictionariesAndMatchingApi()
domain = 56 # Integer | the ID of the domain to query
id = 56 # Integer | ID of the dictionary to drop

try:
    # Drops a dictionary

    api_response = api_instance./domain/{domain}/matching/dictionaries/{id}/drop_get(domain, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionaries/{id}/dropGET: %s\n" % e)

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

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

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {

        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        Integer id = 56; // Integer | ID of the dictionary to drop
        try {
            inline_response_200_4 result = apiInstance./domain/{domain}/matching/dictionaries/{id}/dropPOST(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/dictionaries/{id}/dropPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesAndMatchingApi;

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {
        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        Integer id = 56; // Integer | ID of the dictionary to drop
        try {
            inline_response_200_4 result = apiInstance./domain/{domain}/matching/dictionaries/{id}/dropPOST(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/dictionaries/{id}/dropPOST");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
Integer *id = 56; // ID of the dictionary to drop

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

// Drops a dictionary

[apiInstance /domain/{domain}/matching/dictionaries/{id}/dropPOSTWith:domain
    id:id
              completionHandler: ^(inline_response_200_4 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.DictionariesAndMatchingApi()

var domain = 56; // {Integer} the ID of the domain to query

var id = 56; // {Integer} ID of the dictionary to drop


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api./domain/{domain}/matching/dictionaries/{id}/dropPOST(domainid, callback);

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

namespace Example
{
    public class /domain/{domain}/matching/dictionaries/{id}/dropPOSTExample
    {
        public void main()
        {

            var apiInstance = new DictionariesAndMatchingApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var id = 56;  // Integer | ID of the dictionary to drop

            try
            {
                // Drops a dictionary

                inline_response_200_4 result = apiInstance./domain/{domain}/matching/dictionaries/{id}/dropPOST(domain, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesAndMatchingApi./domain/{domain}/matching/dictionaries/{id}/dropPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DictionariesAndMatchingApi();
$domain = 56; // Integer | the ID of the domain to query
$id = 56; // Integer | ID of the dictionary to drop

try {
    $result = $api_instance->/domain/{domain}/matching/dictionaries/{id}/dropPOST($domain, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionaries/{id}/dropPOST: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DictionariesAndMatchingApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $id = 56; # Integer | ID of the dictionary to drop

eval {
    my $result = $api_instance->/domain/{domain}/matching/dictionaries/{id}/dropPOST(domain => $domain, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionaries/{id}/dropPOST: $@\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.DictionariesAndMatchingApi()
domain = 56 # Integer | the ID of the domain to query
id = 56 # Integer | ID of the dictionary to drop

try:
    # Drops a dictionary

    api_response = api_instance./domain/{domain}/matching/dictionaries/{id}/drop_post(domain, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionaries/{id}/dropPOST: %s\n" % e)

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

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

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {

        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        Integer id = 56; // Integer | ID of the dictionary to drop
        try {
            inline_response_200_4 result = apiInstance./domain/{domain}/matching/dictionaries/{id}DELETE(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/dictionaries/{id}DELETE");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesAndMatchingApi;

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {
        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        Integer id = 56; // Integer | ID of the dictionary to drop
        try {
            inline_response_200_4 result = apiInstance./domain/{domain}/matching/dictionaries/{id}DELETE(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/dictionaries/{id}DELETE");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
Integer *id = 56; // ID of the dictionary to drop

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

// Drops a dictionary

[apiInstance /domain/{domain}/matching/dictionaries/{id}DELETEWith:domain
    id:id
              completionHandler: ^(inline_response_200_4 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.DictionariesAndMatchingApi()

var domain = 56; // {Integer} the ID of the domain to query

var id = 56; // {Integer} ID of the dictionary to drop


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api./domain/{domain}/matching/dictionaries/{id}DELETE(domainid, callback);

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

namespace Example
{
    public class /domain/{domain}/matching/dictionaries/{id}DELETEExample
    {
        public void main()
        {

            var apiInstance = new DictionariesAndMatchingApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var id = 56;  // Integer | ID of the dictionary to drop

            try
            {
                // Drops a dictionary

                inline_response_200_4 result = apiInstance./domain/{domain}/matching/dictionaries/{id}DELETE(domain, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesAndMatchingApi./domain/{domain}/matching/dictionaries/{id}DELETE: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DictionariesAndMatchingApi();
$domain = 56; // Integer | the ID of the domain to query
$id = 56; // Integer | ID of the dictionary to drop

try {
    $result = $api_instance->/domain/{domain}/matching/dictionaries/{id}DELETE($domain, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionaries/{id}DELETE: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DictionariesAndMatchingApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $id = 56; # Integer | ID of the dictionary to drop

eval {
    my $result = $api_instance->/domain/{domain}/matching/dictionaries/{id}DELETE(domain => $domain, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionaries/{id}DELETE: $@\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.DictionariesAndMatchingApi()
domain = 56 # Integer | the ID of the domain to query
id = 56 # Integer | ID of the dictionary to drop

try:
    # Drops a dictionary

    api_response = api_instance./domain/{domain}/matching/dictionaries/{id}delete(domain, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionaries/{id}DELETE: %s\n" % e)

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

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

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {

        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        try {
            DictionaryList result = apiInstance./domain/{domain}/matching/dictionariesGET(domain);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/dictionariesGET");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesAndMatchingApi;

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {
        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        try {
            DictionaryList result = apiInstance./domain/{domain}/matching/dictionariesGET(domain);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/dictionariesGET");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query

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

// Retrieves a list of available dictionaries

[apiInstance /domain/{domain}/matching/dictionariesGETWith:domain
              completionHandler: ^(DictionaryList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.DictionariesAndMatchingApi()

var domain = 56; // {Integer} the ID of the domain to query


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

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

namespace Example
{
    public class /domain/{domain}/matching/dictionariesGETExample
    {
        public void main()
        {

            var apiInstance = new DictionariesAndMatchingApi();
            var domain = 56;  // Integer | the ID of the domain to query

            try
            {
                // Retrieves a list of available dictionaries

                DictionaryList result = apiInstance./domain/{domain}/matching/dictionariesGET(domain);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesAndMatchingApi./domain/{domain}/matching/dictionariesGET: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DictionariesAndMatchingApi();
$domain = 56; // Integer | the ID of the domain to query

try {
    $result = $api_instance->/domain/{domain}/matching/dictionariesGET($domain);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionariesGET: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DictionariesAndMatchingApi->new();
my $domain = 56; # Integer | the ID of the domain to query

eval {
    my $result = $api_instance->/domain/{domain}/matching/dictionariesGET(domain => $domain);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionariesGET: $@\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.DictionariesAndMatchingApi()
domain = 56 # Integer | the ID of the domain to query

try:
    # Retrieves a list of available dictionaries

    api_response = api_instance./domain/{domain}/matching/dictionaries_get(domain)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionariesGET: %s\n" % e)

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

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

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {

        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        RequestBody_32 requestBody = ; // RequestBody_32 | JSON object with a list of query-specific arguments
        try {
            DictionaryList result = apiInstance./domain/{domain}/matching/dictionariesPOST(domain, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/dictionariesPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesAndMatchingApi;

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {
        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        RequestBody_32 requestBody = ; // RequestBody_32 | JSON object with a list of query-specific arguments
        try {
            DictionaryList result = apiInstance./domain/{domain}/matching/dictionariesPOST(domain, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/dictionariesPOST");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
RequestBody_32 *requestBody = ; // JSON object with a list of query-specific arguments (optional)

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

// Retrieves a list of available dictionaries

[apiInstance /domain/{domain}/matching/dictionariesPOSTWith:domain
    requestBody:requestBody
              completionHandler: ^(DictionaryList output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.DictionariesAndMatchingApi()

var domain = 56; // {Integer} the ID of the domain to query

var opts = {
  'requestBody':  // {RequestBody_32} JSON object with a list of query-specific arguments
};

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

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

namespace Example
{
    public class /domain/{domain}/matching/dictionariesPOSTExample
    {
        public void main()
        {

            var apiInstance = new DictionariesAndMatchingApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var requestBody = new RequestBody_32(); // RequestBody_32 | JSON object with a list of query-specific arguments (optional)

            try
            {
                // Retrieves a list of available dictionaries

                DictionaryList result = apiInstance./domain/{domain}/matching/dictionariesPOST(domain, requestBody);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesAndMatchingApi./domain/{domain}/matching/dictionariesPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DictionariesAndMatchingApi();
$domain = 56; // Integer | the ID of the domain to query
$requestBody = ; // RequestBody_32 | JSON object with a list of query-specific arguments

try {
    $result = $api_instance->/domain/{domain}/matching/dictionariesPOST($domain, $requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionariesPOST: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DictionariesAndMatchingApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $requestBody = WWW::SwaggerClient::Object::RequestBody_32->new(); # RequestBody_32 | JSON object with a list of query-specific arguments

eval {
    my $result = $api_instance->/domain/{domain}/matching/dictionariesPOST(domain => $domain, requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionariesPOST: $@\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.DictionariesAndMatchingApi()
domain = 56 # Integer | the ID of the domain to query
requestBody =  # RequestBody_32 | JSON object with a list of query-specific arguments (optional)

try:
    # Retrieves a list of available dictionaries

    api_response = api_instance./domain/{domain}/matching/dictionaries_post(domain, requestBody=requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/dictionariesPOST: %s\n" % e)

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

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

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {

        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        RequestBody_36 requestBody = ; // RequestBody_36 | JSON object with a list of query-specific arguments
        try {
            AddItemsResult result = apiInstance./domain/{domain}/matching/items/newPOST(domain, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/items/newPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesAndMatchingApi;

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {
        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        RequestBody_36 requestBody = ; // RequestBody_36 | JSON object with a list of query-specific arguments
        try {
            AddItemsResult result = apiInstance./domain/{domain}/matching/items/newPOST(domain, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/items/newPOST");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
RequestBody_36 *requestBody = ; // JSON object with a list of query-specific arguments

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

// Create new dictionary items

[apiInstance /domain/{domain}/matching/items/newPOSTWith:domain
    requestBody:requestBody
              completionHandler: ^(AddItemsResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.DictionariesAndMatchingApi()

var domain = 56; // {Integer} the ID of the domain to query

var requestBody = ; // {RequestBody_36} JSON object with a list of query-specific arguments


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api./domain/{domain}/matching/items/newPOST(domainrequestBody, callback);

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

namespace Example
{
    public class /domain/{domain}/matching/items/newPOSTExample
    {
        public void main()
        {

            var apiInstance = new DictionariesAndMatchingApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var requestBody = new RequestBody_36(); // RequestBody_36 | JSON object with a list of query-specific arguments

            try
            {
                // Create new dictionary items

                AddItemsResult result = apiInstance./domain/{domain}/matching/items/newPOST(domain, requestBody);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesAndMatchingApi./domain/{domain}/matching/items/newPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DictionariesAndMatchingApi();
$domain = 56; // Integer | the ID of the domain to query
$requestBody = ; // RequestBody_36 | JSON object with a list of query-specific arguments

try {
    $result = $api_instance->/domain/{domain}/matching/items/newPOST($domain, $requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/items/newPOST: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DictionariesAndMatchingApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $requestBody = WWW::SwaggerClient::Object::RequestBody_36->new(); # RequestBody_36 | JSON object with a list of query-specific arguments

eval {
    my $result = $api_instance->/domain/{domain}/matching/items/newPOST(domain => $domain, requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/items/newPOST: $@\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.DictionariesAndMatchingApi()
domain = 56 # Integer | the ID of the domain to query
requestBody =  # RequestBody_36 | JSON object with a list of query-specific arguments

try:
    # Create new dictionary items

    api_response = api_instance./domain/{domain}/matching/items/new_post(domain, requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/items/newPOST: %s\n" % e)

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

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

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {

        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String id = id_example; // String | ID or URI of the dictionary item to which to add the new terms
        RequestBody_37 requestBody = ; // RequestBody_37 | JSON object with a list of query-specific arguments
        try {
            AddTermsResult result = apiInstance./domain/{domain}/matching/items/{id}/add/termsPOST(domain, id, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/items/{id}/add/termsPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesAndMatchingApi;

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {
        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        String id = id_example; // String | ID or URI of the dictionary item to which to add the new terms
        RequestBody_37 requestBody = ; // RequestBody_37 | JSON object with a list of query-specific arguments
        try {
            AddTermsResult result = apiInstance./domain/{domain}/matching/items/{id}/add/termsPOST(domain, id, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/items/{id}/add/termsPOST");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
String *id = id_example; // ID or URI of the dictionary item to which to add the new terms
RequestBody_37 *requestBody = ; // JSON object with a list of query-specific arguments

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

// Create new dictionary terms

[apiInstance /domain/{domain}/matching/items/{id}/add/termsPOSTWith:domain
    id:id
    requestBody:requestBody
              completionHandler: ^(AddTermsResult output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.DictionariesAndMatchingApi()

var domain = 56; // {Integer} the ID of the domain to query

var id = id_example; // {String} ID or URI of the dictionary item to which to add the new terms

var requestBody = ; // {RequestBody_37} JSON object with a list of query-specific arguments


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api./domain/{domain}/matching/items/{id}/add/termsPOST(domainid, requestBody, callback);

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

namespace Example
{
    public class /domain/{domain}/matching/items/{id}/add/termsPOSTExample
    {
        public void main()
        {

            var apiInstance = new DictionariesAndMatchingApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var id = id_example;  // String | ID or URI of the dictionary item to which to add the new terms
            var requestBody = new RequestBody_37(); // RequestBody_37 | JSON object with a list of query-specific arguments

            try
            {
                // Create new dictionary terms

                AddTermsResult result = apiInstance./domain/{domain}/matching/items/{id}/add/termsPOST(domain, id, requestBody);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesAndMatchingApi./domain/{domain}/matching/items/{id}/add/termsPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DictionariesAndMatchingApi();
$domain = 56; // Integer | the ID of the domain to query
$id = id_example; // String | ID or URI of the dictionary item to which to add the new terms
$requestBody = ; // RequestBody_37 | JSON object with a list of query-specific arguments

try {
    $result = $api_instance->/domain/{domain}/matching/items/{id}/add/termsPOST($domain, $id, $requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/items/{id}/add/termsPOST: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DictionariesAndMatchingApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $id = id_example; # String | ID or URI of the dictionary item to which to add the new terms
my $requestBody = WWW::SwaggerClient::Object::RequestBody_37->new(); # RequestBody_37 | JSON object with a list of query-specific arguments

eval {
    my $result = $api_instance->/domain/{domain}/matching/items/{id}/add/termsPOST(domain => $domain, id => $id, requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/items/{id}/add/termsPOST: $@\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.DictionariesAndMatchingApi()
domain = 56 # Integer | the ID of the domain to query
id = id_example # String | ID or URI of the dictionary item to which to add the new terms
requestBody =  # RequestBody_37 | JSON object with a list of query-specific arguments

try:
    # Create new dictionary terms

    api_response = api_instance./domain/{domain}/matching/items/{id}/add/terms_post(domain, id, requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/items/{id}/add/termsPOST: %s\n" % e)

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

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

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {

        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        Integer id = 56; // Integer | ID or URI of the dictionary item to retrieve
        try {
            inline_response_200_9 result = apiInstance./domain/{domain}/matching/items/{id}/detailsGET(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/items/{id}/detailsGET");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesAndMatchingApi;

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {
        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        Integer id = 56; // Integer | ID or URI of the dictionary item to retrieve
        try {
            inline_response_200_9 result = apiInstance./domain/{domain}/matching/items/{id}/detailsGET(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/items/{id}/detailsGET");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
Integer *id = 56; // ID or URI of the dictionary item to retrieve

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

// Retrieves the detailed contents for a given Dictionary Item

[apiInstance /domain/{domain}/matching/items/{id}/detailsGETWith:domain
    id:id
              completionHandler: ^(inline_response_200_9 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.DictionariesAndMatchingApi()

var domain = 56; // {Integer} the ID of the domain to query

var id = 56; // {Integer} ID or URI of the dictionary item to retrieve


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api./domain/{domain}/matching/items/{id}/detailsGET(domainid, callback);

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

namespace Example
{
    public class /domain/{domain}/matching/items/{id}/detailsGETExample
    {
        public void main()
        {

            var apiInstance = new DictionariesAndMatchingApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var id = 56;  // Integer | ID or URI of the dictionary item to retrieve

            try
            {
                // Retrieves the detailed contents for a given Dictionary Item

                inline_response_200_9 result = apiInstance./domain/{domain}/matching/items/{id}/detailsGET(domain, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesAndMatchingApi./domain/{domain}/matching/items/{id}/detailsGET: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DictionariesAndMatchingApi();
$domain = 56; // Integer | the ID of the domain to query
$id = 56; // Integer | ID or URI of the dictionary item to retrieve

try {
    $result = $api_instance->/domain/{domain}/matching/items/{id}/detailsGET($domain, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/items/{id}/detailsGET: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DictionariesAndMatchingApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $id = 56; # Integer | ID or URI of the dictionary item to retrieve

eval {
    my $result = $api_instance->/domain/{domain}/matching/items/{id}/detailsGET(domain => $domain, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/items/{id}/detailsGET: $@\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.DictionariesAndMatchingApi()
domain = 56 # Integer | the ID of the domain to query
id = 56 # Integer | ID or URI of the dictionary item to retrieve

try:
    # Retrieves the detailed contents for a given Dictionary Item

    api_response = api_instance./domain/{domain}/matching/items/{id}/details_get(domain, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/items/{id}/detailsGET: %s\n" % e)

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

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

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {

        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        Integer id = 56; // Integer | ID or URI of the dictionary item to retrieve
        try {
            inline_response_200_9 result = apiInstance./domain/{domain}/matching/items/{id}/detailsPOST(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/items/{id}/detailsPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesAndMatchingApi;

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {
        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        Integer id = 56; // Integer | ID or URI of the dictionary item to retrieve
        try {
            inline_response_200_9 result = apiInstance./domain/{domain}/matching/items/{id}/detailsPOST(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/items/{id}/detailsPOST");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
Integer *id = 56; // ID or URI of the dictionary item to retrieve

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

// Retrieves the detailed contents for a given Dictionary Item

[apiInstance /domain/{domain}/matching/items/{id}/detailsPOSTWith:domain
    id:id
              completionHandler: ^(inline_response_200_9 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.DictionariesAndMatchingApi()

var domain = 56; // {Integer} the ID of the domain to query

var id = 56; // {Integer} ID or URI of the dictionary item to retrieve


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api./domain/{domain}/matching/items/{id}/detailsPOST(domainid, callback);

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

namespace Example
{
    public class /domain/{domain}/matching/items/{id}/detailsPOSTExample
    {
        public void main()
        {

            var apiInstance = new DictionariesAndMatchingApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var id = 56;  // Integer | ID or URI of the dictionary item to retrieve

            try
            {
                // Retrieves the detailed contents for a given Dictionary Item

                inline_response_200_9 result = apiInstance./domain/{domain}/matching/items/{id}/detailsPOST(domain, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesAndMatchingApi./domain/{domain}/matching/items/{id}/detailsPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DictionariesAndMatchingApi();
$domain = 56; // Integer | the ID of the domain to query
$id = 56; // Integer | ID or URI of the dictionary item to retrieve

try {
    $result = $api_instance->/domain/{domain}/matching/items/{id}/detailsPOST($domain, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/items/{id}/detailsPOST: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DictionariesAndMatchingApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $id = 56; # Integer | ID or URI of the dictionary item to retrieve

eval {
    my $result = $api_instance->/domain/{domain}/matching/items/{id}/detailsPOST(domain => $domain, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/items/{id}/detailsPOST: $@\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.DictionariesAndMatchingApi()
domain = 56 # Integer | the ID of the domain to query
id = 56 # Integer | ID or URI of the dictionary item to retrieve

try:
    # Retrieves the detailed contents for a given Dictionary Item

    api_response = api_instance./domain/{domain}/matching/items/{id}/details_post(domain, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/items/{id}/detailsPOST: %s\n" % e)

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

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

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {

        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        Integer id = 56; // Integer | ID or URI of the dictionary item to drop
        try {
            inline_response_200_4 result = apiInstance./domain/{domain}/matching/items/{id}/dropGET(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/items/{id}/dropGET");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesAndMatchingApi;

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {
        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        Integer id = 56; // Integer | ID or URI of the dictionary item to drop
        try {
            inline_response_200_4 result = apiInstance./domain/{domain}/matching/items/{id}/dropGET(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/items/{id}/dropGET");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
Integer *id = 56; // ID or URI of the dictionary item to drop

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

// Drops a dictionary item

[apiInstance /domain/{domain}/matching/items/{id}/dropGETWith:domain
    id:id
              completionHandler: ^(inline_response_200_4 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.DictionariesAndMatchingApi()

var domain = 56; // {Integer} the ID of the domain to query

var id = 56; // {Integer} ID or URI of the dictionary item to drop


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api./domain/{domain}/matching/items/{id}/dropGET(domainid, callback);

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

namespace Example
{
    public class /domain/{domain}/matching/items/{id}/dropGETExample
    {
        public void main()
        {

            var apiInstance = new DictionariesAndMatchingApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var id = 56;  // Integer | ID or URI of the dictionary item to drop

            try
            {
                // Drops a dictionary item

                inline_response_200_4 result = apiInstance./domain/{domain}/matching/items/{id}/dropGET(domain, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesAndMatchingApi./domain/{domain}/matching/items/{id}/dropGET: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DictionariesAndMatchingApi();
$domain = 56; // Integer | the ID of the domain to query
$id = 56; // Integer | ID or URI of the dictionary item to drop

try {
    $result = $api_instance->/domain/{domain}/matching/items/{id}/dropGET($domain, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/items/{id}/dropGET: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DictionariesAndMatchingApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $id = 56; # Integer | ID or URI of the dictionary item to drop

eval {
    my $result = $api_instance->/domain/{domain}/matching/items/{id}/dropGET(domain => $domain, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/items/{id}/dropGET: $@\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.DictionariesAndMatchingApi()
domain = 56 # Integer | the ID of the domain to query
id = 56 # Integer | ID or URI of the dictionary item to drop

try:
    # Drops a dictionary item

    api_response = api_instance./domain/{domain}/matching/items/{id}/drop_get(domain, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/items/{id}/dropGET: %s\n" % e)

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

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

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {

        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        Integer id = 56; // Integer | ID or URI of the dictionary item to drop
        try {
            inline_response_200_4 result = apiInstance./domain/{domain}/matching/items/{id}/dropPOST(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/items/{id}/dropPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesAndMatchingApi;

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {
        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        Integer id = 56; // Integer | ID or URI of the dictionary item to drop
        try {
            inline_response_200_4 result = apiInstance./domain/{domain}/matching/items/{id}/dropPOST(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/items/{id}/dropPOST");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
Integer *id = 56; // ID or URI of the dictionary item to drop

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

// Drops a dictionary item

[apiInstance /domain/{domain}/matching/items/{id}/dropPOSTWith:domain
    id:id
              completionHandler: ^(inline_response_200_4 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.DictionariesAndMatchingApi()

var domain = 56; // {Integer} the ID of the domain to query

var id = 56; // {Integer} ID or URI of the dictionary item to drop


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api./domain/{domain}/matching/items/{id}/dropPOST(domainid, callback);

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

namespace Example
{
    public class /domain/{domain}/matching/items/{id}/dropPOSTExample
    {
        public void main()
        {

            var apiInstance = new DictionariesAndMatchingApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var id = 56;  // Integer | ID or URI of the dictionary item to drop

            try
            {
                // Drops a dictionary item

                inline_response_200_4 result = apiInstance./domain/{domain}/matching/items/{id}/dropPOST(domain, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesAndMatchingApi./domain/{domain}/matching/items/{id}/dropPOST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DictionariesAndMatchingApi();
$domain = 56; // Integer | the ID of the domain to query
$id = 56; // Integer | ID or URI of the dictionary item to drop

try {
    $result = $api_instance->/domain/{domain}/matching/items/{id}/dropPOST($domain, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/items/{id}/dropPOST: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DictionariesAndMatchingApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $id = 56; # Integer | ID or URI of the dictionary item to drop

eval {
    my $result = $api_instance->/domain/{domain}/matching/items/{id}/dropPOST(domain => $domain, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/items/{id}/dropPOST: $@\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.DictionariesAndMatchingApi()
domain = 56 # Integer | the ID of the domain to query
id = 56 # Integer | ID or URI of the dictionary item to drop

try:
    # Drops a dictionary item

    api_response = api_instance./domain/{domain}/matching/items/{id}/drop_post(domain, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/items/{id}/dropPOST: %s\n" % e)

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

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

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {

        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        Integer id = 56; // Integer | ID or URI of the dictionary item to drop
        try {
            inline_response_200_4 result = apiInstance./domain/{domain}/matching/items/{id}DELETE(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/items/{id}DELETE");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesAndMatchingApi;

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {
        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        Integer id = 56; // Integer | ID or URI of the dictionary item to drop
        try {
            inline_response_200_4 result = apiInstance./domain/{domain}/matching/items/{id}DELETE(domain, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/items/{id}DELETE");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
Integer *id = 56; // ID or URI of the dictionary item to drop

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

// Drops a dictionary item

[apiInstance /domain/{domain}/matching/items/{id}DELETEWith:domain
    id:id
              completionHandler: ^(inline_response_200_4 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.DictionariesAndMatchingApi()

var domain = 56; // {Integer} the ID of the domain to query

var id = 56; // {Integer} ID or URI of the dictionary item to drop


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api./domain/{domain}/matching/items/{id}DELETE(domainid, callback);

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

namespace Example
{
    public class /domain/{domain}/matching/items/{id}DELETEExample
    {
        public void main()
        {

            var apiInstance = new DictionariesAndMatchingApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var id = 56;  // Integer | ID or URI of the dictionary item to drop

            try
            {
                // Drops a dictionary item

                inline_response_200_4 result = apiInstance./domain/{domain}/matching/items/{id}DELETE(domain, id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesAndMatchingApi./domain/{domain}/matching/items/{id}DELETE: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DictionariesAndMatchingApi();
$domain = 56; // Integer | the ID of the domain to query
$id = 56; // Integer | ID or URI of the dictionary item to drop

try {
    $result = $api_instance->/domain/{domain}/matching/items/{id}DELETE($domain, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/items/{id}DELETE: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DictionariesAndMatchingApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $id = 56; # Integer | ID or URI of the dictionary item to drop

eval {
    my $result = $api_instance->/domain/{domain}/matching/items/{id}DELETE(domain => $domain, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/items/{id}DELETE: $@\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.DictionariesAndMatchingApi()
domain = 56 # Integer | the ID of the domain to query
id = 56 # Integer | ID or URI of the dictionary item to drop

try:
    # Drops a dictionary item

    api_response = api_instance./domain/{domain}/matching/items/{id}delete(domain, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/items/{id}DELETE: %s\n" % e)

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

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

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {

        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        Integer source = 56; // Integer | the source ID to query for
        try {
            inline_response_200_10 result = apiInstance./domain/{domain}/matching/match/{source}GET(domain, source);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/match/{source}GET");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesAndMatchingApi;

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {
        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        Integer source = 56; // Integer | the source ID to query for
        try {
            inline_response_200_10 result = apiInstance./domain/{domain}/matching/match/{source}GET(domain, source);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/match/{source}GET");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
Integer *source = 56; // the source ID to query for

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

// Matches a particular source against the current dictionary contents

[apiInstance /domain/{domain}/matching/match/{source}GETWith:domain
    source:source
              completionHandler: ^(inline_response_200_10 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.DictionariesAndMatchingApi()

var domain = 56; // {Integer} the ID of the domain to query

var source = 56; // {Integer} the source ID to query for


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api./domain/{domain}/matching/match/{source}GET(domainsource, callback);

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

namespace Example
{
    public class /domain/{domain}/matching/match/{source}GETExample
    {
        public void main()
        {

            var apiInstance = new DictionariesAndMatchingApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var source = 56;  // Integer | the source ID to query for

            try
            {
                // Matches a particular source against the current dictionary contents

                inline_response_200_10 result = apiInstance./domain/{domain}/matching/match/{source}GET(domain, source);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesAndMatchingApi./domain/{domain}/matching/match/{source}GET: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DictionariesAndMatchingApi();
$domain = 56; // Integer | the ID of the domain to query
$source = 56; // Integer | the source ID to query for

try {
    $result = $api_instance->/domain/{domain}/matching/match/{source}GET($domain, $source);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/match/{source}GET: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DictionariesAndMatchingApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $source = 56; # Integer | the source ID to query for

eval {
    my $result = $api_instance->/domain/{domain}/matching/match/{source}GET(domain => $domain, source => $source);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/match/{source}GET: $@\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.DictionariesAndMatchingApi()
domain = 56 # Integer | the ID of the domain to query
source = 56 # Integer | the source ID to query for

try:
    # Matches a particular source against the current dictionary contents

    api_response = api_instance./domain/{domain}/matching/match/{source}get(domain, source)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/match/{source}GET: %s\n" % e)

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

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

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {

        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        Integer source = 56; // Integer | the source ID to query for
        RequestBody_40 requestBody = ; // RequestBody_40 | JSON object with a list of query-specific arguments
        try {
            inline_response_200_10 result = apiInstance./domain/{domain}/matching/match/{source}POST(domain, source, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/match/{source}POST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesAndMatchingApi;

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {
        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        Integer source = 56; // Integer | the source ID to query for
        RequestBody_40 requestBody = ; // RequestBody_40 | JSON object with a list of query-specific arguments
        try {
            inline_response_200_10 result = apiInstance./domain/{domain}/matching/match/{source}POST(domain, source, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/match/{source}POST");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
Integer *source = 56; // the source ID to query for
RequestBody_40 *requestBody = ; // JSON object with a list of query-specific arguments (optional)

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

// Matches a particular source against the current dictionary contents

[apiInstance /domain/{domain}/matching/match/{source}POSTWith:domain
    source:source
    requestBody:requestBody
              completionHandler: ^(inline_response_200_10 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.DictionariesAndMatchingApi()

var domain = 56; // {Integer} the ID of the domain to query

var source = 56; // {Integer} the source ID to query for

var opts = {
  'requestBody':  // {RequestBody_40} JSON object with a list of query-specific arguments
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api./domain/{domain}/matching/match/{source}POST(domainsource, opts, callback);

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

namespace Example
{
    public class /domain/{domain}/matching/match/{source}POSTExample
    {
        public void main()
        {

            var apiInstance = new DictionariesAndMatchingApi();
            var domain = 56;  // Integer | the ID of the domain to query
            var source = 56;  // Integer | the source ID to query for
            var requestBody = new RequestBody_40(); // RequestBody_40 | JSON object with a list of query-specific arguments (optional)

            try
            {
                // Matches a particular source against the current dictionary contents

                inline_response_200_10 result = apiInstance./domain/{domain}/matching/match/{source}POST(domain, source, requestBody);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesAndMatchingApi./domain/{domain}/matching/match/{source}POST: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DictionariesAndMatchingApi();
$domain = 56; // Integer | the ID of the domain to query
$source = 56; // Integer | the source ID to query for
$requestBody = ; // RequestBody_40 | JSON object with a list of query-specific arguments

try {
    $result = $api_instance->/domain/{domain}/matching/match/{source}POST($domain, $source, $requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/match/{source}POST: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DictionariesAndMatchingApi->new();
my $domain = 56; # Integer | the ID of the domain to query
my $source = 56; # Integer | the source ID to query for
my $requestBody = WWW::SwaggerClient::Object::RequestBody_40->new(); # RequestBody_40 | JSON object with a list of query-specific arguments

eval {
    my $result = $api_instance->/domain/{domain}/matching/match/{source}POST(domain => $domain, source => $source, requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/match/{source}POST: $@\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.DictionariesAndMatchingApi()
domain = 56 # Integer | the ID of the domain to query
source = 56 # Integer | the source ID to query for
requestBody =  # RequestBody_40 | JSON object with a list of query-specific arguments (optional)

try:
    # Matches a particular source against the current dictionary contents

    api_response = api_instance./domain/{domain}/matching/match/{source}post(domain, source, requestBody=requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/match/{source}POST: %s\n" % e)

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

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

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {

        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        try {
            inline_response_200_10 result = apiInstance./domain/{domain}/matching/matchGET(domain);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/matchGET");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesAndMatchingApi;

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {
        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        try {
            inline_response_200_10 result = apiInstance./domain/{domain}/matching/matchGET(domain);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/matchGET");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query

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

// Matches all sources against the current dictionary contents

[apiInstance /domain/{domain}/matching/matchGETWith:domain
              completionHandler: ^(inline_response_200_10 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.DictionariesAndMatchingApi()

var domain = 56; // {Integer} the ID of the domain to query


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

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

namespace Example
{
    public class /domain/{domain}/matching/matchGETExample
    {
        public void main()
        {

            var apiInstance = new DictionariesAndMatchingApi();
            var domain = 56;  // Integer | the ID of the domain to query

            try
            {
                // Matches all sources against the current dictionary contents

                inline_response_200_10 result = apiInstance./domain/{domain}/matching/matchGET(domain);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DictionariesAndMatchingApi./domain/{domain}/matching/matchGET: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\DictionariesAndMatchingApi();
$domain = 56; // Integer | the ID of the domain to query

try {
    $result = $api_instance->/domain/{domain}/matching/matchGET($domain);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/matchGET: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::DictionariesAndMatchingApi->new();
my $domain = 56; # Integer | the ID of the domain to query

eval {
    my $result = $api_instance->/domain/{domain}/matching/matchGET(domain => $domain);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/matchGET: $@\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.DictionariesAndMatchingApi()
domain = 56 # Integer | the ID of the domain to query

try:
    # Matches all sources against the current dictionary contents

    api_response = api_instance./domain/{domain}/matching/match_get(domain)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DictionariesAndMatchingApi->/domain/{domain}/matching/matchGET: %s\n" % e)

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

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

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {

        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        RequestBody_39 requestBody = ; // RequestBody_39 | JSON object with a list of query-specific arguments
        try {
            inline_response_200_10 result = apiInstance./domain/{domain}/matching/matchPOST(domain, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/matchPOST");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DictionariesAndMatchingApi;

public class DictionariesAndMatchingApiExample {

    public static void main(String[] args) {
        DictionariesAndMatchingApi apiInstance = new DictionariesAndMatchingApi();
        Integer domain = 56; // Integer | the ID of the domain to query
        RequestBody_39 requestBody = ; // RequestBody_39 | JSON object with a list of query-specific arguments
        try {
            inline_response_200_10 result = apiInstance./domain/{domain}/matching/matchPOST(domain, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DictionariesAndMatchingApi#/domain/{domain}/matching/matchPOST");
            e.printStackTrace();
        }
    }
}

Integer *domain = 56; // the ID of the domain to query
RequestBody_39 *requestBody = ; // JSON object with a list of query-specific arguments (optional)

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

// Matches all sources against the current dictionary contents

[apiInstance /domain/{domain}/matching/matchPOSTWith:domain
    requestBody:requestBody
              completionHandler: ^(inline_response_200_10 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var IKnowRestApIs = require('i_know_rest_ap_is');

var api = new IKnowRestApIs.DictionariesAndMatchingApi()

var domain = 56; // {Integer} the ID of the domain to query

var opts = {
  'requestBody':  // {RequestBody_39} JSON object with a list of query-specific arguments
};

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