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

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

public class MctApiExample {

    public static void main(String[] args) {
        
        MctApi apiInstance = new MctApi();
        String processType = processType_example; // String | Process type
        String contract = contract_example; // String | Contract number
        String eic = eic_example; // String | EIC for point of delivery
        date decisiveDate = 2013-10-20; // date | Decisive date
        String author = author_example; // String | Request creator
        String amendment = amendment_example; // String | Amendment number
        Date validTo = 2013-10-20T19:20:30+01:00; // Date | 
        APIBusinessPartnerInfo body = ; // APIBusinessPartnerInfo | Information about business partner
        try {
            'String' result = apiInstance.createRequest(processType, contract, eic, decisiveDate, author, amendment, validTo, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MctApi#createRequest");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MctApi;

public class MctApiExample {

    public static void main(String[] args) {
        MctApi apiInstance = new MctApi();
        String processType = processType_example; // String | Process type
        String contract = contract_example; // String | Contract number
        String eic = eic_example; // String | EIC for point of delivery
        date decisiveDate = 2013-10-20; // date | Decisive date
        String author = author_example; // String | Request creator
        String amendment = amendment_example; // String | Amendment number
        Date validTo = 2013-10-20T19:20:30+01:00; // Date | 
        APIBusinessPartnerInfo body = ; // APIBusinessPartnerInfo | Information about business partner
        try {
            'String' result = apiInstance.createRequest(processType, contract, eic, decisiveDate, author, amendment, validTo, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MctApi#createRequest");
            e.printStackTrace();
        }
    }
}

String *processType = processType_example; // Process type
String *contract = contract_example; // Contract number
String *eic = eic_example; // EIC for point of delivery
date *decisiveDate = 2013-10-20; // Decisive date
String *author = author_example; // Request creator
String *amendment = amendment_example; // Amendment number (optional)
Date *validTo = 2013-10-20T19:20:30+01:00; //  (optional)
APIBusinessPartnerInfo *body = ; // Information about business partner (optional)

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

// Create new request
[apiInstance createRequestWith:processType
    contract:contract
    eic:eic
    decisiveDate:decisiveDate
    author:author
    amendment:amendment
    validTo:validTo
    body:body
              completionHandler: ^('String' output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EmpiricaMctApi = require('empirica_mct_api');

var api = new EmpiricaMctApi.MctApi()

var processType = processType_example; // {String} Process type

var contract = contract_example; // {String} Contract number

var eic = eic_example; // {String} EIC for point of delivery

var decisiveDate = 2013-10-20; // {date} Decisive date

var author = author_example; // {String} Request creator

var opts = { 
  'amendment': amendment_example, // {String} Amendment number
  'validTo': 2013-10-20T19:20:30+01:00, // {Date} 
  'body':  // {APIBusinessPartnerInfo} Information about business partner
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createRequest(processType, contract, eic, decisiveDate, author, opts, callback);

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

namespace Example
{
    public class createRequestExample
    {
        public void main()
        {
            
            var apiInstance = new MctApi();
            var processType = processType_example;  // String | Process type
            var contract = contract_example;  // String | Contract number
            var eic = eic_example;  // String | EIC for point of delivery
            var decisiveDate = 2013-10-20;  // date | Decisive date
            var author = author_example;  // String | Request creator
            var amendment = amendment_example;  // String | Amendment number (optional) 
            var validTo = 2013-10-20T19:20:30+01:00;  // Date |  (optional) 
            var body = new APIBusinessPartnerInfo(); // APIBusinessPartnerInfo | Information about business partner (optional) 

            try
            {
                // Create new request
                'String' result = apiInstance.createRequest(processType, contract, eic, decisiveDate, author, amendment, validTo, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MctApi.createRequest: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\MctApi();
$processType = processType_example; // String | Process type
$contract = contract_example; // String | Contract number
$eic = eic_example; // String | EIC for point of delivery
$decisiveDate = 2013-10-20; // date | Decisive date
$author = author_example; // String | Request creator
$amendment = amendment_example; // String | Amendment number
$validTo = 2013-10-20T19:20:30+01:00; // Date | 
$body = ; // APIBusinessPartnerInfo | Information about business partner

try {
    $result = $api_instance->createRequest($processType, $contract, $eic, $decisiveDate, $author, $amendment, $validTo, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MctApi->createRequest: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::MctApi->new();
my $processType = processType_example; # String | Process type
my $contract = contract_example; # String | Contract number
my $eic = eic_example; # String | EIC for point of delivery
my $decisiveDate = 2013-10-20; # date | Decisive date
my $author = author_example; # String | Request creator
my $amendment = amendment_example; # String | Amendment number
my $validTo = 2013-10-20T19:20:30+01:00; # Date | 
my $body = WWW::SwaggerClient::Object::APIBusinessPartnerInfo->new(); # APIBusinessPartnerInfo | Information about business partner

eval { 
    my $result = $api_instance->createRequest(processType => $processType, contract => $contract, eic => $eic, decisiveDate => $decisiveDate, author => $author, amendment => $amendment, validTo => $validTo, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MctApi->createRequest: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.MctApi()
processType = processType_example # String | Process type
contract = contract_example # String | Contract number
eic = eic_example # String | EIC for point of delivery
decisiveDate = 2013-10-20 # date | Decisive date
author = author_example # String | Request creator
amendment = amendment_example # String | Amendment number (optional)
validTo = 2013-10-20T19:20:30+01:00 # Date |  (optional)
body =  # APIBusinessPartnerInfo | Information about business partner (optional)

try: 
    # Create new request
    api_response = api_instance.create_request(processType, contract, eic, decisiveDate, author, amendment=amendment, validTo=validTo, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MctApi->createRequest: %s\n" % e)

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

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

public class MctApiExample {

    public static void main(String[] args) {
        
        MctApi apiInstance = new MctApi();
        String reqNumber = reqNumber_example; // String | Request number
        try {
            apiInstance.doNewSupply(reqNumber);
        } catch (ApiException e) {
            System.err.println("Exception when calling MctApi#doNewSupply");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MctApi;

public class MctApiExample {

    public static void main(String[] args) {
        MctApi apiInstance = new MctApi();
        String reqNumber = reqNumber_example; // String | Request number
        try {
            apiInstance.doNewSupply(reqNumber);
        } catch (ApiException e) {
            System.err.println("Exception when calling MctApi#doNewSupply");
            e.printStackTrace();
        }
    }
}

String *reqNumber = reqNumber_example; // Request number

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

// Perform actions to complete new supply.
[apiInstance doNewSupplyWith:reqNumber
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EmpiricaMctApi = require('empirica_mct_api');

var api = new EmpiricaMctApi.MctApi()

var reqNumber = reqNumber_example; // {String} Request number


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

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

namespace Example
{
    public class doNewSupplyExample
    {
        public void main()
        {
            
            var apiInstance = new MctApi();
            var reqNumber = reqNumber_example;  // String | Request number

            try
            {
                // Perform actions to complete new supply.
                apiInstance.doNewSupply(reqNumber);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MctApi.doNewSupply: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\MctApi();
$reqNumber = reqNumber_example; // String | Request number

try {
    $api_instance->doNewSupply($reqNumber);
} catch (Exception $e) {
    echo 'Exception when calling MctApi->doNewSupply: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::MctApi->new();
my $reqNumber = reqNumber_example; # String | Request number

eval { 
    $api_instance->doNewSupply(reqNumber => $reqNumber);
};
if ($@) {
    warn "Exception when calling MctApi->doNewSupply: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.MctApi()
reqNumber = reqNumber_example # String | Request number

try: 
    # Perform actions to complete new supply.
    api_instance.do_new_supply(reqNumber)
except ApiException as e:
    print("Exception when calling MctApi->doNewSupply: %s\n" % e)

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

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

public class MctApiExample {

    public static void main(String[] args) {
        
        MctApi apiInstance = new MctApi();
        String bpRegNumber = bpRegNumber_example; // String | Business partner registration number
        try {
            array[APIRequest] result = apiInstance.getBusinessPartnerRequests(bpRegNumber);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MctApi#getBusinessPartnerRequests");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MctApi;

public class MctApiExample {

    public static void main(String[] args) {
        MctApi apiInstance = new MctApi();
        String bpRegNumber = bpRegNumber_example; // String | Business partner registration number
        try {
            array[APIRequest] result = apiInstance.getBusinessPartnerRequests(bpRegNumber);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MctApi#getBusinessPartnerRequests");
            e.printStackTrace();
        }
    }
}

String *bpRegNumber = bpRegNumber_example; // Business partner registration number

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

// List of business partner requests (with messages).
[apiInstance getBusinessPartnerRequestsWith:bpRegNumber
              completionHandler: ^(array[APIRequest] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EmpiricaMctApi = require('empirica_mct_api');

var api = new EmpiricaMctApi.MctApi()

var bpRegNumber = bpRegNumber_example; // {String} Business partner registration number


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

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

namespace Example
{
    public class getBusinessPartnerRequestsExample
    {
        public void main()
        {
            
            var apiInstance = new MctApi();
            var bpRegNumber = bpRegNumber_example;  // String | Business partner registration number

            try
            {
                // List of business partner requests (with messages).
                array[APIRequest] result = apiInstance.getBusinessPartnerRequests(bpRegNumber);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MctApi.getBusinessPartnerRequests: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\MctApi();
$bpRegNumber = bpRegNumber_example; // String | Business partner registration number

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

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

my $api_instance = WWW::SwaggerClient::MctApi->new();
my $bpRegNumber = bpRegNumber_example; # String | Business partner registration number

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

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

# create an instance of the API class
api_instance = swagger_client.MctApi()
bpRegNumber = bpRegNumber_example # String | Business partner registration number

try: 
    # List of business partner requests (with messages).
    api_response = api_instance.get_business_partner_requests(bpRegNumber)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MctApi->getBusinessPartnerRequests: %s\n" % e)

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

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

public class MctApiExample {

    public static void main(String[] args) {
        
        MctApi apiInstance = new MctApi();
        String reqNumber = reqNumber_example; // String | Request number
        try {
            apiInstance.performRequestCancel(reqNumber);
        } catch (ApiException e) {
            System.err.println("Exception when calling MctApi#performRequestCancel");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MctApi;

public class MctApiExample {

    public static void main(String[] args) {
        MctApi apiInstance = new MctApi();
        String reqNumber = reqNumber_example; // String | Request number
        try {
            apiInstance.performRequestCancel(reqNumber);
        } catch (ApiException e) {
            System.err.println("Exception when calling MctApi#performRequestCancel");
            e.printStackTrace();
        }
    }
}

String *reqNumber = reqNumber_example; // Request number

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

// Perform actions to complete request cancellation.
[apiInstance performRequestCancelWith:reqNumber
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EmpiricaMctApi = require('empirica_mct_api');

var api = new EmpiricaMctApi.MctApi()

var reqNumber = reqNumber_example; // {String} Request number


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

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

namespace Example
{
    public class performRequestCancelExample
    {
        public void main()
        {
            
            var apiInstance = new MctApi();
            var reqNumber = reqNumber_example;  // String | Request number

            try
            {
                // Perform actions to complete request cancellation.
                apiInstance.performRequestCancel(reqNumber);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MctApi.performRequestCancel: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\MctApi();
$reqNumber = reqNumber_example; // String | Request number

try {
    $api_instance->performRequestCancel($reqNumber);
} catch (Exception $e) {
    echo 'Exception when calling MctApi->performRequestCancel: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::MctApi->new();
my $reqNumber = reqNumber_example; # String | Request number

eval { 
    $api_instance->performRequestCancel(reqNumber => $reqNumber);
};
if ($@) {
    warn "Exception when calling MctApi->performRequestCancel: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.MctApi()
reqNumber = reqNumber_example # String | Request number

try: 
    # Perform actions to complete request cancellation.
    api_instance.perform_request_cancel(reqNumber)
except ApiException as e:
    print("Exception when calling MctApi->performRequestCancel: %s\n" % e)

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

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

public class MctApiExample {

    public static void main(String[] args) {
        
        MctApi apiInstance = new MctApi();
        String type = type_example; // String | Type - one of [UTILMD, APERAK, MSCONS, INVOIC]
        String subj = subj_example; // String | Subject in format transaction-eicDeliveryPoint-freeText
        String body = body_example; // String | Message body
        try {
            apiInstance.registerMessage(type, subj, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling MctApi#registerMessage");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MctApi;

public class MctApiExample {

    public static void main(String[] args) {
        MctApi apiInstance = new MctApi();
        String type = type_example; // String | Type - one of [UTILMD, APERAK, MSCONS, INVOIC]
        String subj = subj_example; // String | Subject in format transaction-eicDeliveryPoint-freeText
        String body = body_example; // String | Message body
        try {
            apiInstance.registerMessage(type, subj, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling MctApi#registerMessage");
            e.printStackTrace();
        }
    }
}

String *type = type_example; // Type - one of [UTILMD, APERAK, MSCONS, INVOIC]
String *subj = subj_example; // Subject in format transaction-eicDeliveryPoint-freeText
String *body = body_example; // Message body (optional)

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

// Register XML message and assign it to the request.
[apiInstance registerMessageWith:type
    subj:subj
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EmpiricaMctApi = require('empirica_mct_api');

var api = new EmpiricaMctApi.MctApi()

var type = type_example; // {String} Type - one of [UTILMD, APERAK, MSCONS, INVOIC]

var subj = subj_example; // {String} Subject in format transaction-eicDeliveryPoint-freeText

var opts = { 
  'body': body_example // {String} Message body
};

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

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

namespace Example
{
    public class registerMessageExample
    {
        public void main()
        {
            
            var apiInstance = new MctApi();
            var type = type_example;  // String | Type - one of [UTILMD, APERAK, MSCONS, INVOIC]
            var subj = subj_example;  // String | Subject in format transaction-eicDeliveryPoint-freeText
            var body = body_example;  // String | Message body (optional) 

            try
            {
                // Register XML message and assign it to the request.
                apiInstance.registerMessage(type, subj, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MctApi.registerMessage: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\MctApi();
$type = type_example; // String | Type - one of [UTILMD, APERAK, MSCONS, INVOIC]
$subj = subj_example; // String | Subject in format transaction-eicDeliveryPoint-freeText
$body = body_example; // String | Message body

try {
    $api_instance->registerMessage($type, $subj, $body);
} catch (Exception $e) {
    echo 'Exception when calling MctApi->registerMessage: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::MctApi->new();
my $type = type_example; # String | Type - one of [UTILMD, APERAK, MSCONS, INVOIC]
my $subj = subj_example; # String | Subject in format transaction-eicDeliveryPoint-freeText
my $body = WWW::SwaggerClient::Object::String->new(); # String | Message body

eval { 
    $api_instance->registerMessage(type => $type, subj => $subj, body => $body);
};
if ($@) {
    warn "Exception when calling MctApi->registerMessage: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.MctApi()
type = type_example # String | Type - one of [UTILMD, APERAK, MSCONS, INVOIC]
subj = subj_example # String | Subject in format transaction-eicDeliveryPoint-freeText
body = body_example # String | Message body (optional)

try: 
    # Register XML message and assign it to the request.
    api_instance.register_message(type, subj, body=body)
except ApiException as e:
    print("Exception when calling MctApi->registerMessage: %s\n" % e)

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

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

public class MctApiExample {

    public static void main(String[] args) {
        
        MctApi apiInstance = new MctApi();
        String reqNumber = reqNumber_example; // String | Request number
        Date cancelTime = 2013-10-20T19:20:30+01:00; // Date | Registration time of cancellation
        String author = author_example; // String | Registration author
        String amendment = amendment_example; // String | Amendment number
        try {
            apiInstance.registerRequestCancellation(reqNumber, cancelTime, author, amendment);
        } catch (ApiException e) {
            System.err.println("Exception when calling MctApi#registerRequestCancellation");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MctApi;

public class MctApiExample {

    public static void main(String[] args) {
        MctApi apiInstance = new MctApi();
        String reqNumber = reqNumber_example; // String | Request number
        Date cancelTime = 2013-10-20T19:20:30+01:00; // Date | Registration time of cancellation
        String author = author_example; // String | Registration author
        String amendment = amendment_example; // String | Amendment number
        try {
            apiInstance.registerRequestCancellation(reqNumber, cancelTime, author, amendment);
        } catch (ApiException e) {
            System.err.println("Exception when calling MctApi#registerRequestCancellation");
            e.printStackTrace();
        }
    }
}

String *reqNumber = reqNumber_example; // Request number
Date *cancelTime = 2013-10-20T19:20:30+01:00; // Registration time of cancellation
String *author = author_example; // Registration author
String *amendment = amendment_example; // Amendment number (optional)

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

// Register cancellation of existing request.
[apiInstance registerRequestCancellationWith:reqNumber
    cancelTime:cancelTime
    author:author
    amendment:amendment
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EmpiricaMctApi = require('empirica_mct_api');

var api = new EmpiricaMctApi.MctApi()

var reqNumber = reqNumber_example; // {String} Request number

var cancelTime = 2013-10-20T19:20:30+01:00; // {Date} Registration time of cancellation

var author = author_example; // {String} Registration author

var opts = { 
  'amendment': amendment_example // {String} Amendment number
};

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

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

namespace Example
{
    public class registerRequestCancellationExample
    {
        public void main()
        {
            
            var apiInstance = new MctApi();
            var reqNumber = reqNumber_example;  // String | Request number
            var cancelTime = 2013-10-20T19:20:30+01:00;  // Date | Registration time of cancellation
            var author = author_example;  // String | Registration author
            var amendment = amendment_example;  // String | Amendment number (optional) 

            try
            {
                // Register cancellation of existing request.
                apiInstance.registerRequestCancellation(reqNumber, cancelTime, author, amendment);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MctApi.registerRequestCancellation: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\MctApi();
$reqNumber = reqNumber_example; // String | Request number
$cancelTime = 2013-10-20T19:20:30+01:00; // Date | Registration time of cancellation
$author = author_example; // String | Registration author
$amendment = amendment_example; // String | Amendment number

try {
    $api_instance->registerRequestCancellation($reqNumber, $cancelTime, $author, $amendment);
} catch (Exception $e) {
    echo 'Exception when calling MctApi->registerRequestCancellation: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::MctApi->new();
my $reqNumber = reqNumber_example; # String | Request number
my $cancelTime = 2013-10-20T19:20:30+01:00; # Date | Registration time of cancellation
my $author = author_example; # String | Registration author
my $amendment = amendment_example; # String | Amendment number

eval { 
    $api_instance->registerRequestCancellation(reqNumber => $reqNumber, cancelTime => $cancelTime, author => $author, amendment => $amendment);
};
if ($@) {
    warn "Exception when calling MctApi->registerRequestCancellation: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.MctApi()
reqNumber = reqNumber_example # String | Request number
cancelTime = 2013-10-20T19:20:30+01:00 # Date | Registration time of cancellation
author = author_example # String | Registration author
amendment = amendment_example # String | Amendment number (optional)

try: 
    # Register cancellation of existing request.
    api_instance.register_request_cancellation(reqNumber, cancelTime, author, amendment=amendment)
except ApiException as e:
    print("Exception when calling MctApi->registerRequestCancellation: %s\n" % e)

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

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

public class MctApiExample {

    public static void main(String[] args) {
        
        MctApi apiInstance = new MctApi();
        String reqNumber = reqNumber_example; // String | Request number
        String procInstance = procInstance_example; // String | Process instance identifier
        try {
            apiInstance.reprocessRequest(reqNumber, procInstance);
        } catch (ApiException e) {
            System.err.println("Exception when calling MctApi#reprocessRequest");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MctApi;

public class MctApiExample {

    public static void main(String[] args) {
        MctApi apiInstance = new MctApi();
        String reqNumber = reqNumber_example; // String | Request number
        String procInstance = procInstance_example; // String | Process instance identifier
        try {
            apiInstance.reprocessRequest(reqNumber, procInstance);
        } catch (ApiException e) {
            System.err.println("Exception when calling MctApi#reprocessRequest");
            e.printStackTrace();
        }
    }
}

String *reqNumber = reqNumber_example; // Request number
String *procInstance = procInstance_example; // Process instance identifier

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

// Run new process for request. Old process instance set as inactive.
[apiInstance reprocessRequestWith:reqNumber
    procInstance:procInstance
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EmpiricaMctApi = require('empirica_mct_api');

var api = new EmpiricaMctApi.MctApi()

var reqNumber = reqNumber_example; // {String} Request number

var procInstance = procInstance_example; // {String} Process instance identifier


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

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

namespace Example
{
    public class reprocessRequestExample
    {
        public void main()
        {
            
            var apiInstance = new MctApi();
            var reqNumber = reqNumber_example;  // String | Request number
            var procInstance = procInstance_example;  // String | Process instance identifier

            try
            {
                // Run new process for request. Old process instance set as inactive.
                apiInstance.reprocessRequest(reqNumber, procInstance);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MctApi.reprocessRequest: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\MctApi();
$reqNumber = reqNumber_example; // String | Request number
$procInstance = procInstance_example; // String | Process instance identifier

try {
    $api_instance->reprocessRequest($reqNumber, $procInstance);
} catch (Exception $e) {
    echo 'Exception when calling MctApi->reprocessRequest: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::MctApi->new();
my $reqNumber = reqNumber_example; # String | Request number
my $procInstance = procInstance_example; # String | Process instance identifier

eval { 
    $api_instance->reprocessRequest(reqNumber => $reqNumber, procInstance => $procInstance);
};
if ($@) {
    warn "Exception when calling MctApi->reprocessRequest: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.MctApi()
reqNumber = reqNumber_example # String | Request number
procInstance = procInstance_example # String | Process instance identifier

try: 
    # Run new process for request. Old process instance set as inactive.
    api_instance.reprocess_request(reqNumber, procInstance)
except ApiException as e:
    print("Exception when calling MctApi->reprocessRequest: %s\n" % e)

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

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

public class MctApiExample {

    public static void main(String[] args) {
        
        MctApi apiInstance = new MctApi();
        String reqNumber = reqNumber_example; // String | Request number
        String procInstance = procInstance_example; // String | Process instance identifier
        String transaction = transaction_example; // String | Transaction code
        String variant = variant_example; // String | Transaction variant
        Boolean createNew = true; // Boolean | Flag of creation new message (or reusing existing)
        try {
            apiInstance.sendMessageToPDS(reqNumber, procInstance, transaction, variant, createNew);
        } catch (ApiException e) {
            System.err.println("Exception when calling MctApi#sendMessageToPDS");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MctApi;

public class MctApiExample {

    public static void main(String[] args) {
        MctApi apiInstance = new MctApi();
        String reqNumber = reqNumber_example; // String | Request number
        String procInstance = procInstance_example; // String | Process instance identifier
        String transaction = transaction_example; // String | Transaction code
        String variant = variant_example; // String | Transaction variant
        Boolean createNew = true; // Boolean | Flag of creation new message (or reusing existing)
        try {
            apiInstance.sendMessageToPDS(reqNumber, procInstance, transaction, variant, createNew);
        } catch (ApiException e) {
            System.err.println("Exception when calling MctApi#sendMessageToPDS");
            e.printStackTrace();
        }
    }
}

String *reqNumber = reqNumber_example; // Request number
String *procInstance = procInstance_example; // Process instance identifier
String *transaction = transaction_example; // Transaction code
String *variant = variant_example; // Transaction variant (optional)
Boolean *createNew = true; // Flag of creation new message (or reusing existing) (optional)

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

// Send message to distributor.
[apiInstance sendMessageToPDSWith:reqNumber
    procInstance:procInstance
    transaction:transaction
    variant:variant
    createNew:createNew
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EmpiricaMctApi = require('empirica_mct_api');

var api = new EmpiricaMctApi.MctApi()

var reqNumber = reqNumber_example; // {String} Request number

var procInstance = procInstance_example; // {String} Process instance identifier

var transaction = transaction_example; // {String} Transaction code

var opts = { 
  'variant': variant_example, // {String} Transaction variant
  'createNew': true // {Boolean} Flag of creation new message (or reusing existing)
};

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

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

namespace Example
{
    public class sendMessageToPDSExample
    {
        public void main()
        {
            
            var apiInstance = new MctApi();
            var reqNumber = reqNumber_example;  // String | Request number
            var procInstance = procInstance_example;  // String | Process instance identifier
            var transaction = transaction_example;  // String | Transaction code
            var variant = variant_example;  // String | Transaction variant (optional) 
            var createNew = true;  // Boolean | Flag of creation new message (or reusing existing) (optional) 

            try
            {
                // Send message to distributor.
                apiInstance.sendMessageToPDS(reqNumber, procInstance, transaction, variant, createNew);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MctApi.sendMessageToPDS: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\MctApi();
$reqNumber = reqNumber_example; // String | Request number
$procInstance = procInstance_example; // String | Process instance identifier
$transaction = transaction_example; // String | Transaction code
$variant = variant_example; // String | Transaction variant
$createNew = true; // Boolean | Flag of creation new message (or reusing existing)

try {
    $api_instance->sendMessageToPDS($reqNumber, $procInstance, $transaction, $variant, $createNew);
} catch (Exception $e) {
    echo 'Exception when calling MctApi->sendMessageToPDS: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::MctApi->new();
my $reqNumber = reqNumber_example; # String | Request number
my $procInstance = procInstance_example; # String | Process instance identifier
my $transaction = transaction_example; # String | Transaction code
my $variant = variant_example; # String | Transaction variant
my $createNew = true; # Boolean | Flag of creation new message (or reusing existing)

eval { 
    $api_instance->sendMessageToPDS(reqNumber => $reqNumber, procInstance => $procInstance, transaction => $transaction, variant => $variant, createNew => $createNew);
};
if ($@) {
    warn "Exception when calling MctApi->sendMessageToPDS: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.MctApi()
reqNumber = reqNumber_example # String | Request number
procInstance = procInstance_example # String | Process instance identifier
transaction = transaction_example # String | Transaction code
variant = variant_example # String | Transaction variant (optional)
createNew = true # Boolean | Flag of creation new message (or reusing existing) (optional)

try: 
    # Send message to distributor.
    api_instance.send_message_to_pds(reqNumber, procInstance, transaction, variant=variant, createNew=createNew)
except ApiException as e:
    print("Exception when calling MctApi->sendMessageToPDS: %s\n" % e)

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

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

public class MctApiExample {

    public static void main(String[] args) {
        
        MctApi apiInstance = new MctApi();
        String reqNumber = reqNumber_example; // String | Request number
        try {
            apiInstance.terminateRequest(reqNumber);
        } catch (ApiException e) {
            System.err.println("Exception when calling MctApi#terminateRequest");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.MctApi;

public class MctApiExample {

    public static void main(String[] args) {
        MctApi apiInstance = new MctApi();
        String reqNumber = reqNumber_example; // String | Request number
        try {
            apiInstance.terminateRequest(reqNumber);
        } catch (ApiException e) {
            System.err.println("Exception when calling MctApi#terminateRequest");
            e.printStackTrace();
        }
    }
}

String *reqNumber = reqNumber_example; // Request number

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

// Terminate request
[apiInstance terminateRequestWith:reqNumber
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var EmpiricaMctApi = require('empirica_mct_api');

var api = new EmpiricaMctApi.MctApi()

var reqNumber = reqNumber_example; // {String} Request number


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

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

namespace Example
{
    public class terminateRequestExample
    {
        public void main()
        {
            
            var apiInstance = new MctApi();
            var reqNumber = reqNumber_example;  // String | Request number

            try
            {
                // Terminate request
                apiInstance.terminateRequest(reqNumber);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling MctApi.terminateRequest: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\Api\MctApi();
$reqNumber = reqNumber_example; // String | Request number

try {
    $api_instance->terminateRequest($reqNumber);
} catch (Exception $e) {
    echo 'Exception when calling MctApi->terminateRequest: ', $e->getMessage(), PHP_EOL;
}
?>

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

my $api_instance = WWW::SwaggerClient::MctApi->new();
my $reqNumber = reqNumber_example; # String | Request number

eval { 
    $api_instance->terminateRequest(reqNumber => $reqNumber);
};
if ($@) {
    warn "Exception when calling MctApi->terminateRequest: $@\n";
}

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

# create an instance of the API class
api_instance = swagger_client.MctApi()
reqNumber = reqNumber_example # String | Request number

try: 
    # Terminate request
    api_instance.terminate_request(reqNumber)
except ApiException as e:
    print("Exception when calling MctApi->terminateRequest: %s\n" % e)