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

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

public class AdjudicationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        AdjudicationApi apiInstance = new AdjudicationApi();
        String caseId = caseId_example; // String | 
        try {
            byte[] result = apiInstance.generateAdjudicationCaseReport(caseId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdjudicationApi#generateAdjudicationCaseReport");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdjudicationApi;

public class AdjudicationApiExample {

    public static void main(String[] args) {
        AdjudicationApi apiInstance = new AdjudicationApi();
        String caseId = caseId_example; // String | 
        try {
            byte[] result = apiInstance.generateAdjudicationCaseReport(caseId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdjudicationApi#generateAdjudicationCaseReport");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *caseId = caseId_example; // 

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

// Generates adjudication case report
[apiInstance generateAdjudicationCaseReportWith:caseId
              completionHandler: ^(byte[] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.AdjudicationApi()

var caseId = caseId_example; // {String} 


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

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

namespace Example
{
    public class generateAdjudicationCaseReportExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new AdjudicationApi();
            var caseId = caseId_example;  // String | 

            try
            {
                // Generates adjudication case report
                byte[] result = apiInstance.generateAdjudicationCaseReport(caseId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdjudicationApi.generateAdjudicationCaseReport: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\AdjudicationApi();
$caseId = caseId_example; // String | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::AdjudicationApi->new();
my $caseId = caseId_example; # String | 

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.AdjudicationApi()
caseId = caseId_example # String | 

try: 
    # Generates adjudication case report
    api_response = api_instance.generate_adjudication_case_report(caseId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdjudicationApi->generateAdjudicationCaseReport: %s\n" % e)

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

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

public class AdjudicationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        AdjudicationApi apiInstance = new AdjudicationApi();
        String caseId = caseId_example; // String | 
        try {
            AdjudicationCase result = apiInstance.getAdjudicationCase(caseId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdjudicationApi#getAdjudicationCase");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdjudicationApi;

public class AdjudicationApiExample {

    public static void main(String[] args) {
        AdjudicationApi apiInstance = new AdjudicationApi();
        String caseId = caseId_example; // String | 
        try {
            AdjudicationCase result = apiInstance.getAdjudicationCase(caseId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdjudicationApi#getAdjudicationCase");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *caseId = caseId_example; // 

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

// Returns main information about adjucation case
[apiInstance getAdjudicationCaseWith:caseId
              completionHandler: ^(AdjudicationCase output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.AdjudicationApi()

var caseId = caseId_example; // {String} 


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

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

namespace Example
{
    public class getAdjudicationCaseExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new AdjudicationApi();
            var caseId = caseId_example;  // String | 

            try
            {
                // Returns main information about adjucation case
                AdjudicationCase result = apiInstance.getAdjudicationCase(caseId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdjudicationApi.getAdjudicationCase: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\AdjudicationApi();
$caseId = caseId_example; // String | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::AdjudicationApi->new();
my $caseId = caseId_example; # String | 

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.AdjudicationApi()
caseId = caseId_example # String | 

try: 
    # Returns main information about adjucation case
    api_response = api_instance.get_adjudication_case(caseId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdjudicationApi->getAdjudicationCase: %s\n" % e)

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

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

public class AdjudicationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        AdjudicationApi apiInstance = new AdjudicationApi();
        try {
            AdjudicationCaseCount result = apiInstance.getAdjudicationCaseCount();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdjudicationApi#getAdjudicationCaseCount");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdjudicationApi;

public class AdjudicationApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


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

// Returns adjudication case count
[apiInstance getAdjudicationCaseCountWithCompletionHandler: 
              ^(AdjudicationCaseCount output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.AdjudicationApi()

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

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

namespace Example
{
    public class getAdjudicationCaseCountExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new AdjudicationApi();

            try
            {
                // Returns adjudication case count
                AdjudicationCaseCount result = apiInstance.getAdjudicationCaseCount();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdjudicationApi.getAdjudicationCaseCount: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

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

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try: 
    # Returns adjudication case count
    api_response = api_instance.get_adjudication_case_count()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdjudicationApi->getAdjudicationCaseCount: %s\n" % e)

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

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

public class AdjudicationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        AdjudicationApi apiInstance = new AdjudicationApi();
        Integer page = 56; // Integer | Page number
        Integer size = 56; // Integer | Page size
        String sort = sort_example; // String | Field name to sort by
        Boolean reverse = true; // Boolean | If true - sort descending, false - ascending
        String status = status_example; // String | Filter by status
        Integer priority = 56; // Integer | Filter by priority
        Date createdAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper createdAt bound
        Date createdAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower createdAt bound
        Date startedAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper startedAt bound
        Date startedAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower startedAt bound
        Date completedAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper completedAt bound
        Date completedAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower completedAt bound
        Integer userId = 56; // Integer | Filter by userId
        String subjectId = subjectId_example; // String | Filter by subjectId
        try {
            array[AdjudicationCase] result = apiInstance.getAdjudicationCases(page, size, sort, reverse, status, priority, createdAtUpper, createdAtLower, startedAtUpper, startedAtLower, completedAtUpper, completedAtLower, userId, subjectId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdjudicationApi#getAdjudicationCases");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdjudicationApi;

public class AdjudicationApiExample {

    public static void main(String[] args) {
        AdjudicationApi apiInstance = new AdjudicationApi();
        Integer page = 56; // Integer | Page number
        Integer size = 56; // Integer | Page size
        String sort = sort_example; // String | Field name to sort by
        Boolean reverse = true; // Boolean | If true - sort descending, false - ascending
        String status = status_example; // String | Filter by status
        Integer priority = 56; // Integer | Filter by priority
        Date createdAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper createdAt bound
        Date createdAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower createdAt bound
        Date startedAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper startedAt bound
        Date startedAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower startedAt bound
        Date completedAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper completedAt bound
        Date completedAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower completedAt bound
        Integer userId = 56; // Integer | Filter by userId
        String subjectId = subjectId_example; // String | Filter by subjectId
        try {
            array[AdjudicationCase] result = apiInstance.getAdjudicationCases(page, size, sort, reverse, status, priority, createdAtUpper, createdAtLower, startedAtUpper, startedAtLower, completedAtUpper, completedAtLower, userId, subjectId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdjudicationApi#getAdjudicationCases");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

Integer *page = 56; // Page number (optional) (default to 0)
Integer *size = 56; // Page size (optional) (default to 15)
String *sort = sort_example; // Field name to sort by (optional) (default to requestId)
Boolean *reverse = true; // If true - sort descending, false - ascending (optional)
String *status = status_example; // Filter by status (optional)
Integer *priority = 56; // Filter by priority (optional)
Date *createdAtUpper = 2013-10-20T19:20:30+01:00; // Upper createdAt bound (optional)
Date *createdAtLower = 2013-10-20T19:20:30+01:00; // Lower createdAt bound (optional)
Date *startedAtUpper = 2013-10-20T19:20:30+01:00; // Upper startedAt bound (optional)
Date *startedAtLower = 2013-10-20T19:20:30+01:00; // Lower startedAt bound (optional)
Date *completedAtUpper = 2013-10-20T19:20:30+01:00; // Upper completedAt bound (optional)
Date *completedAtLower = 2013-10-20T19:20:30+01:00; // Lower completedAt bound (optional)
Integer *userId = 56; // Filter by userId (optional)
String *subjectId = subjectId_example; // Filter by subjectId (optional)

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

// Returns adjudication cases (only basic case information is returned)
[apiInstance getAdjudicationCasesWith:page
    size:size
    sort:sort
    reverse:reverse
    status:status
    priority:priority
    createdAtUpper:createdAtUpper
    createdAtLower:createdAtLower
    startedAtUpper:startedAtUpper
    startedAtLower:startedAtLower
    completedAtUpper:completedAtUpper
    completedAtLower:completedAtLower
    userId:userId
    subjectId:subjectId
              completionHandler: ^(array[AdjudicationCase] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.AdjudicationApi()

var opts = { 
  'page': 56, // {Integer} Page number
  'size': 56, // {Integer} Page size
  'sort': sort_example, // {String} Field name to sort by
  'reverse': true, // {Boolean} If true - sort descending, false - ascending
  'status': status_example, // {String} Filter by status
  'priority': 56, // {Integer} Filter by priority
  'createdAtUpper': 2013-10-20T19:20:30+01:00, // {Date} Upper createdAt bound
  'createdAtLower': 2013-10-20T19:20:30+01:00, // {Date} Lower createdAt bound
  'startedAtUpper': 2013-10-20T19:20:30+01:00, // {Date} Upper startedAt bound
  'startedAtLower': 2013-10-20T19:20:30+01:00, // {Date} Lower startedAt bound
  'completedAtUpper': 2013-10-20T19:20:30+01:00, // {Date} Upper completedAt bound
  'completedAtLower': 2013-10-20T19:20:30+01:00, // {Date} Lower completedAt bound
  'userId': 56, // {Integer} Filter by userId
  'subjectId': subjectId_example // {String} Filter by subjectId
};

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

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

namespace Example
{
    public class getAdjudicationCasesExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new AdjudicationApi();
            var page = 56;  // Integer | Page number (optional)  (default to 0)
            var size = 56;  // Integer | Page size (optional)  (default to 15)
            var sort = sort_example;  // String | Field name to sort by (optional)  (default to requestId)
            var reverse = true;  // Boolean | If true - sort descending, false - ascending (optional) 
            var status = status_example;  // String | Filter by status (optional) 
            var priority = 56;  // Integer | Filter by priority (optional) 
            var createdAtUpper = 2013-10-20T19:20:30+01:00;  // Date | Upper createdAt bound (optional) 
            var createdAtLower = 2013-10-20T19:20:30+01:00;  // Date | Lower createdAt bound (optional) 
            var startedAtUpper = 2013-10-20T19:20:30+01:00;  // Date | Upper startedAt bound (optional) 
            var startedAtLower = 2013-10-20T19:20:30+01:00;  // Date | Lower startedAt bound (optional) 
            var completedAtUpper = 2013-10-20T19:20:30+01:00;  // Date | Upper completedAt bound (optional) 
            var completedAtLower = 2013-10-20T19:20:30+01:00;  // Date | Lower completedAt bound (optional) 
            var userId = 56;  // Integer | Filter by userId (optional) 
            var subjectId = subjectId_example;  // String | Filter by subjectId (optional) 

            try
            {
                // Returns adjudication cases (only basic case information is returned)
                array[AdjudicationCase] result = apiInstance.getAdjudicationCases(page, size, sort, reverse, status, priority, createdAtUpper, createdAtLower, startedAtUpper, startedAtLower, completedAtUpper, completedAtLower, userId, subjectId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdjudicationApi.getAdjudicationCases: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\AdjudicationApi();
$page = 56; // Integer | Page number
$size = 56; // Integer | Page size
$sort = sort_example; // String | Field name to sort by
$reverse = true; // Boolean | If true - sort descending, false - ascending
$status = status_example; // String | Filter by status
$priority = 56; // Integer | Filter by priority
$createdAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper createdAt bound
$createdAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower createdAt bound
$startedAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper startedAt bound
$startedAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower startedAt bound
$completedAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper completedAt bound
$completedAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower completedAt bound
$userId = 56; // Integer | Filter by userId
$subjectId = subjectId_example; // String | Filter by subjectId

try {
    $result = $api_instance->getAdjudicationCases($page, $size, $sort, $reverse, $status, $priority, $createdAtUpper, $createdAtLower, $startedAtUpper, $startedAtLower, $completedAtUpper, $completedAtLower, $userId, $subjectId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AdjudicationApi->getAdjudicationCases: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::AdjudicationApi->new();
my $page = 56; # Integer | Page number
my $size = 56; # Integer | Page size
my $sort = sort_example; # String | Field name to sort by
my $reverse = true; # Boolean | If true - sort descending, false - ascending
my $status = status_example; # String | Filter by status
my $priority = 56; # Integer | Filter by priority
my $createdAtUpper = 2013-10-20T19:20:30+01:00; # Date | Upper createdAt bound
my $createdAtLower = 2013-10-20T19:20:30+01:00; # Date | Lower createdAt bound
my $startedAtUpper = 2013-10-20T19:20:30+01:00; # Date | Upper startedAt bound
my $startedAtLower = 2013-10-20T19:20:30+01:00; # Date | Lower startedAt bound
my $completedAtUpper = 2013-10-20T19:20:30+01:00; # Date | Upper completedAt bound
my $completedAtLower = 2013-10-20T19:20:30+01:00; # Date | Lower completedAt bound
my $userId = 56; # Integer | Filter by userId
my $subjectId = subjectId_example; # String | Filter by subjectId

eval { 
    my $result = $api_instance->getAdjudicationCases(page => $page, size => $size, sort => $sort, reverse => $reverse, status => $status, priority => $priority, createdAtUpper => $createdAtUpper, createdAtLower => $createdAtLower, startedAtUpper => $startedAtUpper, startedAtLower => $startedAtLower, completedAtUpper => $completedAtUpper, completedAtLower => $completedAtLower, userId => $userId, subjectId => $subjectId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdjudicationApi->getAdjudicationCases: $@\n";
}

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.AdjudicationApi()
page = 56 # Integer | Page number (optional) (default to 0)
size = 56 # Integer | Page size (optional) (default to 15)
sort = sort_example # String | Field name to sort by (optional) (default to requestId)
reverse = true # Boolean | If true - sort descending, false - ascending (optional)
status = status_example # String | Filter by status (optional)
priority = 56 # Integer | Filter by priority (optional)
createdAtUpper = 2013-10-20T19:20:30+01:00 # Date | Upper createdAt bound (optional)
createdAtLower = 2013-10-20T19:20:30+01:00 # Date | Lower createdAt bound (optional)
startedAtUpper = 2013-10-20T19:20:30+01:00 # Date | Upper startedAt bound (optional)
startedAtLower = 2013-10-20T19:20:30+01:00 # Date | Lower startedAt bound (optional)
completedAtUpper = 2013-10-20T19:20:30+01:00 # Date | Upper completedAt bound (optional)
completedAtLower = 2013-10-20T19:20:30+01:00 # Date | Lower completedAt bound (optional)
userId = 56 # Integer | Filter by userId (optional)
subjectId = subjectId_example # String | Filter by subjectId (optional)

try: 
    # Returns adjudication cases (only basic case information is returned)
    api_response = api_instance.get_adjudication_cases(page=page, size=size, sort=sort, reverse=reverse, status=status, priority=priority, createdAtUpper=createdAtUpper, createdAtLower=createdAtLower, startedAtUpper=startedAtUpper, startedAtLower=startedAtLower, completedAtUpper=completedAtUpper, completedAtLower=completedAtLower, userId=userId, subjectId=subjectId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdjudicationApi->getAdjudicationCases: %s\n" % e)

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

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

public class AdjudicationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        AdjudicationApi apiInstance = new AdjudicationApi();
        try {
            AdjudicationCase result = apiInstance.getNextAdjudicationCase();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdjudicationApi#getNextAdjudicationCase");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdjudicationApi;

public class AdjudicationApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


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

// Locks and returns next adjudication case to solve
[apiInstance getNextAdjudicationCaseWithCompletionHandler: 
              ^(AdjudicationCase output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.AdjudicationApi()

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

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

namespace Example
{
    public class getNextAdjudicationCaseExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new AdjudicationApi();

            try
            {
                // Locks and returns next adjudication case to solve
                AdjudicationCase result = apiInstance.getNextAdjudicationCase();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdjudicationApi.getNextAdjudicationCase: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

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

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try: 
    # Locks and returns next adjudication case to solve
    api_response = api_instance.get_next_adjudication_case()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdjudicationApi->getNextAdjudicationCase: %s\n" % e)

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

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

public class AdjudicationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        AdjudicationApi apiInstance = new AdjudicationApi();
        String caseId = caseId_example; // String | 
        try {
            apiInstance.lockAdjudicationCase(caseId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdjudicationApi#lockAdjudicationCase");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdjudicationApi;

public class AdjudicationApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *caseId = caseId_example; // 

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

// Locks adjucation case
[apiInstance lockAdjudicationCaseWith:caseId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.AdjudicationApi()

var caseId = caseId_example; // {String} 


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

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

namespace Example
{
    public class lockAdjudicationCaseExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new AdjudicationApi();
            var caseId = caseId_example;  // String | 

            try
            {
                // Locks adjucation case
                apiInstance.lockAdjudicationCase(caseId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdjudicationApi.lockAdjudicationCase: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\AdjudicationApi();
$caseId = caseId_example; // String | 

try {
    $api_instance->lockAdjudicationCase($caseId);
} catch (Exception $e) {
    echo 'Exception when calling AdjudicationApi->lockAdjudicationCase: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::AdjudicationApi->new();
my $caseId = caseId_example; # String | 

eval { 
    $api_instance->lockAdjudicationCase(caseId => $caseId);
};
if ($@) {
    warn "Exception when calling AdjudicationApi->lockAdjudicationCase: $@\n";
}

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.AdjudicationApi()
caseId = caseId_example # String | 

try: 
    # Locks adjucation case
    api_instance.lock_adjudication_case(caseId)
except ApiException as e:
    print("Exception when calling AdjudicationApi->lockAdjudicationCase: %s\n" % e)

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

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

public class AdjudicationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        AdjudicationApi apiInstance = new AdjudicationApi();
        String caseId = caseId_example; // String | 
        AdjudicationResolution body = ; // AdjudicationResolution | 
        try {
            apiInstance.resolveAdjudicationCase(caseId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdjudicationApi#resolveAdjudicationCase");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdjudicationApi;

public class AdjudicationApiExample {

    public static void main(String[] args) {
        AdjudicationApi apiInstance = new AdjudicationApi();
        String caseId = caseId_example; // String | 
        AdjudicationResolution body = ; // AdjudicationResolution | 
        try {
            apiInstance.resolveAdjudicationCase(caseId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdjudicationApi#resolveAdjudicationCase");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *caseId = caseId_example; // 
AdjudicationResolution *body = ; //  (optional)

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

// Resolve adjucation case
[apiInstance resolveAdjudicationCaseWith:caseId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.AdjudicationApi()

var caseId = caseId_example; // {String} 

var opts = { 
  'body':  // {AdjudicationResolution} 
};

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

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

namespace Example
{
    public class resolveAdjudicationCaseExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new AdjudicationApi();
            var caseId = caseId_example;  // String | 
            var body = new AdjudicationResolution(); // AdjudicationResolution |  (optional) 

            try
            {
                // Resolve adjucation case
                apiInstance.resolveAdjudicationCase(caseId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdjudicationApi.resolveAdjudicationCase: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\AdjudicationApi();
$caseId = caseId_example; // String | 
$body = ; // AdjudicationResolution | 

try {
    $api_instance->resolveAdjudicationCase($caseId, $body);
} catch (Exception $e) {
    echo 'Exception when calling AdjudicationApi->resolveAdjudicationCase: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::AdjudicationApi->new();
my $caseId = caseId_example; # String | 
my $body = WWW::SwaggerClient::Object::AdjudicationResolution->new(); # AdjudicationResolution | 

eval { 
    $api_instance->resolveAdjudicationCase(caseId => $caseId, body => $body);
};
if ($@) {
    warn "Exception when calling AdjudicationApi->resolveAdjudicationCase: $@\n";
}

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.AdjudicationApi()
caseId = caseId_example # String | 
body =  # AdjudicationResolution |  (optional)

try: 
    # Resolve adjucation case
    api_instance.resolve_adjudication_case(caseId, body=body)
except ApiException as e:
    print("Exception when calling AdjudicationApi->resolveAdjudicationCase: %s\n" % e)

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

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

public class AdjudicationApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        AdjudicationApi apiInstance = new AdjudicationApi();
        String caseId = caseId_example; // String | 
        try {
            apiInstance.unlockAdjudicationCase(caseId);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdjudicationApi#unlockAdjudicationCase");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.AdjudicationApi;

public class AdjudicationApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *caseId = caseId_example; // 

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

// Unlocks adjucation case
[apiInstance unlockAdjudicationCaseWith:caseId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.AdjudicationApi()

var caseId = caseId_example; // {String} 


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

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

namespace Example
{
    public class unlockAdjudicationCaseExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new AdjudicationApi();
            var caseId = caseId_example;  // String | 

            try
            {
                // Unlocks adjucation case
                apiInstance.unlockAdjudicationCase(caseId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AdjudicationApi.unlockAdjudicationCase: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\AdjudicationApi();
$caseId = caseId_example; // String | 

try {
    $api_instance->unlockAdjudicationCase($caseId);
} catch (Exception $e) {
    echo 'Exception when calling AdjudicationApi->unlockAdjudicationCase: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::AdjudicationApi->new();
my $caseId = caseId_example; # String | 

eval { 
    $api_instance->unlockAdjudicationCase(caseId => $caseId);
};
if ($@) {
    warn "Exception when calling AdjudicationApi->unlockAdjudicationCase: $@\n";
}

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.AdjudicationApi()
caseId = caseId_example # String | 

try: 
    # Unlocks adjucation case
    api_instance.unlock_adjudication_case(caseId)
except ApiException as e:
    print("Exception when calling AdjudicationApi->unlockAdjudicationCase: %s\n" % e)

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

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

public class BiographicDataApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        BiographicDataApi apiInstance = new BiographicDataApi();
        try {
            array[BiographicDataField] result = apiInstance.getBiographicDataFields();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BiographicDataApi#getBiographicDataFields");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BiographicDataApi;

public class BiographicDataApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


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

// Returns configured biographic data fields
[apiInstance getBiographicDataFieldsWithCompletionHandler: 
              ^(array[BiographicDataField] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.BiographicDataApi()

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

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

namespace Example
{
    public class getBiographicDataFieldsExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new BiographicDataApi();

            try
            {
                // Returns configured biographic data fields
                array[BiographicDataField] result = apiInstance.getBiographicDataFields();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BiographicDataApi.getBiographicDataFields: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

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

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try: 
    # Returns configured biographic data fields
    api_response = api_instance.get_biographic_data_fields()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BiographicDataApi->getBiographicDataFields: %s\n" % e)

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

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

public class BiographicDataApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        BiographicDataApi apiInstance = new BiographicDataApi();
        array[BiographicDataField] body = ; // array[BiographicDataField] | 
        try {
            Task result = apiInstance.setBiographicDataFields(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BiographicDataApi#setBiographicDataFields");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.BiographicDataApi;

public class BiographicDataApiExample {

    public static void main(String[] args) {
        BiographicDataApi apiInstance = new BiographicDataApi();
        array[BiographicDataField] body = ; // array[BiographicDataField] | 
        try {
            Task result = apiInstance.setBiographicDataFields(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BiographicDataApi#setBiographicDataFields");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

array[BiographicDataField] *body = ; //  (optional)

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

// Set new biographic data fields
[apiInstance setBiographicDataFieldsWith:body
              completionHandler: ^(Task output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.BiographicDataApi()

var opts = { 
  'body':  // {array[BiographicDataField]} 
};

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

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

namespace Example
{
    public class setBiographicDataFieldsExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new BiographicDataApi();
            var body = new array[BiographicDataField](); // array[BiographicDataField] |  (optional) 

            try
            {
                // Set new biographic data fields
                Task result = apiInstance.setBiographicDataFields(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling BiographicDataApi.setBiographicDataFields: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\BiographicDataApi();
$body = ; // array[BiographicDataField] | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::BiographicDataApi->new();
my $body = [WWW::SwaggerClient::Object::array[BiographicDataField]->new()]; # array[BiographicDataField] | 

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.BiographicDataApi()
body =  # array[BiographicDataField] |  (optional)

try: 
    # Set new biographic data fields
    api_response = api_instance.set_biographic_data_fields(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BiographicDataApi->setBiographicDataFields: %s\n" % e)

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

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

public class EncountersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        String type = type_example; // String | 
        try {
            byte[] result = apiInstance.exportEncounter(encounterId, type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#exportEncounter");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EncountersApi;

public class EncountersApiExample {

    public static void main(String[] args) {
        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        String type = type_example; // String | 
        try {
            byte[] result = apiInstance.exportEncounter(encounterId, type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#exportEncounter");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *encounterId = encounterId_example; // 
String *type = type_example; // 

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

// Exports encounter data
[apiInstance exportEncounterWith:encounterId
    type:type
              completionHandler: ^(byte[] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.EncountersApi()

var encounterId = encounterId_example; // {String} 

var type = type_example; // {String} 


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

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

namespace Example
{
    public class exportEncounterExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new EncountersApi();
            var encounterId = encounterId_example;  // String | 
            var type = type_example;  // String | 

            try
            {
                // Exports encounter data
                byte[] result = apiInstance.exportEncounter(encounterId, type);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EncountersApi.exportEncounter: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\EncountersApi();
$encounterId = encounterId_example; // String | 
$type = type_example; // String | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::EncountersApi->new();
my $encounterId = encounterId_example; # String | 
my $type = type_example; # String | 

eval { 
    my $result = $api_instance->exportEncounter(encounterId => $encounterId, type => $type);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EncountersApi->exportEncounter: $@\n";
}

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.EncountersApi()
encounterId = encounterId_example # String | 
type = type_example # String | 

try: 
    # Exports encounter data
    api_response = api_instance.export_encounter(encounterId, type)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EncountersApi->exportEncounter: %s\n" % e)

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

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

public class EncountersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        try {
            map['String', 'String'] result = apiInstance.getBiographicData(encounterId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getBiographicData");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EncountersApi;

public class EncountersApiExample {

    public static void main(String[] args) {
        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        try {
            map['String', 'String'] result = apiInstance.getBiographicData(encounterId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getBiographicData");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *encounterId = encounterId_example; // 

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

// Returns encounter biographic data
[apiInstance getBiographicDataWith:encounterId
              completionHandler: ^(map['String', 'String'] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.EncountersApi()

var encounterId = encounterId_example; // {String} 


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

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

namespace Example
{
    public class getBiographicDataExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new EncountersApi();
            var encounterId = encounterId_example;  // String | 

            try
            {
                // Returns encounter biographic data
                map['String', 'String'] result = apiInstance.getBiographicData(encounterId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EncountersApi.getBiographicData: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\EncountersApi();
$encounterId = encounterId_example; // String | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::EncountersApi->new();
my $encounterId = encounterId_example; # String | 

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.EncountersApi()
encounterId = encounterId_example # String | 

try: 
    # Returns encounter biographic data
    api_response = api_instance.get_biographic_data(encounterId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EncountersApi->getBiographicData: %s\n" % e)

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

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

public class EncountersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        try {
            Encounter result = apiInstance.getEncounter(encounterId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getEncounter");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EncountersApi;

public class EncountersApiExample {

    public static void main(String[] args) {
        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        try {
            Encounter result = apiInstance.getEncounter(encounterId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getEncounter");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *encounterId = encounterId_example; // 

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

// Returns enounter
[apiInstance getEncounterWith:encounterId
              completionHandler: ^(Encounter output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.EncountersApi()

var encounterId = encounterId_example; // {String} 


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

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

namespace Example
{
    public class getEncounterExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new EncountersApi();
            var encounterId = encounterId_example;  // String | 

            try
            {
                // Returns enounter
                Encounter result = apiInstance.getEncounter(encounterId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EncountersApi.getEncounter: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\EncountersApi();
$encounterId = encounterId_example; // String | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::EncountersApi->new();
my $encounterId = encounterId_example; # String | 

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.EncountersApi()
encounterId = encounterId_example # String | 

try: 
    # Returns enounter
    api_response = api_instance.get_encounter(encounterId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EncountersApi->getEncounter: %s\n" % e)

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

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

public class EncountersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        Integer faceId = 56; // Integer | 
        try {
            Face result = apiInstance.getFace(encounterId, faceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getFace");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EncountersApi;

public class EncountersApiExample {

    public static void main(String[] args) {
        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        Integer faceId = 56; // Integer | 
        try {
            Face result = apiInstance.getFace(encounterId, faceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getFace");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *encounterId = encounterId_example; // 
Integer *faceId = 56; // 

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

// Returns information about face
[apiInstance getFaceWith:encounterId
    faceId:faceId
              completionHandler: ^(Face output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.EncountersApi()

var encounterId = encounterId_example; // {String} 

var faceId = 56; // {Integer} 


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

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

namespace Example
{
    public class getFaceExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new EncountersApi();
            var encounterId = encounterId_example;  // String | 
            var faceId = 56;  // Integer | 

            try
            {
                // Returns information about face
                Face result = apiInstance.getFace(encounterId, faceId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EncountersApi.getFace: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\EncountersApi();
$encounterId = encounterId_example; // String | 
$faceId = 56; // Integer | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::EncountersApi->new();
my $encounterId = encounterId_example; # String | 
my $faceId = 56; # Integer | 

eval { 
    my $result = $api_instance->getFace(encounterId => $encounterId, faceId => $faceId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EncountersApi->getFace: $@\n";
}

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.EncountersApi()
encounterId = encounterId_example # String | 
faceId = 56 # Integer | 

try: 
    # Returns information about face
    api_response = api_instance.get_face(encounterId, faceId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EncountersApi->getFace: %s\n" % e)

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

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

public class EncountersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        Integer faceId = 56; // Integer | 
        try {
            FaceFeatures result = apiInstance.getFaceFeatures(encounterId, faceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getFaceFeatures");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EncountersApi;

public class EncountersApiExample {

    public static void main(String[] args) {
        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        Integer faceId = 56; // Integer | 
        try {
            FaceFeatures result = apiInstance.getFaceFeatures(encounterId, faceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getFaceFeatures");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *encounterId = encounterId_example; // 
Integer *faceId = 56; // 

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

// Returns face features
[apiInstance getFaceFeaturesWith:encounterId
    faceId:faceId
              completionHandler: ^(FaceFeatures output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.EncountersApi()

var encounterId = encounterId_example; // {String} 

var faceId = 56; // {Integer} 


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

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

namespace Example
{
    public class getFaceFeaturesExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new EncountersApi();
            var encounterId = encounterId_example;  // String | 
            var faceId = 56;  // Integer | 

            try
            {
                // Returns face features
                FaceFeatures result = apiInstance.getFaceFeatures(encounterId, faceId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EncountersApi.getFaceFeatures: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\EncountersApi();
$encounterId = encounterId_example; // String | 
$faceId = 56; // Integer | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::EncountersApi->new();
my $encounterId = encounterId_example; # String | 
my $faceId = 56; # Integer | 

eval { 
    my $result = $api_instance->getFaceFeatures(encounterId => $encounterId, faceId => $faceId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EncountersApi->getFaceFeatures: $@\n";
}

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.EncountersApi()
encounterId = encounterId_example # String | 
faceId = 56 # Integer | 

try: 
    # Returns face features
    api_response = api_instance.get_face_features(encounterId, faceId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EncountersApi->getFaceFeatures: %s\n" % e)

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

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

public class EncountersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        Integer faceId = 56; // Integer | 
        try {
            byte[] result = apiInstance.getFaceImage(encounterId, faceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getFaceImage");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EncountersApi;

public class EncountersApiExample {

    public static void main(String[] args) {
        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        Integer faceId = 56; // Integer | 
        try {
            byte[] result = apiInstance.getFaceImage(encounterId, faceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getFaceImage");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *encounterId = encounterId_example; // 
Integer *faceId = 56; // 

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

// Returns face image
[apiInstance getFaceImageWith:encounterId
    faceId:faceId
              completionHandler: ^(byte[] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.EncountersApi()

var encounterId = encounterId_example; // {String} 

var faceId = 56; // {Integer} 


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

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

namespace Example
{
    public class getFaceImageExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new EncountersApi();
            var encounterId = encounterId_example;  // String | 
            var faceId = 56;  // Integer | 

            try
            {
                // Returns face image
                byte[] result = apiInstance.getFaceImage(encounterId, faceId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EncountersApi.getFaceImage: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\EncountersApi();
$encounterId = encounterId_example; // String | 
$faceId = 56; // Integer | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::EncountersApi->new();
my $encounterId = encounterId_example; # String | 
my $faceId = 56; # Integer | 

eval { 
    my $result = $api_instance->getFaceImage(encounterId => $encounterId, faceId => $faceId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EncountersApi->getFaceImage: $@\n";
}

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.EncountersApi()
encounterId = encounterId_example # String | 
faceId = 56 # Integer | 

try: 
    # Returns face image
    api_response = api_instance.get_face_image(encounterId, faceId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EncountersApi->getFaceImage: %s\n" % e)

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

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

public class EncountersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        try {
            array[Face] result = apiInstance.getFaces(encounterId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getFaces");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EncountersApi;

public class EncountersApiExample {

    public static void main(String[] args) {
        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        try {
            array[Face] result = apiInstance.getFaces(encounterId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getFaces");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *encounterId = encounterId_example; // 

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

// Returns information about encounter faces
[apiInstance getFacesWith:encounterId
              completionHandler: ^(array[Face] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.EncountersApi()

var encounterId = encounterId_example; // {String} 


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

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

namespace Example
{
    public class getFacesExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new EncountersApi();
            var encounterId = encounterId_example;  // String | 

            try
            {
                // Returns information about encounter faces
                array[Face] result = apiInstance.getFaces(encounterId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EncountersApi.getFaces: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\EncountersApi();
$encounterId = encounterId_example; // String | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::EncountersApi->new();
my $encounterId = encounterId_example; # String | 

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.EncountersApi()
encounterId = encounterId_example # String | 

try: 
    # Returns information about encounter faces
    api_response = api_instance.get_faces(encounterId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EncountersApi->getFaces: %s\n" % e)

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

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

public class EncountersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        Integer fingerId = 56; // Integer | 
        try {
            Finger result = apiInstance.getFinger(encounterId, fingerId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getFinger");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EncountersApi;

public class EncountersApiExample {

    public static void main(String[] args) {
        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        Integer fingerId = 56; // Integer | 
        try {
            Finger result = apiInstance.getFinger(encounterId, fingerId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getFinger");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *encounterId = encounterId_example; // 
Integer *fingerId = 56; // 

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

// Returns information about finger
[apiInstance getFingerWith:encounterId
    fingerId:fingerId
              completionHandler: ^(Finger output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.EncountersApi()

var encounterId = encounterId_example; // {String} 

var fingerId = 56; // {Integer} 


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

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

namespace Example
{
    public class getFingerExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new EncountersApi();
            var encounterId = encounterId_example;  // String | 
            var fingerId = 56;  // Integer | 

            try
            {
                // Returns information about finger
                Finger result = apiInstance.getFinger(encounterId, fingerId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EncountersApi.getFinger: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\EncountersApi();
$encounterId = encounterId_example; // String | 
$fingerId = 56; // Integer | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::EncountersApi->new();
my $encounterId = encounterId_example; # String | 
my $fingerId = 56; # Integer | 

eval { 
    my $result = $api_instance->getFinger(encounterId => $encounterId, fingerId => $fingerId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EncountersApi->getFinger: $@\n";
}

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.EncountersApi()
encounterId = encounterId_example # String | 
fingerId = 56 # Integer | 

try: 
    # Returns information about finger
    api_response = api_instance.get_finger(encounterId, fingerId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EncountersApi->getFinger: %s\n" % e)

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

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

public class EncountersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        Integer fingerId = 56; // Integer | 
        Boolean all = true; // Boolean | Return all features (if any), otherwise only minutiae are returned
        try {
            FingerFeatures result = apiInstance.getFingerFeatures(encounterId, fingerId, all);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getFingerFeatures");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EncountersApi;

public class EncountersApiExample {

    public static void main(String[] args) {
        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        Integer fingerId = 56; // Integer | 
        Boolean all = true; // Boolean | Return all features (if any), otherwise only minutiae are returned
        try {
            FingerFeatures result = apiInstance.getFingerFeatures(encounterId, fingerId, all);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getFingerFeatures");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *encounterId = encounterId_example; // 
Integer *fingerId = 56; // 
Boolean *all = true; // Return all features (if any), otherwise only minutiae are returned (optional) (default to false)

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

// Returns finger features
[apiInstance getFingerFeaturesWith:encounterId
    fingerId:fingerId
    all:all
              completionHandler: ^(FingerFeatures output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.EncountersApi()

var encounterId = encounterId_example; // {String} 

var fingerId = 56; // {Integer} 

var opts = { 
  'all': true // {Boolean} Return all features (if any), otherwise only minutiae are returned
};

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

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

namespace Example
{
    public class getFingerFeaturesExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new EncountersApi();
            var encounterId = encounterId_example;  // String | 
            var fingerId = 56;  // Integer | 
            var all = true;  // Boolean | Return all features (if any), otherwise only minutiae are returned (optional)  (default to false)

            try
            {
                // Returns finger features
                FingerFeatures result = apiInstance.getFingerFeatures(encounterId, fingerId, all);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EncountersApi.getFingerFeatures: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\EncountersApi();
$encounterId = encounterId_example; // String | 
$fingerId = 56; // Integer | 
$all = true; // Boolean | Return all features (if any), otherwise only minutiae are returned

try {
    $result = $api_instance->getFingerFeatures($encounterId, $fingerId, $all);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling EncountersApi->getFingerFeatures: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::EncountersApi->new();
my $encounterId = encounterId_example; # String | 
my $fingerId = 56; # Integer | 
my $all = true; # Boolean | Return all features (if any), otherwise only minutiae are returned

eval { 
    my $result = $api_instance->getFingerFeatures(encounterId => $encounterId, fingerId => $fingerId, all => $all);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EncountersApi->getFingerFeatures: $@\n";
}

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.EncountersApi()
encounterId = encounterId_example # String | 
fingerId = 56 # Integer | 
all = true # Boolean | Return all features (if any), otherwise only minutiae are returned (optional) (default to false)

try: 
    # Returns finger features
    api_response = api_instance.get_finger_features(encounterId, fingerId, all=all)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EncountersApi->getFingerFeatures: %s\n" % e)

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

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

public class EncountersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        Integer fingerId = 56; // Integer | 
        String type = type_example; // String | 
        try {
            byte[] result = apiInstance.getFingerImage(encounterId, fingerId, type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getFingerImage");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EncountersApi;

public class EncountersApiExample {

    public static void main(String[] args) {
        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        Integer fingerId = 56; // Integer | 
        String type = type_example; // String | 
        try {
            byte[] result = apiInstance.getFingerImage(encounterId, fingerId, type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getFingerImage");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *encounterId = encounterId_example; // 
Integer *fingerId = 56; // 
String *type = type_example; //  (optional) (default to ORIGINAL)

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

// Returns fingerprint image
[apiInstance getFingerImageWith:encounterId
    fingerId:fingerId
    type:type
              completionHandler: ^(byte[] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.EncountersApi()

var encounterId = encounterId_example; // {String} 

var fingerId = 56; // {Integer} 

var opts = { 
  'type': type_example // {String} 
};

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

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

namespace Example
{
    public class getFingerImageExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new EncountersApi();
            var encounterId = encounterId_example;  // String | 
            var fingerId = 56;  // Integer | 
            var type = type_example;  // String |  (optional)  (default to ORIGINAL)

            try
            {
                // Returns fingerprint image
                byte[] result = apiInstance.getFingerImage(encounterId, fingerId, type);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EncountersApi.getFingerImage: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\EncountersApi();
$encounterId = encounterId_example; // String | 
$fingerId = 56; // Integer | 
$type = type_example; // String | 

try {
    $result = $api_instance->getFingerImage($encounterId, $fingerId, $type);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling EncountersApi->getFingerImage: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::EncountersApi->new();
my $encounterId = encounterId_example; # String | 
my $fingerId = 56; # Integer | 
my $type = type_example; # String | 

eval { 
    my $result = $api_instance->getFingerImage(encounterId => $encounterId, fingerId => $fingerId, type => $type);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EncountersApi->getFingerImage: $@\n";
}

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.EncountersApi()
encounterId = encounterId_example # String | 
fingerId = 56 # Integer | 
type = type_example # String |  (optional) (default to ORIGINAL)

try: 
    # Returns fingerprint image
    api_response = api_instance.get_finger_image(encounterId, fingerId, type=type)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EncountersApi->getFingerImage: %s\n" % e)

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

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

public class EncountersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        try {
            array[Finger] result = apiInstance.getFingers(encounterId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getFingers");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EncountersApi;

public class EncountersApiExample {

    public static void main(String[] args) {
        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        try {
            array[Finger] result = apiInstance.getFingers(encounterId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getFingers");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *encounterId = encounterId_example; // 

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

// Returns information about encounter fingers
[apiInstance getFingersWith:encounterId
              completionHandler: ^(array[Finger] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.EncountersApi()

var encounterId = encounterId_example; // {String} 


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

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

namespace Example
{
    public class getFingersExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new EncountersApi();
            var encounterId = encounterId_example;  // String | 

            try
            {
                // Returns information about encounter fingers
                array[Finger] result = apiInstance.getFingers(encounterId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EncountersApi.getFingers: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\EncountersApi();
$encounterId = encounterId_example; // String | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::EncountersApi->new();
my $encounterId = encounterId_example; # String | 

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.EncountersApi()
encounterId = encounterId_example # String | 

try: 
    # Returns information about encounter fingers
    api_response = api_instance.get_fingers(encounterId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EncountersApi->getFingers: %s\n" % e)

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

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

public class EncountersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        Integer irisId = 56; // Integer | 
        try {
            Iris result = apiInstance.getIris(encounterId, irisId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getIris");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EncountersApi;

public class EncountersApiExample {

    public static void main(String[] args) {
        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        Integer irisId = 56; // Integer | 
        try {
            Iris result = apiInstance.getIris(encounterId, irisId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getIris");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *encounterId = encounterId_example; // 
Integer *irisId = 56; // 

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

// Returns information about iris
[apiInstance getIrisWith:encounterId
    irisId:irisId
              completionHandler: ^(Iris output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.EncountersApi()

var encounterId = encounterId_example; // {String} 

var irisId = 56; // {Integer} 


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

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

namespace Example
{
    public class getIrisExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new EncountersApi();
            var encounterId = encounterId_example;  // String | 
            var irisId = 56;  // Integer | 

            try
            {
                // Returns information about iris
                Iris result = apiInstance.getIris(encounterId, irisId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EncountersApi.getIris: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\EncountersApi();
$encounterId = encounterId_example; // String | 
$irisId = 56; // Integer | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::EncountersApi->new();
my $encounterId = encounterId_example; # String | 
my $irisId = 56; # Integer | 

eval { 
    my $result = $api_instance->getIris(encounterId => $encounterId, irisId => $irisId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EncountersApi->getIris: $@\n";
}

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.EncountersApi()
encounterId = encounterId_example # String | 
irisId = 56 # Integer | 

try: 
    # Returns information about iris
    api_response = api_instance.get_iris(encounterId, irisId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EncountersApi->getIris: %s\n" % e)

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

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

public class EncountersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        Integer irisId = 56; // Integer | 
        try {
            byte[] result = apiInstance.getIrisImage(encounterId, irisId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getIrisImage");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EncountersApi;

public class EncountersApiExample {

    public static void main(String[] args) {
        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        Integer irisId = 56; // Integer | 
        try {
            byte[] result = apiInstance.getIrisImage(encounterId, irisId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getIrisImage");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *encounterId = encounterId_example; // 
Integer *irisId = 56; // 

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

// Returns iris image
[apiInstance getIrisImageWith:encounterId
    irisId:irisId
              completionHandler: ^(byte[] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.EncountersApi()

var encounterId = encounterId_example; // {String} 

var irisId = 56; // {Integer} 


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

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

namespace Example
{
    public class getIrisImageExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new EncountersApi();
            var encounterId = encounterId_example;  // String | 
            var irisId = 56;  // Integer | 

            try
            {
                // Returns iris image
                byte[] result = apiInstance.getIrisImage(encounterId, irisId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EncountersApi.getIrisImage: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\EncountersApi();
$encounterId = encounterId_example; // String | 
$irisId = 56; // Integer | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::EncountersApi->new();
my $encounterId = encounterId_example; # String | 
my $irisId = 56; # Integer | 

eval { 
    my $result = $api_instance->getIrisImage(encounterId => $encounterId, irisId => $irisId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EncountersApi->getIrisImage: $@\n";
}

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.EncountersApi()
encounterId = encounterId_example # String | 
irisId = 56 # Integer | 

try: 
    # Returns iris image
    api_response = api_instance.get_iris_image(encounterId, irisId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EncountersApi->getIrisImage: %s\n" % e)

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

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

public class EncountersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        try {
            array[Iris] result = apiInstance.getIrises(encounterId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getIrises");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EncountersApi;

public class EncountersApiExample {

    public static void main(String[] args) {
        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        try {
            array[Iris] result = apiInstance.getIrises(encounterId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getIrises");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *encounterId = encounterId_example; // 

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

// Returns information about encounter irises
[apiInstance getIrisesWith:encounterId
              completionHandler: ^(array[Iris] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.EncountersApi()

var encounterId = encounterId_example; // {String} 


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

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

namespace Example
{
    public class getIrisesExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new EncountersApi();
            var encounterId = encounterId_example;  // String | 

            try
            {
                // Returns information about encounter irises
                array[Iris] result = apiInstance.getIrises(encounterId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EncountersApi.getIrises: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\EncountersApi();
$encounterId = encounterId_example; // String | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::EncountersApi->new();
my $encounterId = encounterId_example; # String | 

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.EncountersApi()
encounterId = encounterId_example # String | 

try: 
    # Returns information about encounter irises
    api_response = api_instance.get_irises(encounterId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EncountersApi->getIrises: %s\n" % e)

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

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

public class EncountersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        Integer palmId = 56; // Integer | 
        try {
            Palm result = apiInstance.getPalm(encounterId, palmId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getPalm");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EncountersApi;

public class EncountersApiExample {

    public static void main(String[] args) {
        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        Integer palmId = 56; // Integer | 
        try {
            Palm result = apiInstance.getPalm(encounterId, palmId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getPalm");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *encounterId = encounterId_example; // 
Integer *palmId = 56; // 

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

// Returns information about palm
[apiInstance getPalmWith:encounterId
    palmId:palmId
              completionHandler: ^(Palm output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.EncountersApi()

var encounterId = encounterId_example; // {String} 

var palmId = 56; // {Integer} 


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

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

namespace Example
{
    public class getPalmExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new EncountersApi();
            var encounterId = encounterId_example;  // String | 
            var palmId = 56;  // Integer | 

            try
            {
                // Returns information about palm
                Palm result = apiInstance.getPalm(encounterId, palmId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EncountersApi.getPalm: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\EncountersApi();
$encounterId = encounterId_example; // String | 
$palmId = 56; // Integer | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::EncountersApi->new();
my $encounterId = encounterId_example; # String | 
my $palmId = 56; # Integer | 

eval { 
    my $result = $api_instance->getPalm(encounterId => $encounterId, palmId => $palmId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EncountersApi->getPalm: $@\n";
}

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.EncountersApi()
encounterId = encounterId_example # String | 
palmId = 56 # Integer | 

try: 
    # Returns information about palm
    api_response = api_instance.get_palm(encounterId, palmId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EncountersApi->getPalm: %s\n" % e)

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

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

public class EncountersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        Integer palmId = 56; // Integer | 
        try {
            PalmFeatures result = apiInstance.getPalmFeatures(encounterId, palmId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getPalmFeatures");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EncountersApi;

public class EncountersApiExample {

    public static void main(String[] args) {
        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        Integer palmId = 56; // Integer | 
        try {
            PalmFeatures result = apiInstance.getPalmFeatures(encounterId, palmId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getPalmFeatures");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *encounterId = encounterId_example; // 
Integer *palmId = 56; // 

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

// Returns palm features
[apiInstance getPalmFeaturesWith:encounterId
    palmId:palmId
              completionHandler: ^(PalmFeatures output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.EncountersApi()

var encounterId = encounterId_example; // {String} 

var palmId = 56; // {Integer} 


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

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

namespace Example
{
    public class getPalmFeaturesExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new EncountersApi();
            var encounterId = encounterId_example;  // String | 
            var palmId = 56;  // Integer | 

            try
            {
                // Returns palm features
                PalmFeatures result = apiInstance.getPalmFeatures(encounterId, palmId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EncountersApi.getPalmFeatures: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\EncountersApi();
$encounterId = encounterId_example; // String | 
$palmId = 56; // Integer | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::EncountersApi->new();
my $encounterId = encounterId_example; # String | 
my $palmId = 56; # Integer | 

eval { 
    my $result = $api_instance->getPalmFeatures(encounterId => $encounterId, palmId => $palmId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EncountersApi->getPalmFeatures: $@\n";
}

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.EncountersApi()
encounterId = encounterId_example # String | 
palmId = 56 # Integer | 

try: 
    # Returns palm features
    api_response = api_instance.get_palm_features(encounterId, palmId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EncountersApi->getPalmFeatures: %s\n" % e)

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

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

public class EncountersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        Integer palmId = 56; // Integer | 
        try {
            byte[] result = apiInstance.getPalmImage(encounterId, palmId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getPalmImage");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EncountersApi;

public class EncountersApiExample {

    public static void main(String[] args) {
        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        Integer palmId = 56; // Integer | 
        try {
            byte[] result = apiInstance.getPalmImage(encounterId, palmId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getPalmImage");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *encounterId = encounterId_example; // 
Integer *palmId = 56; // 

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

// Returns palm image
[apiInstance getPalmImageWith:encounterId
    palmId:palmId
              completionHandler: ^(byte[] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.EncountersApi()

var encounterId = encounterId_example; // {String} 

var palmId = 56; // {Integer} 


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

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

namespace Example
{
    public class getPalmImageExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new EncountersApi();
            var encounterId = encounterId_example;  // String | 
            var palmId = 56;  // Integer | 

            try
            {
                // Returns palm image
                byte[] result = apiInstance.getPalmImage(encounterId, palmId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EncountersApi.getPalmImage: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\EncountersApi();
$encounterId = encounterId_example; // String | 
$palmId = 56; // Integer | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::EncountersApi->new();
my $encounterId = encounterId_example; # String | 
my $palmId = 56; # Integer | 

eval { 
    my $result = $api_instance->getPalmImage(encounterId => $encounterId, palmId => $palmId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EncountersApi->getPalmImage: $@\n";
}

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.EncountersApi()
encounterId = encounterId_example # String | 
palmId = 56 # Integer | 

try: 
    # Returns palm image
    api_response = api_instance.get_palm_image(encounterId, palmId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EncountersApi->getPalmImage: %s\n" % e)

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

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

public class EncountersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        try {
            array[Palm] result = apiInstance.getPalms(encounterId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getPalms");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EncountersApi;

public class EncountersApiExample {

    public static void main(String[] args) {
        EncountersApi apiInstance = new EncountersApi();
        String encounterId = encounterId_example; // String | 
        try {
            array[Palm] result = apiInstance.getPalms(encounterId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EncountersApi#getPalms");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *encounterId = encounterId_example; // 

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

// Returns information about encounter palms
[apiInstance getPalmsWith:encounterId
              completionHandler: ^(array[Palm] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.EncountersApi()

var encounterId = encounterId_example; // {String} 


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

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

namespace Example
{
    public class getPalmsExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new EncountersApi();
            var encounterId = encounterId_example;  // String | 

            try
            {
                // Returns information about encounter palms
                array[Palm] result = apiInstance.getPalms(encounterId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EncountersApi.getPalms: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\EncountersApi();
$encounterId = encounterId_example; // String | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::EncountersApi->new();
my $encounterId = encounterId_example; # String | 

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.EncountersApi()
encounterId = encounterId_example # String | 

try: 
    # Returns information about encounter palms
    api_response = api_instance.get_palms(encounterId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EncountersApi->getPalms: %s\n" % e)

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

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

public class HitsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        HitsApi apiInstance = new HitsApi();
        String encounterId = encounterId_example; // String | 
        String hitId = hitId_example; // String | 
        Integer fingerId = 56; // Integer | 
        try {
            array[FingerMatchingDetails] result = apiInstance.getFingerMatchingDetails(encounterId, hitId, fingerId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HitsApi#getFingerMatchingDetails");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.HitsApi;

public class HitsApiExample {

    public static void main(String[] args) {
        HitsApi apiInstance = new HitsApi();
        String encounterId = encounterId_example; // String | 
        String hitId = hitId_example; // String | 
        Integer fingerId = 56; // Integer | 
        try {
            array[FingerMatchingDetails] result = apiInstance.getFingerMatchingDetails(encounterId, hitId, fingerId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HitsApi#getFingerMatchingDetails");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *encounterId = encounterId_example; // 
String *hitId = hitId_example; // 
Integer *fingerId = 56; // 

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

// Returns hits' finger matching details
[apiInstance getFingerMatchingDetailsWith:encounterId
    hitId:hitId
    fingerId:fingerId
              completionHandler: ^(array[FingerMatchingDetails] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.HitsApi()

var encounterId = encounterId_example; // {String} 

var hitId = hitId_example; // {String} 

var fingerId = 56; // {Integer} 


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

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

namespace Example
{
    public class getFingerMatchingDetailsExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new HitsApi();
            var encounterId = encounterId_example;  // String | 
            var hitId = hitId_example;  // String | 
            var fingerId = 56;  // Integer | 

            try
            {
                // Returns hits' finger matching details
                array[FingerMatchingDetails] result = apiInstance.getFingerMatchingDetails(encounterId, hitId, fingerId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HitsApi.getFingerMatchingDetails: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\HitsApi();
$encounterId = encounterId_example; // String | 
$hitId = hitId_example; // String | 
$fingerId = 56; // Integer | 

try {
    $result = $api_instance->getFingerMatchingDetails($encounterId, $hitId, $fingerId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HitsApi->getFingerMatchingDetails: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::HitsApi->new();
my $encounterId = encounterId_example; # String | 
my $hitId = hitId_example; # String | 
my $fingerId = 56; # Integer | 

eval { 
    my $result = $api_instance->getFingerMatchingDetails(encounterId => $encounterId, hitId => $hitId, fingerId => $fingerId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HitsApi->getFingerMatchingDetails: $@\n";
}

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.HitsApi()
encounterId = encounterId_example # String | 
hitId = hitId_example # String | 
fingerId = 56 # Integer | 

try: 
    # Returns hits' finger matching details
    api_response = api_instance.get_finger_matching_details(encounterId, hitId, fingerId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HitsApi->getFingerMatchingDetails: %s\n" % e)

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

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

public class HitsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        HitsApi apiInstance = new HitsApi();
        String encounterId = encounterId_example; // String | 
        String hitId = hitId_example; // String | 
        try {
            Hit result = apiInstance.getHit(encounterId, hitId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HitsApi#getHit");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.HitsApi;

public class HitsApiExample {

    public static void main(String[] args) {
        HitsApi apiInstance = new HitsApi();
        String encounterId = encounterId_example; // String | 
        String hitId = hitId_example; // String | 
        try {
            Hit result = apiInstance.getHit(encounterId, hitId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HitsApi#getHit");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *encounterId = encounterId_example; // 
String *hitId = hitId_example; // 

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

// Returns hit
[apiInstance getHitWith:encounterId
    hitId:hitId
              completionHandler: ^(Hit output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.HitsApi()

var encounterId = encounterId_example; // {String} 

var hitId = hitId_example; // {String} 


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

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

namespace Example
{
    public class getHitExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new HitsApi();
            var encounterId = encounterId_example;  // String | 
            var hitId = hitId_example;  // String | 

            try
            {
                // Returns hit
                Hit result = apiInstance.getHit(encounterId, hitId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HitsApi.getHit: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\HitsApi();
$encounterId = encounterId_example; // String | 
$hitId = hitId_example; // String | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::HitsApi->new();
my $encounterId = encounterId_example; # String | 
my $hitId = hitId_example; # String | 

eval { 
    my $result = $api_instance->getHit(encounterId => $encounterId, hitId => $hitId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HitsApi->getHit: $@\n";
}

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.HitsApi()
encounterId = encounterId_example # String | 
hitId = hitId_example # String | 

try: 
    # Returns hit
    api_response = api_instance.get_hit(encounterId, hitId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HitsApi->getHit: %s\n" % e)

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

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

public class HitsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        HitsApi apiInstance = new HitsApi();
        String encounterId = encounterId_example; // String | 
        try {
            array[Hit] result = apiInstance.getHits(encounterId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HitsApi#getHits");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.HitsApi;

public class HitsApiExample {

    public static void main(String[] args) {
        HitsApi apiInstance = new HitsApi();
        String encounterId = encounterId_example; // String | 
        try {
            array[Hit] result = apiInstance.getHits(encounterId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HitsApi#getHits");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *encounterId = encounterId_example; // 

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

// Returns hits for enounter
[apiInstance getHitsWith:encounterId
              completionHandler: ^(array[Hit] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.HitsApi()

var encounterId = encounterId_example; // {String} 


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

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

namespace Example
{
    public class getHitsExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new HitsApi();
            var encounterId = encounterId_example;  // String | 

            try
            {
                // Returns hits for enounter
                array[Hit] result = apiInstance.getHits(encounterId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HitsApi.getHits: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\HitsApi();
$encounterId = encounterId_example; // String | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::HitsApi->new();
my $encounterId = encounterId_example; # String | 

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.HitsApi()
encounterId = encounterId_example # String | 

try: 
    # Returns hits for enounter
    api_response = api_instance.get_hits(encounterId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HitsApi->getHits: %s\n" % e)

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

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

public class HitsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        HitsApi apiInstance = new HitsApi();
        String encounterId = encounterId_example; // String | 
        String hitId = hitId_example; // String | 
        Integer palmId = 56; // Integer | 
        try {
            array[PalmMatchingDetails] result = apiInstance.getPalmMatchingDetails(encounterId, hitId, palmId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HitsApi#getPalmMatchingDetails");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.HitsApi;

public class HitsApiExample {

    public static void main(String[] args) {
        HitsApi apiInstance = new HitsApi();
        String encounterId = encounterId_example; // String | 
        String hitId = hitId_example; // String | 
        Integer palmId = 56; // Integer | 
        try {
            array[PalmMatchingDetails] result = apiInstance.getPalmMatchingDetails(encounterId, hitId, palmId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HitsApi#getPalmMatchingDetails");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *encounterId = encounterId_example; // 
String *hitId = hitId_example; // 
Integer *palmId = 56; // 

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

// Returns hits' palm matching details
[apiInstance getPalmMatchingDetailsWith:encounterId
    hitId:hitId
    palmId:palmId
              completionHandler: ^(array[PalmMatchingDetails] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.HitsApi()

var encounterId = encounterId_example; // {String} 

var hitId = hitId_example; // {String} 

var palmId = 56; // {Integer} 


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

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

namespace Example
{
    public class getPalmMatchingDetailsExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new HitsApi();
            var encounterId = encounterId_example;  // String | 
            var hitId = hitId_example;  // String | 
            var palmId = 56;  // Integer | 

            try
            {
                // Returns hits' palm matching details
                array[PalmMatchingDetails] result = apiInstance.getPalmMatchingDetails(encounterId, hitId, palmId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HitsApi.getPalmMatchingDetails: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\HitsApi();
$encounterId = encounterId_example; // String | 
$hitId = hitId_example; // String | 
$palmId = 56; // Integer | 

try {
    $result = $api_instance->getPalmMatchingDetails($encounterId, $hitId, $palmId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HitsApi->getPalmMatchingDetails: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::HitsApi->new();
my $encounterId = encounterId_example; # String | 
my $hitId = hitId_example; # String | 
my $palmId = 56; # Integer | 

eval { 
    my $result = $api_instance->getPalmMatchingDetails(encounterId => $encounterId, hitId => $hitId, palmId => $palmId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HitsApi->getPalmMatchingDetails: $@\n";
}

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.HitsApi()
encounterId = encounterId_example # String | 
hitId = hitId_example # String | 
palmId = 56 # Integer | 

try: 
    # Returns hits' palm matching details
    api_response = api_instance.get_palm_matching_details(encounterId, hitId, palmId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HitsApi->getPalmMatchingDetails: %s\n" % e)

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

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

public class ParametersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        ParametersApi apiInstance = new ParametersApi();
        try {
            'Integer' result = apiInstance.getDuplicateCheckLowerThreshold();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParametersApi#getDuplicateCheckLowerThreshold");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParametersApi;

public class ParametersApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


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

// Returns current lower duplicate check threshold
[apiInstance getDuplicateCheckLowerThresholdWithCompletionHandler: 
              ^('Integer' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.ParametersApi()

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

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

namespace Example
{
    public class getDuplicateCheckLowerThresholdExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ParametersApi();

            try
            {
                // Returns current lower duplicate check threshold
                'Integer' result = apiInstance.getDuplicateCheckLowerThreshold();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParametersApi.getDuplicateCheckLowerThreshold: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

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

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try: 
    # Returns current lower duplicate check threshold
    api_response = api_instance.get_duplicate_check_lower_threshold()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParametersApi->getDuplicateCheckLowerThreshold: %s\n" % e)

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

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

public class ParametersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        ParametersApi apiInstance = new ParametersApi();
        try {
            'Integer' result = apiInstance.getDuplicateCheckTopThreshold();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParametersApi#getDuplicateCheckTopThreshold");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParametersApi;

public class ParametersApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


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

// Returns current top duplicate check threshold
[apiInstance getDuplicateCheckTopThresholdWithCompletionHandler: 
              ^('Integer' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.ParametersApi()

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

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

namespace Example
{
    public class getDuplicateCheckTopThresholdExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ParametersApi();

            try
            {
                // Returns current top duplicate check threshold
                'Integer' result = apiInstance.getDuplicateCheckTopThreshold();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParametersApi.getDuplicateCheckTopThreshold: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

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

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try: 
    # Returns current top duplicate check threshold
    api_response = api_instance.get_duplicate_check_top_threshold()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParametersApi->getDuplicateCheckTopThreshold: %s\n" % e)

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

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

public class ParametersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        ParametersApi apiInstance = new ParametersApi();
        try {
            'Integer' result = apiInstance.getIdentificationThreshold();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParametersApi#getIdentificationThreshold");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParametersApi;

public class ParametersApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


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

// Returns current identification threshold
[apiInstance getIdentificationThresholdWithCompletionHandler: 
              ^('Integer' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.ParametersApi()

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

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

namespace Example
{
    public class getIdentificationThresholdExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ParametersApi();

            try
            {
                // Returns current identification threshold
                'Integer' result = apiInstance.getIdentificationThreshold();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParametersApi.getIdentificationThreshold: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

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

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try: 
    # Returns current identification threshold
    api_response = api_instance.get_identification_threshold()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParametersApi->getIdentificationThreshold: %s\n" % e)

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

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

public class ParametersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        ParametersApi apiInstance = new ParametersApi();
        array[String] names = ; // array[String] | 
        try {
            array[Parameter] result = apiInstance.getParameters(names);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParametersApi#getParameters");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParametersApi;

public class ParametersApiExample {

    public static void main(String[] args) {
        ParametersApi apiInstance = new ParametersApi();
        array[String] names = ; // array[String] | 
        try {
            array[Parameter] result = apiInstance.getParameters(names);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParametersApi#getParameters");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

array[String] *names = ; //  (optional)

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

// Returns parameter values for provided parameter names
[apiInstance getParametersWith:names
              completionHandler: ^(array[Parameter] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.ParametersApi()

var opts = { 
  'names':  // {array[String]} 
};

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

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

namespace Example
{
    public class getParametersExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ParametersApi();
            var names = new array[String](); // array[String] |  (optional) 

            try
            {
                // Returns parameter values for provided parameter names
                array[Parameter] result = apiInstance.getParameters(names);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParametersApi.getParameters: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\ParametersApi();
$names = ; // array[String] | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::ParametersApi->new();
my $names = []; # array[String] | 

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.ParametersApi()
names =  # array[String] |  (optional)

try: 
    # Returns parameter values for provided parameter names
    api_response = api_instance.get_parameters(names=names)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParametersApi->getParameters: %s\n" % e)

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

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

public class ParametersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        ParametersApi apiInstance = new ParametersApi();
        try {
            'Integer' result = apiInstance.getVerificationThreshold();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParametersApi#getVerificationThreshold");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParametersApi;

public class ParametersApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


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

// Returns current verification threshold
[apiInstance getVerificationThresholdWithCompletionHandler: 
              ^('Integer' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.ParametersApi()

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

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

namespace Example
{
    public class getVerificationThresholdExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ParametersApi();

            try
            {
                // Returns current verification threshold
                'Integer' result = apiInstance.getVerificationThreshold();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParametersApi.getVerificationThreshold: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

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

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try: 
    # Returns current verification threshold
    api_response = api_instance.get_verification_threshold()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParametersApi->getVerificationThreshold: %s\n" % e)

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

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

public class ParametersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        ParametersApi apiInstance = new ParametersApi();
        try {
            Task result = apiInstance.resetDuplicateCheckLowerThreshold();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParametersApi#resetDuplicateCheckLowerThreshold");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParametersApi;

public class ParametersApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


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

// Resets lower duplicate check threshold to system default
[apiInstance resetDuplicateCheckLowerThresholdWithCompletionHandler: 
              ^(Task output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.ParametersApi()

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

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

namespace Example
{
    public class resetDuplicateCheckLowerThresholdExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ParametersApi();

            try
            {
                // Resets lower duplicate check threshold to system default
                Task result = apiInstance.resetDuplicateCheckLowerThreshold();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParametersApi.resetDuplicateCheckLowerThreshold: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

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

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try: 
    # Resets lower duplicate check threshold to system default
    api_response = api_instance.reset_duplicate_check_lower_threshold()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParametersApi->resetDuplicateCheckLowerThreshold: %s\n" % e)

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

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

public class ParametersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        ParametersApi apiInstance = new ParametersApi();
        try {
            Task result = apiInstance.resetDuplicateCheckTopThreshold();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParametersApi#resetDuplicateCheckTopThreshold");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParametersApi;

public class ParametersApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


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

// Resets top duplicate check threshold to system default
[apiInstance resetDuplicateCheckTopThresholdWithCompletionHandler: 
              ^(Task output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.ParametersApi()

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

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

namespace Example
{
    public class resetDuplicateCheckTopThresholdExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ParametersApi();

            try
            {
                // Resets top duplicate check threshold to system default
                Task result = apiInstance.resetDuplicateCheckTopThreshold();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParametersApi.resetDuplicateCheckTopThreshold: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

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

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try: 
    # Resets top duplicate check threshold to system default
    api_response = api_instance.reset_duplicate_check_top_threshold()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParametersApi->resetDuplicateCheckTopThreshold: %s\n" % e)

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

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

public class ParametersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        ParametersApi apiInstance = new ParametersApi();
        try {
            Task result = apiInstance.resetIdentificationParameters();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParametersApi#resetIdentificationParameters");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParametersApi;

public class ParametersApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


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

// Resets identification threshold to system default
[apiInstance resetIdentificationParametersWithCompletionHandler: 
              ^(Task output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.ParametersApi()

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

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

namespace Example
{
    public class resetIdentificationParametersExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ParametersApi();

            try
            {
                // Resets identification threshold to system default
                Task result = apiInstance.resetIdentificationParameters();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParametersApi.resetIdentificationParameters: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

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

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try: 
    # Resets identification threshold to system default
    api_response = api_instance.reset_identification_parameters()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParametersApi->resetIdentificationParameters: %s\n" % e)

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

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

public class ParametersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        ParametersApi apiInstance = new ParametersApi();
        try {
            Task result = apiInstance.resetVerificationParameters();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParametersApi#resetVerificationParameters");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParametersApi;

public class ParametersApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


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

// Resets verification threshold to system default
[apiInstance resetVerificationParametersWithCompletionHandler: 
              ^(Task output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.ParametersApi()

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

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

namespace Example
{
    public class resetVerificationParametersExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ParametersApi();

            try
            {
                // Resets verification threshold to system default
                Task result = apiInstance.resetVerificationParameters();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParametersApi.resetVerificationParameters: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

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

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try: 
    # Resets verification threshold to system default
    api_response = api_instance.reset_verification_parameters()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParametersApi->resetVerificationParameters: %s\n" % e)

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

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

public class ParametersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        ParametersApi apiInstance = new ParametersApi();
        Integer body = 56; // Integer | 
        try {
            Task result = apiInstance.setDuplicateCheckLowerThreshold(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParametersApi#setDuplicateCheckLowerThreshold");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParametersApi;

public class ParametersApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

Integer *body = 56; // 

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

// Sets new lower duplicate check threshold
[apiInstance setDuplicateCheckLowerThresholdWith:body
              completionHandler: ^(Task output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.ParametersApi()

var body = 56; // {Integer} 


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

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

namespace Example
{
    public class setDuplicateCheckLowerThresholdExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ParametersApi();
            var body = 56;  // Integer | 

            try
            {
                // Sets new lower duplicate check threshold
                Task result = apiInstance.setDuplicateCheckLowerThreshold(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParametersApi.setDuplicateCheckLowerThreshold: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\ParametersApi();
$body = 56; // Integer | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try: 
    # Sets new lower duplicate check threshold
    api_response = api_instance.set_duplicate_check_lower_threshold(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParametersApi->setDuplicateCheckLowerThreshold: %s\n" % e)

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

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

public class ParametersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        ParametersApi apiInstance = new ParametersApi();
        Integer body = 56; // Integer | 
        try {
            Task result = apiInstance.setDuplicateCheckTopThreshold(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParametersApi#setDuplicateCheckTopThreshold");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParametersApi;

public class ParametersApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

Integer *body = 56; // 

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

// Sets new top duplicate check threshold
[apiInstance setDuplicateCheckTopThresholdWith:body
              completionHandler: ^(Task output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.ParametersApi()

var body = 56; // {Integer} 


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

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

namespace Example
{
    public class setDuplicateCheckTopThresholdExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ParametersApi();
            var body = 56;  // Integer | 

            try
            {
                // Sets new top duplicate check threshold
                Task result = apiInstance.setDuplicateCheckTopThreshold(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParametersApi.setDuplicateCheckTopThreshold: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\ParametersApi();
$body = 56; // Integer | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try: 
    # Sets new top duplicate check threshold
    api_response = api_instance.set_duplicate_check_top_threshold(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParametersApi->setDuplicateCheckTopThreshold: %s\n" % e)

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

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

public class ParametersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        ParametersApi apiInstance = new ParametersApi();
        Integer body = 56; // Integer | 
        try {
            Task result = apiInstance.setIdentificationParameters(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParametersApi#setIdentificationParameters");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParametersApi;

public class ParametersApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

Integer *body = 56; // 

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

// Sets new identification threshold
[apiInstance setIdentificationParametersWith:body
              completionHandler: ^(Task output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.ParametersApi()

var body = 56; // {Integer} 


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

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

namespace Example
{
    public class setIdentificationParametersExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ParametersApi();
            var body = 56;  // Integer | 

            try
            {
                // Sets new identification threshold
                Task result = apiInstance.setIdentificationParameters(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParametersApi.setIdentificationParameters: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\ParametersApi();
$body = 56; // Integer | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try: 
    # Sets new identification threshold
    api_response = api_instance.set_identification_parameters(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParametersApi->setIdentificationParameters: %s\n" % e)

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

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

public class ParametersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        ParametersApi apiInstance = new ParametersApi();
        array[Parameter] body = ; // array[Parameter] | 
        try {
            Task result = apiInstance.setParameters(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParametersApi#setParameters");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParametersApi;

public class ParametersApiExample {

    public static void main(String[] args) {
        ParametersApi apiInstance = new ParametersApi();
        array[Parameter] body = ; // array[Parameter] | 
        try {
            Task result = apiInstance.setParameters(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParametersApi#setParameters");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

array[Parameter] *body = ; //  (optional)

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

// Sets provided parameters
[apiInstance setParametersWith:body
              completionHandler: ^(Task output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.ParametersApi()

var opts = { 
  'body':  // {array[Parameter]} 
};

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

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

namespace Example
{
    public class setParametersExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ParametersApi();
            var body = new array[Parameter](); // array[Parameter] |  (optional) 

            try
            {
                // Sets provided parameters
                Task result = apiInstance.setParameters(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParametersApi.setParameters: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\ParametersApi();
$body = ; // array[Parameter] | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::ParametersApi->new();
my $body = [WWW::SwaggerClient::Object::array[Parameter]->new()]; # array[Parameter] | 

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.ParametersApi()
body =  # array[Parameter] |  (optional)

try: 
    # Sets provided parameters
    api_response = api_instance.set_parameters(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParametersApi->setParameters: %s\n" % e)

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

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

public class ParametersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        ParametersApi apiInstance = new ParametersApi();
        Integer body = 56; // Integer | 
        try {
            Task result = apiInstance.setVerificationParameters(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParametersApi#setVerificationParameters");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParametersApi;

public class ParametersApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

Integer *body = 56; // 

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

// Sets new verification threshold
[apiInstance setVerificationParametersWith:body
              completionHandler: ^(Task output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.ParametersApi()

var body = 56; // {Integer} 


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

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

namespace Example
{
    public class setVerificationParametersExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ParametersApi();
            var body = 56;  // Integer | 

            try
            {
                // Sets new verification threshold
                Task result = apiInstance.setVerificationParameters(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParametersApi.setVerificationParameters: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\ParametersApi();
$body = 56; // Integer | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try: 
    # Sets new verification threshold
    api_response = api_instance.set_verification_parameters(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ParametersApi->setVerificationParameters: %s\n" % e)

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

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

public class ScriptsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        ScriptsApi apiInstance = new ScriptsApi();
        try {
            Script result = apiInstance.getMasterEncounterSelector();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScriptsApi#getMasterEncounterSelector");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ScriptsApi;

public class ScriptsApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


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

// Returns master encounter selector script
[apiInstance getMasterEncounterSelectorWithCompletionHandler: 
              ^(Script output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.ScriptsApi()

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

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

namespace Example
{
    public class getMasterEncounterSelectorExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ScriptsApi();

            try
            {
                // Returns master encounter selector script
                Script result = apiInstance.getMasterEncounterSelector();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ScriptsApi.getMasterEncounterSelector: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

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

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try: 
    # Returns master encounter selector script
    api_response = api_instance.get_master_encounter_selector()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ScriptsApi->getMasterEncounterSelector: %s\n" % e)

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

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

public class ScriptsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        ScriptsApi apiInstance = new ScriptsApi();
        try {
            Script result = apiInstance.getMatchingResultPredicate();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScriptsApi#getMatchingResultPredicate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ScriptsApi;

public class ScriptsApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


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

// Returns matching result filtering script
[apiInstance getMatchingResultPredicateWithCompletionHandler: 
              ^(Script output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.ScriptsApi()

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

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

namespace Example
{
    public class getMatchingResultPredicateExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ScriptsApi();

            try
            {
                // Returns matching result filtering script
                Script result = apiInstance.getMatchingResultPredicate();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ScriptsApi.getMatchingResultPredicate: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

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

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try: 
    # Returns matching result filtering script
    api_response = api_instance.get_matching_result_predicate()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ScriptsApi->getMatchingResultPredicate: %s\n" % e)

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

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

public class ScriptsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        ScriptsApi apiInstance = new ScriptsApi();
        Script body = ; // Script | 
        try {
            Task result = apiInstance.setMasterEncounterSelector(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScriptsApi#setMasterEncounterSelector");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ScriptsApi;

public class ScriptsApiExample {

    public static void main(String[] args) {
        ScriptsApi apiInstance = new ScriptsApi();
        Script body = ; // Script | 
        try {
            Task result = apiInstance.setMasterEncounterSelector(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScriptsApi#setMasterEncounterSelector");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

Script *body = ; // 

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

// Sets new master encounter selector script
[apiInstance setMasterEncounterSelectorWith:body
              completionHandler: ^(Task output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.ScriptsApi()

var body = ; // {Script} 


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

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

namespace Example
{
    public class setMasterEncounterSelectorExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ScriptsApi();
            var body = new Script(); // Script | 

            try
            {
                // Sets new master encounter selector script
                Task result = apiInstance.setMasterEncounterSelector(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ScriptsApi.setMasterEncounterSelector: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\ScriptsApi();
$body = ; // Script | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.ScriptsApi()
body =  # Script | 

try: 
    # Sets new master encounter selector script
    api_response = api_instance.set_master_encounter_selector(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ScriptsApi->setMasterEncounterSelector: %s\n" % e)

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

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

public class ScriptsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        ScriptsApi apiInstance = new ScriptsApi();
        Script body = ; // Script | 
        try {
            Task result = apiInstance.setMatchingResultPredicate(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScriptsApi#setMatchingResultPredicate");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ScriptsApi;

public class ScriptsApiExample {

    public static void main(String[] args) {
        ScriptsApi apiInstance = new ScriptsApi();
        Script body = ; // Script | 
        try {
            Task result = apiInstance.setMatchingResultPredicate(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ScriptsApi#setMatchingResultPredicate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

Script *body = ; // 

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

// Sets new matching result filtering script
[apiInstance setMatchingResultPredicateWith:body
              completionHandler: ^(Task output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.ScriptsApi()

var body = ; // {Script} 


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

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

namespace Example
{
    public class setMatchingResultPredicateExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new ScriptsApi();
            var body = new Script(); // Script | 

            try
            {
                // Sets new matching result filtering script
                Task result = apiInstance.setMatchingResultPredicate(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ScriptsApi.setMatchingResultPredicate: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\ScriptsApi();
$body = ; // Script | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.ScriptsApi()
body =  # Script | 

try: 
    # Sets new matching result filtering script
    api_response = api_instance.set_matching_result_predicate(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ScriptsApi->setMatchingResultPredicate: %s\n" % e)

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

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

public class SubjectsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        SubjectsApi apiInstance = new SubjectsApi();
        String id = id_example; // String | Subject ID
        Boolean all = true; // Boolean | Return not only currently enrolled encounters, but also deleted ones and those that are not yet completely processed
        try {
            SubjectEx result = apiInstance.getSubject(id, all);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SubjectsApi#getSubject");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SubjectsApi;

public class SubjectsApiExample {

    public static void main(String[] args) {
        SubjectsApi apiInstance = new SubjectsApi();
        String id = id_example; // String | Subject ID
        Boolean all = true; // Boolean | Return not only currently enrolled encounters, but also deleted ones and those that are not yet completely processed
        try {
            SubjectEx result = apiInstance.getSubject(id, all);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SubjectsApi#getSubject");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *id = id_example; // Subject ID
Boolean *all = true; // Return not only currently enrolled encounters, but also deleted ones and those that are not yet completely processed (optional) (default to false)

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

// Returns information about subject
[apiInstance getSubjectWith:id
    all:all
              completionHandler: ^(SubjectEx output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.SubjectsApi()

var id = id_example; // {String} Subject ID

var opts = { 
  'all': true // {Boolean} Return not only currently enrolled encounters, but also deleted ones and those that are not yet completely processed
};

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

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

namespace Example
{
    public class getSubjectExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new SubjectsApi();
            var id = id_example;  // String | Subject ID
            var all = true;  // Boolean | Return not only currently enrolled encounters, but also deleted ones and those that are not yet completely processed (optional)  (default to false)

            try
            {
                // Returns information about subject
                SubjectEx result = apiInstance.getSubject(id, all);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SubjectsApi.getSubject: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\SubjectsApi();
$id = id_example; // String | Subject ID
$all = true; // Boolean | Return not only currently enrolled encounters, but also deleted ones and those that are not yet completely processed

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::SubjectsApi->new();
my $id = id_example; # String | Subject ID
my $all = true; # Boolean | Return not only currently enrolled encounters, but also deleted ones and those that are not yet completely processed

eval { 
    my $result = $api_instance->getSubject(id => $id, all => $all);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SubjectsApi->getSubject: $@\n";
}

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.SubjectsApi()
id = id_example # String | Subject ID
all = true # Boolean | Return not only currently enrolled encounters, but also deleted ones and those that are not yet completely processed (optional) (default to false)

try: 
    # Returns information about subject
    api_response = api_instance.get_subject(id, all=all)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SubjectsApi->getSubject: %s\n" % e)

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

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

public class SubjectsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        SubjectsApi apiInstance = new SubjectsApi();
        Integer page = 56; // Integer | Page number
        Integer size = 56; // Integer | Page size
        String sort = sort_example; // String | Field name to sort by
        Boolean reverse = true; // Boolean | If true - sort descending, false - ascending
        String subjectId = subjectId_example; // String | Search by subject ID
        try {
            array[SubjectSearchResult] result = apiInstance.getSubjects(page, size, sort, reverse, subjectId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SubjectsApi#getSubjects");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.SubjectsApi;

public class SubjectsApiExample {

    public static void main(String[] args) {
        SubjectsApi apiInstance = new SubjectsApi();
        Integer page = 56; // Integer | Page number
        Integer size = 56; // Integer | Page size
        String sort = sort_example; // String | Field name to sort by
        Boolean reverse = true; // Boolean | If true - sort descending, false - ascending
        String subjectId = subjectId_example; // String | Search by subject ID
        try {
            array[SubjectSearchResult] result = apiInstance.getSubjects(page, size, sort, reverse, subjectId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SubjectsApi#getSubjects");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

Integer *page = 56; // Page number (optional) (default to 0)
Integer *size = 56; // Page size (optional) (default to 15)
String *sort = sort_example; // Field name to sort by (optional) (default to subjectId)
Boolean *reverse = true; // If true - sort descending, false - ascending (optional)
String *subjectId = subjectId_example; // Search by subject ID (optional)

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

// Returns information about subjects that match query
[apiInstance getSubjectsWith:page
    size:size
    sort:sort
    reverse:reverse
    subjectId:subjectId
              completionHandler: ^(array[SubjectSearchResult] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.SubjectsApi()

var opts = { 
  'page': 56, // {Integer} Page number
  'size': 56, // {Integer} Page size
  'sort': sort_example, // {String} Field name to sort by
  'reverse': true, // {Boolean} If true - sort descending, false - ascending
  'subjectId': subjectId_example // {String} Search by subject ID
};

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

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

namespace Example
{
    public class getSubjectsExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new SubjectsApi();
            var page = 56;  // Integer | Page number (optional)  (default to 0)
            var size = 56;  // Integer | Page size (optional)  (default to 15)
            var sort = sort_example;  // String | Field name to sort by (optional)  (default to subjectId)
            var reverse = true;  // Boolean | If true - sort descending, false - ascending (optional) 
            var subjectId = subjectId_example;  // String | Search by subject ID (optional) 

            try
            {
                // Returns information about subjects that match query
                array[SubjectSearchResult] result = apiInstance.getSubjects(page, size, sort, reverse, subjectId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SubjectsApi.getSubjects: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\SubjectsApi();
$page = 56; // Integer | Page number
$size = 56; // Integer | Page size
$sort = sort_example; // String | Field name to sort by
$reverse = true; // Boolean | If true - sort descending, false - ascending
$subjectId = subjectId_example; // String | Search by subject ID

try {
    $result = $api_instance->getSubjects($page, $size, $sort, $reverse, $subjectId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SubjectsApi->getSubjects: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::SubjectsApi->new();
my $page = 56; # Integer | Page number
my $size = 56; # Integer | Page size
my $sort = sort_example; # String | Field name to sort by
my $reverse = true; # Boolean | If true - sort descending, false - ascending
my $subjectId = subjectId_example; # String | Search by subject ID

eval { 
    my $result = $api_instance->getSubjects(page => $page, size => $size, sort => $sort, reverse => $reverse, subjectId => $subjectId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SubjectsApi->getSubjects: $@\n";
}

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.SubjectsApi()
page = 56 # Integer | Page number (optional) (default to 0)
size = 56 # Integer | Page size (optional) (default to 15)
sort = sort_example # String | Field name to sort by (optional) (default to subjectId)
reverse = true # Boolean | If true - sort descending, false - ascending (optional)
subjectId = subjectId_example # String | Search by subject ID (optional)

try: 
    # Returns information about subjects that match query
    api_response = api_instance.get_subjects(page=page, size=size, sort=sort, reverse=reverse, subjectId=subjectId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SubjectsApi->getSubjects: %s\n" % e)

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

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

public class TasksApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        TasksApi apiInstance = new TasksApi();
        Integer id = 56; // Integer | Task id
        try {
            Task result = apiInstance.getTask(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TasksApi#getTask");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TasksApi;

public class TasksApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

Integer *id = 56; // Task id

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

// Returns information about administrative task
[apiInstance getTaskWith:id
              completionHandler: ^(Task output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.TasksApi()

var id = 56; // {Integer} Task id


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

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

namespace Example
{
    public class getTaskExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new TasksApi();
            var id = 56;  // Integer | Task id

            try
            {
                // Returns information about administrative task
                Task result = apiInstance.getTask(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TasksApi.getTask: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\TasksApi();
$id = 56; // Integer | Task id

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::TasksApi->new();
my $id = 56; # Integer | Task id

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.TasksApi()
id = 56 # Integer | Task id

try: 
    # Returns information about administrative task
    api_response = api_instance.get_task(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TasksApi->getTask: %s\n" % e)

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

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

public class TransactionsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        TransactionsApi apiInstance = new TransactionsApi();
        String requestId = requestId_example; // String | Filter by requestId
        String type = type_example; // String | Filter by type
        Integer priority = 56; // Integer | Filter by priority
        String status = status_example; // String | Filter by status
        Date createdAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper createdAt bound
        Date createdAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower createdAt bound
        Date startedAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper startedAt bound
        Date startedAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower startedAt bound
        Date completedAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper completedAt bound
        Date completedAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower completedAt bound
        Integer userId = 56; // Integer | Filter by userId
        Boolean adjudicated = true; // Boolean | Filter only adjudicated transactions
        try {
            TransactionsCount result = apiInstance.countTransactions(requestId, type, priority, status, createdAtUpper, createdAtLower, startedAtUpper, startedAtLower, completedAtUpper, completedAtLower, userId, adjudicated);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionsApi#countTransactions");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TransactionsApi;

public class TransactionsApiExample {

    public static void main(String[] args) {
        TransactionsApi apiInstance = new TransactionsApi();
        String requestId = requestId_example; // String | Filter by requestId
        String type = type_example; // String | Filter by type
        Integer priority = 56; // Integer | Filter by priority
        String status = status_example; // String | Filter by status
        Date createdAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper createdAt bound
        Date createdAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower createdAt bound
        Date startedAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper startedAt bound
        Date startedAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower startedAt bound
        Date completedAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper completedAt bound
        Date completedAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower completedAt bound
        Integer userId = 56; // Integer | Filter by userId
        Boolean adjudicated = true; // Boolean | Filter only adjudicated transactions
        try {
            TransactionsCount result = apiInstance.countTransactions(requestId, type, priority, status, createdAtUpper, createdAtLower, startedAtUpper, startedAtLower, completedAtUpper, completedAtLower, userId, adjudicated);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionsApi#countTransactions");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *requestId = requestId_example; // Filter by requestId (optional)
String *type = type_example; // Filter by type (optional)
Integer *priority = 56; // Filter by priority (optional)
String *status = status_example; // Filter by status (optional)
Date *createdAtUpper = 2013-10-20T19:20:30+01:00; // Upper createdAt bound (optional)
Date *createdAtLower = 2013-10-20T19:20:30+01:00; // Lower createdAt bound (optional)
Date *startedAtUpper = 2013-10-20T19:20:30+01:00; // Upper startedAt bound (optional)
Date *startedAtLower = 2013-10-20T19:20:30+01:00; // Lower startedAt bound (optional)
Date *completedAtUpper = 2013-10-20T19:20:30+01:00; // Upper completedAt bound (optional)
Date *completedAtLower = 2013-10-20T19:20:30+01:00; // Lower completedAt bound (optional)
Integer *userId = 56; // Filter by userId (optional)
Boolean *adjudicated = true; // Filter only adjudicated transactions (optional)

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

// Returns transactions count
[apiInstance countTransactionsWith:requestId
    type:type
    priority:priority
    status:status
    createdAtUpper:createdAtUpper
    createdAtLower:createdAtLower
    startedAtUpper:startedAtUpper
    startedAtLower:startedAtLower
    completedAtUpper:completedAtUpper
    completedAtLower:completedAtLower
    userId:userId
    adjudicated:adjudicated
              completionHandler: ^(TransactionsCount output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.TransactionsApi()

var opts = { 
  'requestId': requestId_example, // {String} Filter by requestId
  'type': type_example, // {String} Filter by type
  'priority': 56, // {Integer} Filter by priority
  'status': status_example, // {String} Filter by status
  'createdAtUpper': 2013-10-20T19:20:30+01:00, // {Date} Upper createdAt bound
  'createdAtLower': 2013-10-20T19:20:30+01:00, // {Date} Lower createdAt bound
  'startedAtUpper': 2013-10-20T19:20:30+01:00, // {Date} Upper startedAt bound
  'startedAtLower': 2013-10-20T19:20:30+01:00, // {Date} Lower startedAt bound
  'completedAtUpper': 2013-10-20T19:20:30+01:00, // {Date} Upper completedAt bound
  'completedAtLower': 2013-10-20T19:20:30+01:00, // {Date} Lower completedAt bound
  'userId': 56, // {Integer} Filter by userId
  'adjudicated': true // {Boolean} Filter only adjudicated transactions
};

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

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

namespace Example
{
    public class countTransactionsExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new TransactionsApi();
            var requestId = requestId_example;  // String | Filter by requestId (optional) 
            var type = type_example;  // String | Filter by type (optional) 
            var priority = 56;  // Integer | Filter by priority (optional) 
            var status = status_example;  // String | Filter by status (optional) 
            var createdAtUpper = 2013-10-20T19:20:30+01:00;  // Date | Upper createdAt bound (optional) 
            var createdAtLower = 2013-10-20T19:20:30+01:00;  // Date | Lower createdAt bound (optional) 
            var startedAtUpper = 2013-10-20T19:20:30+01:00;  // Date | Upper startedAt bound (optional) 
            var startedAtLower = 2013-10-20T19:20:30+01:00;  // Date | Lower startedAt bound (optional) 
            var completedAtUpper = 2013-10-20T19:20:30+01:00;  // Date | Upper completedAt bound (optional) 
            var completedAtLower = 2013-10-20T19:20:30+01:00;  // Date | Lower completedAt bound (optional) 
            var userId = 56;  // Integer | Filter by userId (optional) 
            var adjudicated = true;  // Boolean | Filter only adjudicated transactions (optional) 

            try
            {
                // Returns transactions count
                TransactionsCount result = apiInstance.countTransactions(requestId, type, priority, status, createdAtUpper, createdAtLower, startedAtUpper, startedAtLower, completedAtUpper, completedAtLower, userId, adjudicated);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TransactionsApi.countTransactions: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\TransactionsApi();
$requestId = requestId_example; // String | Filter by requestId
$type = type_example; // String | Filter by type
$priority = 56; // Integer | Filter by priority
$status = status_example; // String | Filter by status
$createdAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper createdAt bound
$createdAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower createdAt bound
$startedAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper startedAt bound
$startedAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower startedAt bound
$completedAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper completedAt bound
$completedAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower completedAt bound
$userId = 56; // Integer | Filter by userId
$adjudicated = true; // Boolean | Filter only adjudicated transactions

try {
    $result = $api_instance->countTransactions($requestId, $type, $priority, $status, $createdAtUpper, $createdAtLower, $startedAtUpper, $startedAtLower, $completedAtUpper, $completedAtLower, $userId, $adjudicated);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TransactionsApi->countTransactions: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::TransactionsApi->new();
my $requestId = requestId_example; # String | Filter by requestId
my $type = type_example; # String | Filter by type
my $priority = 56; # Integer | Filter by priority
my $status = status_example; # String | Filter by status
my $createdAtUpper = 2013-10-20T19:20:30+01:00; # Date | Upper createdAt bound
my $createdAtLower = 2013-10-20T19:20:30+01:00; # Date | Lower createdAt bound
my $startedAtUpper = 2013-10-20T19:20:30+01:00; # Date | Upper startedAt bound
my $startedAtLower = 2013-10-20T19:20:30+01:00; # Date | Lower startedAt bound
my $completedAtUpper = 2013-10-20T19:20:30+01:00; # Date | Upper completedAt bound
my $completedAtLower = 2013-10-20T19:20:30+01:00; # Date | Lower completedAt bound
my $userId = 56; # Integer | Filter by userId
my $adjudicated = true; # Boolean | Filter only adjudicated transactions

eval { 
    my $result = $api_instance->countTransactions(requestId => $requestId, type => $type, priority => $priority, status => $status, createdAtUpper => $createdAtUpper, createdAtLower => $createdAtLower, startedAtUpper => $startedAtUpper, startedAtLower => $startedAtLower, completedAtUpper => $completedAtUpper, completedAtLower => $completedAtLower, userId => $userId, adjudicated => $adjudicated);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TransactionsApi->countTransactions: $@\n";
}

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.TransactionsApi()
requestId = requestId_example # String | Filter by requestId (optional)
type = type_example # String | Filter by type (optional)
priority = 56 # Integer | Filter by priority (optional)
status = status_example # String | Filter by status (optional)
createdAtUpper = 2013-10-20T19:20:30+01:00 # Date | Upper createdAt bound (optional)
createdAtLower = 2013-10-20T19:20:30+01:00 # Date | Lower createdAt bound (optional)
startedAtUpper = 2013-10-20T19:20:30+01:00 # Date | Upper startedAt bound (optional)
startedAtLower = 2013-10-20T19:20:30+01:00 # Date | Lower startedAt bound (optional)
completedAtUpper = 2013-10-20T19:20:30+01:00 # Date | Upper completedAt bound (optional)
completedAtLower = 2013-10-20T19:20:30+01:00 # Date | Lower completedAt bound (optional)
userId = 56 # Integer | Filter by userId (optional)
adjudicated = true # Boolean | Filter only adjudicated transactions (optional)

try: 
    # Returns transactions count
    api_response = api_instance.count_transactions(requestId=requestId, type=type, priority=priority, status=status, createdAtUpper=createdAtUpper, createdAtLower=createdAtLower, startedAtUpper=startedAtUpper, startedAtLower=startedAtLower, completedAtUpper=completedAtUpper, completedAtLower=completedAtLower, userId=userId, adjudicated=adjudicated)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransactionsApi->countTransactions: %s\n" % e)

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

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

public class TransactionsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        TransactionsApi apiInstance = new TransactionsApi();
        String requestId = requestId_example; // String | 
        try {
            Transaction result = apiInstance.getTransaction(requestId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionsApi#getTransaction");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TransactionsApi;

public class TransactionsApiExample {

    public static void main(String[] args) {
        TransactionsApi apiInstance = new TransactionsApi();
        String requestId = requestId_example; // String | 
        try {
            Transaction result = apiInstance.getTransaction(requestId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionsApi#getTransaction");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *requestId = requestId_example; // 

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

// Returns information about a single transaction
[apiInstance getTransactionWith:requestId
              completionHandler: ^(Transaction output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.TransactionsApi()

var requestId = requestId_example; // {String} 


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

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

namespace Example
{
    public class getTransactionExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new TransactionsApi();
            var requestId = requestId_example;  // String | 

            try
            {
                // Returns information about a single transaction
                Transaction result = apiInstance.getTransaction(requestId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TransactionsApi.getTransaction: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\TransactionsApi();
$requestId = requestId_example; // String | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::TransactionsApi->new();
my $requestId = requestId_example; # String | 

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.TransactionsApi()
requestId = requestId_example # String | 

try: 
    # Returns information about a single transaction
    api_response = api_instance.get_transaction(requestId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransactionsApi->getTransaction: %s\n" % e)

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

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

public class TransactionsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        TransactionsApi apiInstance = new TransactionsApi();
        String requestId = requestId_example; // String | 
        String timeZone = timeZone_example; // String | Time Zone ID
        try {
            byte[] result = apiInstance.getTransactionReport(requestId, timeZone);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionsApi#getTransactionReport");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TransactionsApi;

public class TransactionsApiExample {

    public static void main(String[] args) {
        TransactionsApi apiInstance = new TransactionsApi();
        String requestId = requestId_example; // String | 
        String timeZone = timeZone_example; // String | Time Zone ID
        try {
            byte[] result = apiInstance.getTransactionReport(requestId, timeZone);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionsApi#getTransactionReport");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *requestId = requestId_example; // 
String *timeZone = timeZone_example; // Time Zone ID (optional)

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

// Generates single biometric task (transaction) report
[apiInstance getTransactionReportWith:requestId
    timeZone:timeZone
              completionHandler: ^(byte[] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.TransactionsApi()

var requestId = requestId_example; // {String} 

var opts = { 
  'timeZone': timeZone_example // {String} Time Zone ID
};

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

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

namespace Example
{
    public class getTransactionReportExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new TransactionsApi();
            var requestId = requestId_example;  // String | 
            var timeZone = timeZone_example;  // String | Time Zone ID (optional) 

            try
            {
                // Generates single biometric task (transaction) report
                byte[] result = apiInstance.getTransactionReport(requestId, timeZone);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TransactionsApi.getTransactionReport: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\TransactionsApi();
$requestId = requestId_example; // String | 
$timeZone = timeZone_example; // String | Time Zone ID

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::TransactionsApi->new();
my $requestId = requestId_example; # String | 
my $timeZone = timeZone_example; # String | Time Zone ID

eval { 
    my $result = $api_instance->getTransactionReport(requestId => $requestId, timeZone => $timeZone);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TransactionsApi->getTransactionReport: $@\n";
}

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.TransactionsApi()
requestId = requestId_example # String | 
timeZone = timeZone_example # String | Time Zone ID (optional)

try: 
    # Generates single biometric task (transaction) report
    api_response = api_instance.get_transaction_report(requestId, timeZone=timeZone)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransactionsApi->getTransactionReport: %s\n" % e)

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

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

public class TransactionsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        TransactionsApi apiInstance = new TransactionsApi();
        Integer page = 56; // Integer | Page number
        Integer size = 56; // Integer | Page size
        String sort = sort_example; // String | Field name to sort by
        Boolean reverse = true; // Boolean | If true - sort descending, false - ascending
        String requestId = requestId_example; // String | Filter by requestId
        String type = type_example; // String | Filter by type
        Integer priority = 56; // Integer | Filter by priority
        String status = status_example; // String | Filter by status
        Date createdAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper createdAt bound
        Date createdAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower createdAt bound
        Date startedAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper startedAt bound
        Date startedAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower startedAt bound
        Date completedAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper completedAt bound
        Date completedAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower completedAt bound
        Integer userId = 56; // Integer | Filter by userId
        Boolean adjudicated = true; // Boolean | Filter only adjudicated transactions
        try {
            array[Transaction] result = apiInstance.getTransactions(page, size, sort, reverse, requestId, type, priority, status, createdAtUpper, createdAtLower, startedAtUpper, startedAtLower, completedAtUpper, completedAtLower, userId, adjudicated);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionsApi#getTransactions");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TransactionsApi;

public class TransactionsApiExample {

    public static void main(String[] args) {
        TransactionsApi apiInstance = new TransactionsApi();
        Integer page = 56; // Integer | Page number
        Integer size = 56; // Integer | Page size
        String sort = sort_example; // String | Field name to sort by
        Boolean reverse = true; // Boolean | If true - sort descending, false - ascending
        String requestId = requestId_example; // String | Filter by requestId
        String type = type_example; // String | Filter by type
        Integer priority = 56; // Integer | Filter by priority
        String status = status_example; // String | Filter by status
        Date createdAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper createdAt bound
        Date createdAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower createdAt bound
        Date startedAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper startedAt bound
        Date startedAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower startedAt bound
        Date completedAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper completedAt bound
        Date completedAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower completedAt bound
        Integer userId = 56; // Integer | Filter by userId
        Boolean adjudicated = true; // Boolean | Filter only adjudicated transactions
        try {
            array[Transaction] result = apiInstance.getTransactions(page, size, sort, reverse, requestId, type, priority, status, createdAtUpper, createdAtLower, startedAtUpper, startedAtLower, completedAtUpper, completedAtLower, userId, adjudicated);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionsApi#getTransactions");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

Integer *page = 56; // Page number (optional) (default to 0)
Integer *size = 56; // Page size (optional) (default to 15)
String *sort = sort_example; // Field name to sort by (optional) (default to requestId)
Boolean *reverse = true; // If true - sort descending, false - ascending (optional)
String *requestId = requestId_example; // Filter by requestId (optional)
String *type = type_example; // Filter by type (optional)
Integer *priority = 56; // Filter by priority (optional)
String *status = status_example; // Filter by status (optional)
Date *createdAtUpper = 2013-10-20T19:20:30+01:00; // Upper createdAt bound (optional)
Date *createdAtLower = 2013-10-20T19:20:30+01:00; // Lower createdAt bound (optional)
Date *startedAtUpper = 2013-10-20T19:20:30+01:00; // Upper startedAt bound (optional)
Date *startedAtLower = 2013-10-20T19:20:30+01:00; // Lower startedAt bound (optional)
Date *completedAtUpper = 2013-10-20T19:20:30+01:00; // Upper completedAt bound (optional)
Date *completedAtLower = 2013-10-20T19:20:30+01:00; // Lower completedAt bound (optional)
Integer *userId = 56; // Filter by userId (optional)
Boolean *adjudicated = true; // Filter only adjudicated transactions (optional)

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

// Returns information about transactions
[apiInstance getTransactionsWith:page
    size:size
    sort:sort
    reverse:reverse
    requestId:requestId
    type:type
    priority:priority
    status:status
    createdAtUpper:createdAtUpper
    createdAtLower:createdAtLower
    startedAtUpper:startedAtUpper
    startedAtLower:startedAtLower
    completedAtUpper:completedAtUpper
    completedAtLower:completedAtLower
    userId:userId
    adjudicated:adjudicated
              completionHandler: ^(array[Transaction] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.TransactionsApi()

var opts = { 
  'page': 56, // {Integer} Page number
  'size': 56, // {Integer} Page size
  'sort': sort_example, // {String} Field name to sort by
  'reverse': true, // {Boolean} If true - sort descending, false - ascending
  'requestId': requestId_example, // {String} Filter by requestId
  'type': type_example, // {String} Filter by type
  'priority': 56, // {Integer} Filter by priority
  'status': status_example, // {String} Filter by status
  'createdAtUpper': 2013-10-20T19:20:30+01:00, // {Date} Upper createdAt bound
  'createdAtLower': 2013-10-20T19:20:30+01:00, // {Date} Lower createdAt bound
  'startedAtUpper': 2013-10-20T19:20:30+01:00, // {Date} Upper startedAt bound
  'startedAtLower': 2013-10-20T19:20:30+01:00, // {Date} Lower startedAt bound
  'completedAtUpper': 2013-10-20T19:20:30+01:00, // {Date} Upper completedAt bound
  'completedAtLower': 2013-10-20T19:20:30+01:00, // {Date} Lower completedAt bound
  'userId': 56, // {Integer} Filter by userId
  'adjudicated': true // {Boolean} Filter only adjudicated transactions
};

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

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

namespace Example
{
    public class getTransactionsExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new TransactionsApi();
            var page = 56;  // Integer | Page number (optional)  (default to 0)
            var size = 56;  // Integer | Page size (optional)  (default to 15)
            var sort = sort_example;  // String | Field name to sort by (optional)  (default to requestId)
            var reverse = true;  // Boolean | If true - sort descending, false - ascending (optional) 
            var requestId = requestId_example;  // String | Filter by requestId (optional) 
            var type = type_example;  // String | Filter by type (optional) 
            var priority = 56;  // Integer | Filter by priority (optional) 
            var status = status_example;  // String | Filter by status (optional) 
            var createdAtUpper = 2013-10-20T19:20:30+01:00;  // Date | Upper createdAt bound (optional) 
            var createdAtLower = 2013-10-20T19:20:30+01:00;  // Date | Lower createdAt bound (optional) 
            var startedAtUpper = 2013-10-20T19:20:30+01:00;  // Date | Upper startedAt bound (optional) 
            var startedAtLower = 2013-10-20T19:20:30+01:00;  // Date | Lower startedAt bound (optional) 
            var completedAtUpper = 2013-10-20T19:20:30+01:00;  // Date | Upper completedAt bound (optional) 
            var completedAtLower = 2013-10-20T19:20:30+01:00;  // Date | Lower completedAt bound (optional) 
            var userId = 56;  // Integer | Filter by userId (optional) 
            var adjudicated = true;  // Boolean | Filter only adjudicated transactions (optional) 

            try
            {
                // Returns information about transactions
                array[Transaction] result = apiInstance.getTransactions(page, size, sort, reverse, requestId, type, priority, status, createdAtUpper, createdAtLower, startedAtUpper, startedAtLower, completedAtUpper, completedAtLower, userId, adjudicated);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TransactionsApi.getTransactions: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\TransactionsApi();
$page = 56; // Integer | Page number
$size = 56; // Integer | Page size
$sort = sort_example; // String | Field name to sort by
$reverse = true; // Boolean | If true - sort descending, false - ascending
$requestId = requestId_example; // String | Filter by requestId
$type = type_example; // String | Filter by type
$priority = 56; // Integer | Filter by priority
$status = status_example; // String | Filter by status
$createdAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper createdAt bound
$createdAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower createdAt bound
$startedAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper startedAt bound
$startedAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower startedAt bound
$completedAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper completedAt bound
$completedAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower completedAt bound
$userId = 56; // Integer | Filter by userId
$adjudicated = true; // Boolean | Filter only adjudicated transactions

try {
    $result = $api_instance->getTransactions($page, $size, $sort, $reverse, $requestId, $type, $priority, $status, $createdAtUpper, $createdAtLower, $startedAtUpper, $startedAtLower, $completedAtUpper, $completedAtLower, $userId, $adjudicated);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TransactionsApi->getTransactions: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::TransactionsApi->new();
my $page = 56; # Integer | Page number
my $size = 56; # Integer | Page size
my $sort = sort_example; # String | Field name to sort by
my $reverse = true; # Boolean | If true - sort descending, false - ascending
my $requestId = requestId_example; # String | Filter by requestId
my $type = type_example; # String | Filter by type
my $priority = 56; # Integer | Filter by priority
my $status = status_example; # String | Filter by status
my $createdAtUpper = 2013-10-20T19:20:30+01:00; # Date | Upper createdAt bound
my $createdAtLower = 2013-10-20T19:20:30+01:00; # Date | Lower createdAt bound
my $startedAtUpper = 2013-10-20T19:20:30+01:00; # Date | Upper startedAt bound
my $startedAtLower = 2013-10-20T19:20:30+01:00; # Date | Lower startedAt bound
my $completedAtUpper = 2013-10-20T19:20:30+01:00; # Date | Upper completedAt bound
my $completedAtLower = 2013-10-20T19:20:30+01:00; # Date | Lower completedAt bound
my $userId = 56; # Integer | Filter by userId
my $adjudicated = true; # Boolean | Filter only adjudicated transactions

eval { 
    my $result = $api_instance->getTransactions(page => $page, size => $size, sort => $sort, reverse => $reverse, requestId => $requestId, type => $type, priority => $priority, status => $status, createdAtUpper => $createdAtUpper, createdAtLower => $createdAtLower, startedAtUpper => $startedAtUpper, startedAtLower => $startedAtLower, completedAtUpper => $completedAtUpper, completedAtLower => $completedAtLower, userId => $userId, adjudicated => $adjudicated);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TransactionsApi->getTransactions: $@\n";
}

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.TransactionsApi()
page = 56 # Integer | Page number (optional) (default to 0)
size = 56 # Integer | Page size (optional) (default to 15)
sort = sort_example # String | Field name to sort by (optional) (default to requestId)
reverse = true # Boolean | If true - sort descending, false - ascending (optional)
requestId = requestId_example # String | Filter by requestId (optional)
type = type_example # String | Filter by type (optional)
priority = 56 # Integer | Filter by priority (optional)
status = status_example # String | Filter by status (optional)
createdAtUpper = 2013-10-20T19:20:30+01:00 # Date | Upper createdAt bound (optional)
createdAtLower = 2013-10-20T19:20:30+01:00 # Date | Lower createdAt bound (optional)
startedAtUpper = 2013-10-20T19:20:30+01:00 # Date | Upper startedAt bound (optional)
startedAtLower = 2013-10-20T19:20:30+01:00 # Date | Lower startedAt bound (optional)
completedAtUpper = 2013-10-20T19:20:30+01:00 # Date | Upper completedAt bound (optional)
completedAtLower = 2013-10-20T19:20:30+01:00 # Date | Lower completedAt bound (optional)
userId = 56 # Integer | Filter by userId (optional)
adjudicated = true # Boolean | Filter only adjudicated transactions (optional)

try: 
    # Returns information about transactions
    api_response = api_instance.get_transactions(page=page, size=size, sort=sort, reverse=reverse, requestId=requestId, type=type, priority=priority, status=status, createdAtUpper=createdAtUpper, createdAtLower=createdAtLower, startedAtUpper=startedAtUpper, startedAtLower=startedAtLower, completedAtUpper=completedAtUpper, completedAtLower=completedAtLower, userId=userId, adjudicated=adjudicated)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransactionsApi->getTransactions: %s\n" % e)

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

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

public class TransactionsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        TransactionsApi apiInstance = new TransactionsApi();
        String requestId = requestId_example; // String | Filter by requestId
        String type = type_example; // String | Filter by type
        Integer priority = 56; // Integer | Filter by priority
        String status = status_example; // String | Filter by status
        Date createdAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper createdAt bound
        Date createdAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower createdAt bound
        Date startedAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper startedAt bound
        Date startedAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower startedAt bound
        Date completedAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper completedAt bound
        Date completedAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower completedAt bound
        Integer userId = 56; // Integer | Filter by userId
        Boolean adjudicated = true; // Boolean | Filter only adjudicated transactions
        String timeZone = timeZone_example; // String | Time Zone ID
        try {
            byte[] result = apiInstance.getTransactionsReport(requestId, type, priority, status, createdAtUpper, createdAtLower, startedAtUpper, startedAtLower, completedAtUpper, completedAtLower, userId, adjudicated, timeZone);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionsApi#getTransactionsReport");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TransactionsApi;

public class TransactionsApiExample {

    public static void main(String[] args) {
        TransactionsApi apiInstance = new TransactionsApi();
        String requestId = requestId_example; // String | Filter by requestId
        String type = type_example; // String | Filter by type
        Integer priority = 56; // Integer | Filter by priority
        String status = status_example; // String | Filter by status
        Date createdAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper createdAt bound
        Date createdAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower createdAt bound
        Date startedAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper startedAt bound
        Date startedAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower startedAt bound
        Date completedAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper completedAt bound
        Date completedAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower completedAt bound
        Integer userId = 56; // Integer | Filter by userId
        Boolean adjudicated = true; // Boolean | Filter only adjudicated transactions
        String timeZone = timeZone_example; // String | Time Zone ID
        try {
            byte[] result = apiInstance.getTransactionsReport(requestId, type, priority, status, createdAtUpper, createdAtLower, startedAtUpper, startedAtLower, completedAtUpper, completedAtLower, userId, adjudicated, timeZone);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionsApi#getTransactionsReport");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

String *requestId = requestId_example; // Filter by requestId (optional)
String *type = type_example; // Filter by type (optional)
Integer *priority = 56; // Filter by priority (optional)
String *status = status_example; // Filter by status (optional)
Date *createdAtUpper = 2013-10-20T19:20:30+01:00; // Upper createdAt bound (optional)
Date *createdAtLower = 2013-10-20T19:20:30+01:00; // Lower createdAt bound (optional)
Date *startedAtUpper = 2013-10-20T19:20:30+01:00; // Upper startedAt bound (optional)
Date *startedAtLower = 2013-10-20T19:20:30+01:00; // Lower startedAt bound (optional)
Date *completedAtUpper = 2013-10-20T19:20:30+01:00; // Upper completedAt bound (optional)
Date *completedAtLower = 2013-10-20T19:20:30+01:00; // Lower completedAt bound (optional)
Integer *userId = 56; // Filter by userId (optional)
Boolean *adjudicated = true; // Filter only adjudicated transactions (optional)
String *timeZone = timeZone_example; // Time Zone ID (optional)

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

// Generates biometric tasks (transactions) report
[apiInstance getTransactionsReportWith:requestId
    type:type
    priority:priority
    status:status
    createdAtUpper:createdAtUpper
    createdAtLower:createdAtLower
    startedAtUpper:startedAtUpper
    startedAtLower:startedAtLower
    completedAtUpper:completedAtUpper
    completedAtLower:completedAtLower
    userId:userId
    adjudicated:adjudicated
    timeZone:timeZone
              completionHandler: ^(byte[] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.TransactionsApi()

var opts = { 
  'requestId': requestId_example, // {String} Filter by requestId
  'type': type_example, // {String} Filter by type
  'priority': 56, // {Integer} Filter by priority
  'status': status_example, // {String} Filter by status
  'createdAtUpper': 2013-10-20T19:20:30+01:00, // {Date} Upper createdAt bound
  'createdAtLower': 2013-10-20T19:20:30+01:00, // {Date} Lower createdAt bound
  'startedAtUpper': 2013-10-20T19:20:30+01:00, // {Date} Upper startedAt bound
  'startedAtLower': 2013-10-20T19:20:30+01:00, // {Date} Lower startedAt bound
  'completedAtUpper': 2013-10-20T19:20:30+01:00, // {Date} Upper completedAt bound
  'completedAtLower': 2013-10-20T19:20:30+01:00, // {Date} Lower completedAt bound
  'userId': 56, // {Integer} Filter by userId
  'adjudicated': true, // {Boolean} Filter only adjudicated transactions
  'timeZone': timeZone_example // {String} Time Zone ID
};

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

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

namespace Example
{
    public class getTransactionsReportExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new TransactionsApi();
            var requestId = requestId_example;  // String | Filter by requestId (optional) 
            var type = type_example;  // String | Filter by type (optional) 
            var priority = 56;  // Integer | Filter by priority (optional) 
            var status = status_example;  // String | Filter by status (optional) 
            var createdAtUpper = 2013-10-20T19:20:30+01:00;  // Date | Upper createdAt bound (optional) 
            var createdAtLower = 2013-10-20T19:20:30+01:00;  // Date | Lower createdAt bound (optional) 
            var startedAtUpper = 2013-10-20T19:20:30+01:00;  // Date | Upper startedAt bound (optional) 
            var startedAtLower = 2013-10-20T19:20:30+01:00;  // Date | Lower startedAt bound (optional) 
            var completedAtUpper = 2013-10-20T19:20:30+01:00;  // Date | Upper completedAt bound (optional) 
            var completedAtLower = 2013-10-20T19:20:30+01:00;  // Date | Lower completedAt bound (optional) 
            var userId = 56;  // Integer | Filter by userId (optional) 
            var adjudicated = true;  // Boolean | Filter only adjudicated transactions (optional) 
            var timeZone = timeZone_example;  // String | Time Zone ID (optional) 

            try
            {
                // Generates biometric tasks (transactions) report
                byte[] result = apiInstance.getTransactionsReport(requestId, type, priority, status, createdAtUpper, createdAtLower, startedAtUpper, startedAtLower, completedAtUpper, completedAtLower, userId, adjudicated, timeZone);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TransactionsApi.getTransactionsReport: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\TransactionsApi();
$requestId = requestId_example; // String | Filter by requestId
$type = type_example; // String | Filter by type
$priority = 56; // Integer | Filter by priority
$status = status_example; // String | Filter by status
$createdAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper createdAt bound
$createdAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower createdAt bound
$startedAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper startedAt bound
$startedAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower startedAt bound
$completedAtUpper = 2013-10-20T19:20:30+01:00; // Date | Upper completedAt bound
$completedAtLower = 2013-10-20T19:20:30+01:00; // Date | Lower completedAt bound
$userId = 56; // Integer | Filter by userId
$adjudicated = true; // Boolean | Filter only adjudicated transactions
$timeZone = timeZone_example; // String | Time Zone ID

try {
    $result = $api_instance->getTransactionsReport($requestId, $type, $priority, $status, $createdAtUpper, $createdAtLower, $startedAtUpper, $startedAtLower, $completedAtUpper, $completedAtLower, $userId, $adjudicated, $timeZone);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TransactionsApi->getTransactionsReport: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::TransactionsApi->new();
my $requestId = requestId_example; # String | Filter by requestId
my $type = type_example; # String | Filter by type
my $priority = 56; # Integer | Filter by priority
my $status = status_example; # String | Filter by status
my $createdAtUpper = 2013-10-20T19:20:30+01:00; # Date | Upper createdAt bound
my $createdAtLower = 2013-10-20T19:20:30+01:00; # Date | Lower createdAt bound
my $startedAtUpper = 2013-10-20T19:20:30+01:00; # Date | Upper startedAt bound
my $startedAtLower = 2013-10-20T19:20:30+01:00; # Date | Lower startedAt bound
my $completedAtUpper = 2013-10-20T19:20:30+01:00; # Date | Upper completedAt bound
my $completedAtLower = 2013-10-20T19:20:30+01:00; # Date | Lower completedAt bound
my $userId = 56; # Integer | Filter by userId
my $adjudicated = true; # Boolean | Filter only adjudicated transactions
my $timeZone = timeZone_example; # String | Time Zone ID

eval { 
    my $result = $api_instance->getTransactionsReport(requestId => $requestId, type => $type, priority => $priority, status => $status, createdAtUpper => $createdAtUpper, createdAtLower => $createdAtLower, startedAtUpper => $startedAtUpper, startedAtLower => $startedAtLower, completedAtUpper => $completedAtUpper, completedAtLower => $completedAtLower, userId => $userId, adjudicated => $adjudicated, timeZone => $timeZone);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TransactionsApi->getTransactionsReport: $@\n";
}

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.TransactionsApi()
requestId = requestId_example # String | Filter by requestId (optional)
type = type_example # String | Filter by type (optional)
priority = 56 # Integer | Filter by priority (optional)
status = status_example # String | Filter by status (optional)
createdAtUpper = 2013-10-20T19:20:30+01:00 # Date | Upper createdAt bound (optional)
createdAtLower = 2013-10-20T19:20:30+01:00 # Date | Lower createdAt bound (optional)
startedAtUpper = 2013-10-20T19:20:30+01:00 # Date | Upper startedAt bound (optional)
startedAtLower = 2013-10-20T19:20:30+01:00 # Date | Lower startedAt bound (optional)
completedAtUpper = 2013-10-20T19:20:30+01:00 # Date | Upper completedAt bound (optional)
completedAtLower = 2013-10-20T19:20:30+01:00 # Date | Lower completedAt bound (optional)
userId = 56 # Integer | Filter by userId (optional)
adjudicated = true # Boolean | Filter only adjudicated transactions (optional)
timeZone = timeZone_example # String | Time Zone ID (optional)

try: 
    # Generates biometric tasks (transactions) report
    api_response = api_instance.get_transactions_report(requestId=requestId, type=type, priority=priority, status=status, createdAtUpper=createdAtUpper, createdAtLower=createdAtLower, startedAtUpper=startedAtUpper, startedAtLower=startedAtLower, completedAtUpper=completedAtUpper, completedAtLower=completedAtLower, userId=userId, adjudicated=adjudicated, timeZone=timeZone)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransactionsApi->getTransactionsReport: %s\n" % e)

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

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

public class TransactionsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        TransactionsApi apiInstance = new TransactionsApi();
        TransactionRegistration body = ; // TransactionRegistration | Transaction registration model
        try {
            Transaction result = apiInstance.registerTransaction(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionsApi#registerTransaction");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.TransactionsApi;

public class TransactionsApiExample {

    public static void main(String[] args) {
        TransactionsApi apiInstance = new TransactionsApi();
        TransactionRegistration body = ; // TransactionRegistration | Transaction registration model
        try {
            Transaction result = apiInstance.registerTransaction(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionsApi#registerTransaction");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

TransactionRegistration *body = ; // Transaction registration model

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

// Registers new transaction according to specified parameters
[apiInstance registerTransactionWith:body
              completionHandler: ^(Transaction output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.TransactionsApi()

var body = ; // {TransactionRegistration} Transaction registration model


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

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

namespace Example
{
    public class registerTransactionExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new TransactionsApi();
            var body = new TransactionRegistration(); // TransactionRegistration | Transaction registration model

            try
            {
                // Registers new transaction according to specified parameters
                Transaction result = apiInstance.registerTransaction(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling TransactionsApi.registerTransaction: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\TransactionsApi();
$body = ; // TransactionRegistration | Transaction registration model

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::TransactionsApi->new();
my $body = WWW::SwaggerClient::Object::TransactionRegistration->new(); # TransactionRegistration | Transaction registration model

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.TransactionsApi()
body =  # TransactionRegistration | Transaction registration model

try: 
    # Registers new transaction according to specified parameters
    api_response = api_instance.register_transaction(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransactionsApi->registerTransaction: %s\n" % e)

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

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

public class UsersApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        UsersApi apiInstance = new UsersApi();
        Integer page = 56; // Integer | Page number
        Integer size = 56; // Integer | Page size
        try {
            array[User] result = apiInstance.getUsers(page, size);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#getUsers");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        Integer page = 56; // Integer | Page number
        Integer size = 56; // Integer | Page size
        try {
            array[User] result = apiInstance.getUsers(page, size);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#getUsers");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

Integer *page = 56; // Page number (optional) (default to 0)
Integer *size = 56; // Page size (optional) (default to 15)

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

// Returns users information
[apiInstance getUsersWith:page
    size:size
              completionHandler: ^(array[User] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.UsersApi()

var opts = { 
  'page': 56, // {Integer} Page number
  'size': 56 // {Integer} Page size
};

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

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

namespace Example
{
    public class getUsersExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new UsersApi();
            var page = 56;  // Integer | Page number (optional)  (default to 0)
            var size = 56;  // Integer | Page size (optional)  (default to 15)

            try
            {
                // Returns users information
                array[User] result = apiInstance.getUsers(page, size);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.getUsers: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\UsersApi();
$page = 56; // Integer | Page number
$size = 56; // Integer | Page size

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::UsersApi->new();
my $page = 56; # Integer | Page number
my $size = 56; # Integer | Page size

eval { 
    my $result = $api_instance->getUsers(page => $page, size => $size);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UsersApi->getUsers: $@\n";
}

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.UsersApi()
page = 56 # Integer | Page number (optional) (default to 0)
size = 56 # Integer | Page size (optional) (default to 15)

try: 
    # Returns users information
    api_response = api_instance.get_users(page=page, size=size)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->getUsers: %s\n" % e)

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

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

public class UtilitiesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        UtilitiesApi apiInstance = new UtilitiesApi();
        try {
            Task result = apiInstance.calculateMissingNfiq();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UtilitiesApi#calculateMissingNfiq");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UtilitiesApi;

public class UtilitiesApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


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

// Calculate NFIQ data
[apiInstance calculateMissingNfiqWithCompletionHandler: 
              ^(Task output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.UtilitiesApi()

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

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

namespace Example
{
    public class calculateMissingNfiqExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new UtilitiesApi();

            try
            {
                // Calculate NFIQ data
                Task result = apiInstance.calculateMissingNfiq();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UtilitiesApi.calculateMissingNfiq: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

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

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try: 
    # Calculate NFIQ data
    api_response = api_instance.calculate_missing_nfiq()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UtilitiesApi->calculateMissingNfiq: %s\n" % e)

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

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

public class UtilitiesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        UtilitiesApi apiInstance = new UtilitiesApi();
        try {
            Task result = apiInstance.clearTransactions();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UtilitiesApi#clearTransactions");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UtilitiesApi;

public class UtilitiesApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


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

// Clears transactions
[apiInstance clearTransactionsWithCompletionHandler: 
              ^(Task output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.UtilitiesApi()

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

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

namespace Example
{
    public class clearTransactionsExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new UtilitiesApi();

            try
            {
                // Clears transactions
                Task result = apiInstance.clearTransactions();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UtilitiesApi.clearTransactions: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

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

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try: 
    # Clears transactions
    api_response = api_instance.clear_transactions()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UtilitiesApi->clearTransactions: %s\n" % e)

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

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

public class UtilitiesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        UtilitiesApi apiInstance = new UtilitiesApi();
        Boolean duplicateCheckThresholds = true; // Boolean | 
        Boolean filtering = true; // Boolean | 
        try {
            Task result = apiInstance.reapplyMatchingRules(duplicateCheckThresholds, filtering);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UtilitiesApi#reapplyMatchingRules");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UtilitiesApi;

public class UtilitiesApiExample {

    public static void main(String[] args) {
        UtilitiesApi apiInstance = new UtilitiesApi();
        Boolean duplicateCheckThresholds = true; // Boolean | 
        Boolean filtering = true; // Boolean | 
        try {
            Task result = apiInstance.reapplyMatchingRules(duplicateCheckThresholds, filtering);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UtilitiesApi#reapplyMatchingRules");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

Boolean *duplicateCheckThresholds = true; //  (optional) (default to false)
Boolean *filtering = true; //  (optional) (default to false)

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

// Retrospectively applies matching rules (only rules that shorten matching results list will be applied, previously discarded matches won't be re-added)
[apiInstance reapplyMatchingRulesWith:duplicateCheckThresholds
    filtering:filtering
              completionHandler: ^(Task output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.UtilitiesApi()

var opts = { 
  'duplicateCheckThresholds': true, // {Boolean} 
  'filtering': true // {Boolean} 
};

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

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

namespace Example
{
    public class reapplyMatchingRulesExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new UtilitiesApi();
            var duplicateCheckThresholds = true;  // Boolean |  (optional)  (default to false)
            var filtering = true;  // Boolean |  (optional)  (default to false)

            try
            {
                // Retrospectively applies matching rules (only rules that shorten matching results list will be applied, previously discarded matches won't be re-added)
                Task result = apiInstance.reapplyMatchingRules(duplicateCheckThresholds, filtering);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UtilitiesApi.reapplyMatchingRules: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\UtilitiesApi();
$duplicateCheckThresholds = true; // Boolean | 
$filtering = true; // Boolean | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::UtilitiesApi->new();
my $duplicateCheckThresholds = true; # Boolean | 
my $filtering = true; # Boolean | 

eval { 
    my $result = $api_instance->reapplyMatchingRules(duplicateCheckThresholds => $duplicateCheckThresholds, filtering => $filtering);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UtilitiesApi->reapplyMatchingRules: $@\n";
}

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.UtilitiesApi()
duplicateCheckThresholds = true # Boolean |  (optional) (default to false)
filtering = true # Boolean |  (optional) (default to false)

try: 
    # Retrospectively applies matching rules (only rules that shorten matching results list will be applied, previously discarded matches won't be re-added)
    api_response = api_instance.reapply_matching_rules(duplicateCheckThresholds=duplicateCheckThresholds, filtering=filtering)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UtilitiesApi->reapplyMatchingRules: %s\n" % e)

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

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

public class UtilitiesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        UtilitiesApi apiInstance = new UtilitiesApi();
        try {
            Task result = apiInstance.syncElasticsearch();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UtilitiesApi#syncElasticsearch");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UtilitiesApi;

public class UtilitiesApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];


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

// Sync transactions to Elasticsearch
[apiInstance syncElasticsearchWithCompletionHandler: 
              ^(Task output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.UtilitiesApi()

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

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

namespace Example
{
    public class syncElasticsearchExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new UtilitiesApi();

            try
            {
                // Sync transactions to Elasticsearch
                Task result = apiInstance.syncElasticsearch();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UtilitiesApi.syncElasticsearch: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

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

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try: 
    # Sync transactions to Elasticsearch
    api_response = api_instance.sync_elasticsearch()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UtilitiesApi->syncElasticsearch: %s\n" % e)

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

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

public class UtilitiesApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure OAuth2 access token for authorization: main
        OAuth main = (OAuth) defaultClient.getAuthentication("main");
        main.setAccessToken("YOUR ACCESS TOKEN");

        UtilitiesApi apiInstance = new UtilitiesApi();
        Boolean incremental = true; // Boolean | 
        try {
            Task result = apiInstance.syncMatchingService(incremental);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UtilitiesApi#syncMatchingService");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UtilitiesApi;

public class UtilitiesApiExample {

    public static void main(String[] args) {
        UtilitiesApi apiInstance = new UtilitiesApi();
        Boolean incremental = true; // Boolean | 
        try {
            Task result = apiInstance.syncMatchingService(incremental);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UtilitiesApi#syncMatchingService");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure OAuth2 access token for authorization: (authentication scheme: main)
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

Boolean *incremental = true; //  (optional) (default to false)

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

// Sync transactions to Matching Service
[apiInstance syncMatchingServiceWith:incremental
              completionHandler: ^(Task output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var MegaMatcherAutomatedBiometricIdentificationSystemAbis = require('mega_matcher_automated_biometric_identification_system__abis');
var defaultClient = MegaMatcherAutomatedBiometricIdentificationSystemAbis.ApiClient.instance;

// Configure OAuth2 access token for authorization: main
var main = defaultClient.authentications['main'];
main.accessToken = "YOUR ACCESS TOKEN"

var api = new MegaMatcherAutomatedBiometricIdentificationSystemAbis.UtilitiesApi()

var opts = { 
  'incremental': true // {Boolean} 
};

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

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

namespace Example
{
    public class syncMatchingServiceExample
    {
        public void main()
        {
            
            // Configure OAuth2 access token for authorization: main
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            var apiInstance = new UtilitiesApi();
            var incremental = true;  // Boolean |  (optional)  (default to false)

            try
            {
                // Sync transactions to Matching Service
                Task result = apiInstance.syncMatchingService(incremental);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UtilitiesApi.syncMatchingService: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: main
Swagger\Client\Configuration::getDefaultConfiguration()->setAccessToken('YOUR_ACCESS_TOKEN');

$api_instance = new Swagger\Client\Api\UtilitiesApi();
$incremental = true; // Boolean | 

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

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

# Configure OAuth2 access token for authorization: main
$WWW::SwaggerClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

my $api_instance = WWW::SwaggerClient::UtilitiesApi->new();
my $incremental = true; # Boolean | 

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

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

# Configure OAuth2 access token for authorization: main
swagger_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# create an instance of the API class
api_instance = swagger_client.UtilitiesApi()
incremental = true # Boolean |  (optional) (default to false)

try: 
    # Sync transactions to Matching Service
    api_response = api_instance.sync_matching_service(incremental=incremental)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UtilitiesApi->syncMatchingService: %s\n" % e)