import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountsPayableApi;

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

public class AccountsPayableApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AccountsPayableApi apiInstance = new AccountsPayableApi();

        try {
            AgedPayables result = apiInstance.aPGETAgedPayables();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETAgedPayables");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.aPGETAgedPayables();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->aPGETAgedPayables: $e\n');
}

import org.openapitools.client.api.AccountsPayableApi;

public class AccountsPayableApiExample {
    public static void main(String[] args) {
        AccountsPayableApi apiInstance = new AccountsPayableApi();

        try {
            AgedPayables result = apiInstance.aPGETAgedPayables();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETAgedPayables");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AccountsPayableApi *apiInstance = [[AccountsPayableApi alloc] init];

// AP_GET_AgedPayables
[apiInstance aPGETAgedPayablesWithCompletionHandler: 
              ^(AgedPayables output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.AccountsPayableApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.aPGETAgedPayables(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AccountsPayableApi();

            try {
                // AP_GET_AgedPayables
                AgedPayables result = apiInstance.aPGETAgedPayables();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsPayableApi.aPGETAgedPayables: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsPayableApi();

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AccountsPayableApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AccountsPayableApi->new();

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

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

# Create an instance of the API class
api_instance = openapi_client.AccountsPayableApi()

try:
    # AP_GET_AgedPayables
    api_response = api_instance.a_pget_aged_payables()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsPayableApi->aPGETAgedPayables: %s\n" % e)

extern crate AccountsPayableApi;

pub fn main() {

    let mut context = AccountsPayableApi::Context::default();
    let result = client.aPGETAgedPayables(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountsPayableApi;

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

public class AccountsPayableApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AccountsPayableApi apiInstance = new AccountsPayableApi();
        UUID batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            Batch result = apiInstance.aPGETBatch(batchGuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETBatch");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID batchGuid = new UUID(); // UUID | 

try {
    final result = await api_instance.aPGETBatch(batchGuid);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->aPGETBatch: $e\n');
}

import org.openapitools.client.api.AccountsPayableApi;

public class AccountsPayableApiExample {
    public static void main(String[] args) {
        AccountsPayableApi apiInstance = new AccountsPayableApi();
        UUID batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            Batch result = apiInstance.aPGETBatch(batchGuid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETBatch");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AccountsPayableApi *apiInstance = [[AccountsPayableApi alloc] init];
UUID *batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// AP_GET_Batch
[apiInstance aPGETBatchWith:batchGuid
              completionHandler: ^(Batch output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.AccountsPayableApi()
var batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AccountsPayableApi();
            var batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // AP_GET_Batch
                Batch result = apiInstance.aPGETBatch(batchGuid);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsPayableApi.aPGETBatch: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsPayableApi();
$batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AccountsPayableApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AccountsPayableApi->new();
my $batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

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

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

# Create an instance of the API class
api_instance = openapi_client.AccountsPayableApi()
batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # AP_GET_Batch
    api_response = api_instance.a_pget_batch(batchGuid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsPayableApi->aPGETBatch: %s\n" % e)

extern crate AccountsPayableApi;

pub fn main() {
    let batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = AccountsPayableApi::Context::default();
    let result = client.aPGETBatch(batchGuid, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountsPayableApi;

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

public class AccountsPayableApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AccountsPayableApi apiInstance = new AccountsPayableApi();
        UUID batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String statuses = statuses_example; // String | 
        UUID createdbyGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UUID approvedbyGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String paymentMethod = paymentMethod_example; // String | 
        String filterByDate = filterByDate_example; // String | 
        Date fromDate = 2013-10-20T19:20:30+01:00; // Date | 
        Date toDate = 2013-10-20T19:20:30+01:00; // Date | 

        try {
            Batches result = apiInstance.aPGETBatches(batchGuid, statuses, createdbyGuid, approvedbyGuid, paymentMethod, filterByDate, fromDate, toDate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETBatches");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID batchGuid = new UUID(); // UUID | 
final String statuses = new String(); // String | 
final UUID createdbyGuid = new UUID(); // UUID | 
final UUID approvedbyGuid = new UUID(); // UUID | 
final String paymentMethod = new String(); // String | 
final String filterByDate = new String(); // String | 
final Date fromDate = new Date(); // Date | 
final Date toDate = new Date(); // Date | 

try {
    final result = await api_instance.aPGETBatches(batchGuid, statuses, createdbyGuid, approvedbyGuid, paymentMethod, filterByDate, fromDate, toDate);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->aPGETBatches: $e\n');
}

import org.openapitools.client.api.AccountsPayableApi;

public class AccountsPayableApiExample {
    public static void main(String[] args) {
        AccountsPayableApi apiInstance = new AccountsPayableApi();
        UUID batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String statuses = statuses_example; // String | 
        UUID createdbyGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UUID approvedbyGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String paymentMethod = paymentMethod_example; // String | 
        String filterByDate = filterByDate_example; // String | 
        Date fromDate = 2013-10-20T19:20:30+01:00; // Date | 
        Date toDate = 2013-10-20T19:20:30+01:00; // Date | 

        try {
            Batches result = apiInstance.aPGETBatches(batchGuid, statuses, createdbyGuid, approvedbyGuid, paymentMethod, filterByDate, fromDate, toDate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETBatches");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AccountsPayableApi *apiInstance = [[AccountsPayableApi alloc] init];
UUID *batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (optional) (default to null)
String *statuses = statuses_example; //  (optional) (default to null)
UUID *createdbyGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (optional) (default to null)
UUID *approvedbyGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (optional) (default to null)
String *paymentMethod = paymentMethod_example; //  (optional) (default to null)
String *filterByDate = filterByDate_example; //  (optional) (default to null)
Date *fromDate = 2013-10-20T19:20:30+01:00; //  (optional) (default to null)
Date *toDate = 2013-10-20T19:20:30+01:00; //  (optional) (default to null)

// AP_GET_Batches
[apiInstance aPGETBatchesWith:batchGuid
    statuses:statuses
    createdbyGuid:createdbyGuid
    approvedbyGuid:approvedbyGuid
    paymentMethod:paymentMethod
    filterByDate:filterByDate
    fromDate:fromDate
    toDate:toDate
              completionHandler: ^(Batches output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.AccountsPayableApi()
var opts = {
  'batchGuid': 38400000-8cf0-11bd-b23e-10b96e4ef00d, // {UUID} 
  'statuses': statuses_example, // {String} 
  'createdbyGuid': 38400000-8cf0-11bd-b23e-10b96e4ef00d, // {UUID} 
  'approvedbyGuid': 38400000-8cf0-11bd-b23e-10b96e4ef00d, // {UUID} 
  'paymentMethod': paymentMethod_example, // {String} 
  'filterByDate': filterByDate_example, // {String} 
  'fromDate': 2013-10-20T19:20:30+01:00, // {Date} 
  'toDate': 2013-10-20T19:20:30+01:00 // {Date} 
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AccountsPayableApi();
            var batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (optional)  (default to null)
            var statuses = statuses_example;  // String |  (optional)  (default to null)
            var createdbyGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (optional)  (default to null)
            var approvedbyGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (optional)  (default to null)
            var paymentMethod = paymentMethod_example;  // String |  (optional)  (default to null)
            var filterByDate = filterByDate_example;  // String |  (optional)  (default to null)
            var fromDate = 2013-10-20T19:20:30+01:00;  // Date |  (optional)  (default to null)
            var toDate = 2013-10-20T19:20:30+01:00;  // Date |  (optional)  (default to null)

            try {
                // AP_GET_Batches
                Batches result = apiInstance.aPGETBatches(batchGuid, statuses, createdbyGuid, approvedbyGuid, paymentMethod, filterByDate, fromDate, toDate);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsPayableApi.aPGETBatches: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsPayableApi();
$batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$statuses = statuses_example; // String | 
$createdbyGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$approvedbyGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$paymentMethod = paymentMethod_example; // String | 
$filterByDate = filterByDate_example; // String | 
$fromDate = 2013-10-20T19:20:30+01:00; // Date | 
$toDate = 2013-10-20T19:20:30+01:00; // Date | 

try {
    $result = $api_instance->aPGETBatches($batchGuid, $statuses, $createdbyGuid, $approvedbyGuid, $paymentMethod, $filterByDate, $fromDate, $toDate);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AccountsPayableApi->aPGETBatches: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AccountsPayableApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AccountsPayableApi->new();
my $batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $statuses = statuses_example; # String | 
my $createdbyGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $approvedbyGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $paymentMethod = paymentMethod_example; # String | 
my $filterByDate = filterByDate_example; # String | 
my $fromDate = 2013-10-20T19:20:30+01:00; # Date | 
my $toDate = 2013-10-20T19:20:30+01:00; # Date | 

eval {
    my $result = $api_instance->aPGETBatches(batchGuid => $batchGuid, statuses => $statuses, createdbyGuid => $createdbyGuid, approvedbyGuid => $approvedbyGuid, paymentMethod => $paymentMethod, filterByDate => $filterByDate, fromDate => $fromDate, toDate => $toDate);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountsPayableApi->aPGETBatches: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.AccountsPayableApi()
batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (optional) (default to null)
statuses = statuses_example # String |  (optional) (default to null)
createdbyGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (optional) (default to null)
approvedbyGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (optional) (default to null)
paymentMethod = paymentMethod_example # String |  (optional) (default to null)
filterByDate = filterByDate_example # String |  (optional) (default to null)
fromDate = 2013-10-20T19:20:30+01:00 # Date |  (optional) (default to null)
toDate = 2013-10-20T19:20:30+01:00 # Date |  (optional) (default to null)

try:
    # AP_GET_Batches
    api_response = api_instance.a_pget_batches(batchGuid=batchGuid, statuses=statuses, createdbyGuid=createdbyGuid, approvedbyGuid=approvedbyGuid, paymentMethod=paymentMethod, filterByDate=filterByDate, fromDate=fromDate, toDate=toDate)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsPayableApi->aPGETBatches: %s\n" % e)

extern crate AccountsPayableApi;

pub fn main() {
    let batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let statuses = statuses_example; // String
    let createdbyGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let approvedbyGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let paymentMethod = paymentMethod_example; // String
    let filterByDate = filterByDate_example; // String
    let fromDate = 2013-10-20T19:20:30+01:00; // Date
    let toDate = 2013-10-20T19:20:30+01:00; // Date

    let mut context = AccountsPayableApi::Context::default();
    let result = client.aPGETBatches(batchGuid, statuses, createdbyGuid, approvedbyGuid, paymentMethod, filterByDate, fromDate, toDate, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountsPayableApi;

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

public class AccountsPayableApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AccountsPayableApi apiInstance = new AccountsPayableApi();
        UUID creditNoteGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            CreditNote result = apiInstance.aPGETCreditNote(creditNoteGUID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETCreditNote");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID creditNoteGUID = new UUID(); // UUID | 

try {
    final result = await api_instance.aPGETCreditNote(creditNoteGUID);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->aPGETCreditNote: $e\n');
}

import org.openapitools.client.api.AccountsPayableApi;

public class AccountsPayableApiExample {
    public static void main(String[] args) {
        AccountsPayableApi apiInstance = new AccountsPayableApi();
        UUID creditNoteGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            CreditNote result = apiInstance.aPGETCreditNote(creditNoteGUID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETCreditNote");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AccountsPayableApi *apiInstance = [[AccountsPayableApi alloc] init];
UUID *creditNoteGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// AP_GET_CreditNote
[apiInstance aPGETCreditNoteWith:creditNoteGUID
              completionHandler: ^(CreditNote output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.AccountsPayableApi()
var creditNoteGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AccountsPayableApi();
            var creditNoteGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // AP_GET_CreditNote
                CreditNote result = apiInstance.aPGETCreditNote(creditNoteGUID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsPayableApi.aPGETCreditNote: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsPayableApi();
$creditNoteGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AccountsPayableApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AccountsPayableApi->new();
my $creditNoteGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

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

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

# Create an instance of the API class
api_instance = openapi_client.AccountsPayableApi()
creditNoteGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # AP_GET_CreditNote
    api_response = api_instance.a_pget_credit_note(creditNoteGUID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsPayableApi->aPGETCreditNote: %s\n" % e)

extern crate AccountsPayableApi;

pub fn main() {
    let creditNoteGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = AccountsPayableApi::Context::default();
    let result = client.aPGETCreditNote(creditNoteGUID, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountsPayableApi;

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

public class AccountsPayableApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AccountsPayableApi apiInstance = new AccountsPayableApi();

        try {
            Batch result = apiInstance.aPGETDraftBatch();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETDraftBatch");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.aPGETDraftBatch();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->aPGETDraftBatch: $e\n');
}

import org.openapitools.client.api.AccountsPayableApi;

public class AccountsPayableApiExample {
    public static void main(String[] args) {
        AccountsPayableApi apiInstance = new AccountsPayableApi();

        try {
            Batch result = apiInstance.aPGETDraftBatch();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETDraftBatch");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AccountsPayableApi *apiInstance = [[AccountsPayableApi alloc] init];

// AP_GET_DraftBatch
[apiInstance aPGETDraftBatchWithCompletionHandler: 
              ^(Batch output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.AccountsPayableApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.aPGETDraftBatch(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AccountsPayableApi();

            try {
                // AP_GET_DraftBatch
                Batch result = apiInstance.aPGETDraftBatch();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsPayableApi.aPGETDraftBatch: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsPayableApi();

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AccountsPayableApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AccountsPayableApi->new();

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

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

# Create an instance of the API class
api_instance = openapi_client.AccountsPayableApi()

try:
    # AP_GET_DraftBatch
    api_response = api_instance.a_pget_draft_batch()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsPayableApi->aPGETDraftBatch: %s\n" % e)

extern crate AccountsPayableApi;

pub fn main() {

    let mut context = AccountsPayableApi::Context::default();
    let result = client.aPGETDraftBatch(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountsPayableApi;

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

public class AccountsPayableApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AccountsPayableApi apiInstance = new AccountsPayableApi();
        UUID purchaseInvoiceGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            PurchaseInvoice result = apiInstance.aPGETPurchaseInvoice(purchaseInvoiceGUID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETPurchaseInvoice");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID purchaseInvoiceGUID = new UUID(); // UUID | 

try {
    final result = await api_instance.aPGETPurchaseInvoice(purchaseInvoiceGUID);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->aPGETPurchaseInvoice: $e\n');
}

import org.openapitools.client.api.AccountsPayableApi;

public class AccountsPayableApiExample {
    public static void main(String[] args) {
        AccountsPayableApi apiInstance = new AccountsPayableApi();
        UUID purchaseInvoiceGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            PurchaseInvoice result = apiInstance.aPGETPurchaseInvoice(purchaseInvoiceGUID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETPurchaseInvoice");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AccountsPayableApi *apiInstance = [[AccountsPayableApi alloc] init];
UUID *purchaseInvoiceGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// AP_GET_PurchaseInvoice
[apiInstance aPGETPurchaseInvoiceWith:purchaseInvoiceGUID
              completionHandler: ^(PurchaseInvoice output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.AccountsPayableApi()
var purchaseInvoiceGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AccountsPayableApi();
            var purchaseInvoiceGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // AP_GET_PurchaseInvoice
                PurchaseInvoice result = apiInstance.aPGETPurchaseInvoice(purchaseInvoiceGUID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsPayableApi.aPGETPurchaseInvoice: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsPayableApi();
$purchaseInvoiceGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AccountsPayableApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AccountsPayableApi->new();
my $purchaseInvoiceGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

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

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

# Create an instance of the API class
api_instance = openapi_client.AccountsPayableApi()
purchaseInvoiceGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # AP_GET_PurchaseInvoice
    api_response = api_instance.a_pget_purchase_invoice(purchaseInvoiceGUID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsPayableApi->aPGETPurchaseInvoice: %s\n" % e)

extern crate AccountsPayableApi;

pub fn main() {
    let purchaseInvoiceGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = AccountsPayableApi::Context::default();
    let result = client.aPGETPurchaseInvoice(purchaseInvoiceGUID, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountsPayableApi;

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

public class AccountsPayableApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AccountsPayableApi apiInstance = new AccountsPayableApi();
        UUID supplierGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            Supplier result = apiInstance.aPGETSupplier(supplierGUID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETSupplier");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID supplierGUID = new UUID(); // UUID | 

try {
    final result = await api_instance.aPGETSupplier(supplierGUID);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->aPGETSupplier: $e\n');
}

import org.openapitools.client.api.AccountsPayableApi;

public class AccountsPayableApiExample {
    public static void main(String[] args) {
        AccountsPayableApi apiInstance = new AccountsPayableApi();
        UUID supplierGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            Supplier result = apiInstance.aPGETSupplier(supplierGUID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETSupplier");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AccountsPayableApi *apiInstance = [[AccountsPayableApi alloc] init];
UUID *supplierGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// AP_GET_Supplier
[apiInstance aPGETSupplierWith:supplierGUID
              completionHandler: ^(Supplier output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.AccountsPayableApi()
var supplierGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AccountsPayableApi();
            var supplierGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // AP_GET_Supplier
                Supplier result = apiInstance.aPGETSupplier(supplierGUID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsPayableApi.aPGETSupplier: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsPayableApi();
$supplierGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AccountsPayableApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AccountsPayableApi->new();
my $supplierGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

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

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

# Create an instance of the API class
api_instance = openapi_client.AccountsPayableApi()
supplierGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # AP_GET_Supplier
    api_response = api_instance.a_pget_supplier(supplierGUID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsPayableApi->aPGETSupplier: %s\n" % e)

extern crate AccountsPayableApi;

pub fn main() {
    let supplierGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = AccountsPayableApi::Context::default();
    let result = client.aPGETSupplier(supplierGUID, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountsPayableApi;

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

public class AccountsPayableApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AccountsPayableApi apiInstance = new AccountsPayableApi();

        try {
            Suppliers result = apiInstance.aPGETSuppliers();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETSuppliers");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.aPGETSuppliers();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->aPGETSuppliers: $e\n');
}

import org.openapitools.client.api.AccountsPayableApi;

public class AccountsPayableApiExample {
    public static void main(String[] args) {
        AccountsPayableApi apiInstance = new AccountsPayableApi();

        try {
            Suppliers result = apiInstance.aPGETSuppliers();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPGETSuppliers");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AccountsPayableApi *apiInstance = [[AccountsPayableApi alloc] init];

// AP_GET_Suppliers
[apiInstance aPGETSuppliersWithCompletionHandler: 
              ^(Suppliers output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.AccountsPayableApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.aPGETSuppliers(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AccountsPayableApi();

            try {
                // AP_GET_Suppliers
                Suppliers result = apiInstance.aPGETSuppliers();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsPayableApi.aPGETSuppliers: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsPayableApi();

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AccountsPayableApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AccountsPayableApi->new();

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

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

# Create an instance of the API class
api_instance = openapi_client.AccountsPayableApi()

try:
    # AP_GET_Suppliers
    api_response = api_instance.a_pget_suppliers()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsPayableApi->aPGETSuppliers: %s\n" % e)

extern crate AccountsPayableApi;

pub fn main() {

    let mut context = AccountsPayableApi::Context::default();
    let result = client.aPGETSuppliers(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountsPayableApi;

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

public class AccountsPayableApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AccountsPayableApi apiInstance = new AccountsPayableApi();
        UUID batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UpdateBatch updateBatch = {"$type":"transactions","updateTransactionsRequest":{"recordVersion":"string","batchTransactions":[{"type":"Customer","guid":"string","amountApplied":0}]}}; // UpdateBatch | 

        try {
            UpdateBatchResponse result = apiInstance.aPPUTBatch(batchGuid, updateBatch);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPPUTBatch");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID batchGuid = new UUID(); // UUID | 
final UpdateBatch updateBatch = new UpdateBatch(); // UpdateBatch | 

try {
    final result = await api_instance.aPPUTBatch(batchGuid, updateBatch);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->aPPUTBatch: $e\n');
}

import org.openapitools.client.api.AccountsPayableApi;

public class AccountsPayableApiExample {
    public static void main(String[] args) {
        AccountsPayableApi apiInstance = new AccountsPayableApi();
        UUID batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UpdateBatch updateBatch = {"$type":"transactions","updateTransactionsRequest":{"recordVersion":"string","batchTransactions":[{"type":"Customer","guid":"string","amountApplied":0}]}}; // UpdateBatch | 

        try {
            UpdateBatchResponse result = apiInstance.aPPUTBatch(batchGuid, updateBatch);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountsPayableApi#aPPUTBatch");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
AccountsPayableApi *apiInstance = [[AccountsPayableApi alloc] init];
UUID *batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
UpdateBatch *updateBatch = {"$type":"transactions","updateTransactionsRequest":{"recordVersion":"string","batchTransactions":[{"type":"Customer","guid":"string","amountApplied":0}]}}; //  (optional)

// AP_PUT_Batch
[apiInstance aPPUTBatchWith:batchGuid
    updateBatch:updateBatch
              completionHandler: ^(UpdateBatchResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.AccountsPayableApi()
var batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var opts = {
  'updateBatch': {"$type":"transactions","updateTransactionsRequest":{"recordVersion":"string","batchTransactions":[{"type":"Customer","guid":"string","amountApplied":0}]}} // {UpdateBatch} 
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new AccountsPayableApi();
            var batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var updateBatch = new UpdateBatch(); // UpdateBatch |  (optional) 

            try {
                // AP_PUT_Batch
                UpdateBatchResponse result = apiInstance.aPPUTBatch(batchGuid, updateBatch);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AccountsPayableApi.aPPUTBatch: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AccountsPayableApi();
$batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$updateBatch = {"$type":"transactions","updateTransactionsRequest":{"recordVersion":"string","batchTransactions":[{"type":"Customer","guid":"string","amountApplied":0}]}}; // UpdateBatch | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AccountsPayableApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AccountsPayableApi->new();
my $batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $updateBatch = WWW::OPenAPIClient::Object::UpdateBatch->new(); # UpdateBatch | 

eval {
    my $result = $api_instance->aPPUTBatch(batchGuid => $batchGuid, updateBatch => $updateBatch);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountsPayableApi->aPPUTBatch: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.AccountsPayableApi()
batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
updateBatch = {"$type":"transactions","updateTransactionsRequest":{"recordVersion":"string","batchTransactions":[{"type":"Customer","guid":"string","amountApplied":0}]}} # UpdateBatch |  (optional)

try:
    # AP_PUT_Batch
    api_response = api_instance.a_pput_batch(batchGuid, updateBatch=updateBatch)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AccountsPayableApi->aPPUTBatch: %s\n" % e)

extern crate AccountsPayableApi;

pub fn main() {
    let batchGuid = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let updateBatch = {"$type":"transactions","updateTransactionsRequest":{"recordVersion":"string","batchTransactions":[{"type":"Customer","guid":"string","amountApplied":0}]}}; // UpdateBatch

    let mut context = AccountsPayableApi::Context::default();
    let result = client.aPPUTBatch(batchGuid, updateBatch, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ConnectHubApi;

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

public class ConnectHubApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ConnectHubApi apiInstance = new ConnectHubApi();

        try {
            Object result = apiInstance.connectHubDELETEConnection();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubDELETEConnection");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.connectHubDELETEConnection();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->connectHubDELETEConnection: $e\n');
}

import org.openapitools.client.api.ConnectHubApi;

public class ConnectHubApiExample {
    public static void main(String[] args) {
        ConnectHubApi apiInstance = new ConnectHubApi();

        try {
            Object result = apiInstance.connectHubDELETEConnection();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubDELETEConnection");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ConnectHubApi *apiInstance = [[ConnectHubApi alloc] init];

// ConnectHub_DELETE_Connection
[apiInstance connectHubDELETEConnectionWithCompletionHandler: 
              ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.ConnectHubApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.connectHubDELETEConnection(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new ConnectHubApi();

            try {
                // ConnectHub_DELETE_Connection
                Object result = apiInstance.connectHubDELETEConnection();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectHubApi.connectHubDELETEConnection: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ConnectHubApi();

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ConnectHubApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ConnectHubApi->new();

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

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

# Create an instance of the API class
api_instance = openapi_client.ConnectHubApi()

try:
    # ConnectHub_DELETE_Connection
    api_response = api_instance.connect_hub_delete_connection()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectHubApi->connectHubDELETEConnection: %s\n" % e)

extern crate ConnectHubApi;

pub fn main() {

    let mut context = ConnectHubApi::Context::default();
    let result = client.connectHubDELETEConnection(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ConnectHubApi;

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

public class ConnectHubApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ConnectHubApi apiInstance = new ConnectHubApi();
        UUID connectionBatchGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            ConnectionBatchResponse result = apiInstance.connectHubGETBatch(connectionBatchGUID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubGETBatch");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID connectionBatchGUID = new UUID(); // UUID | 

try {
    final result = await api_instance.connectHubGETBatch(connectionBatchGUID);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->connectHubGETBatch: $e\n');
}

import org.openapitools.client.api.ConnectHubApi;

public class ConnectHubApiExample {
    public static void main(String[] args) {
        ConnectHubApi apiInstance = new ConnectHubApi();
        UUID connectionBatchGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            ConnectionBatchResponse result = apiInstance.connectHubGETBatch(connectionBatchGUID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubGETBatch");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ConnectHubApi *apiInstance = [[ConnectHubApi alloc] init];
UUID *connectionBatchGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// ConnectHub_GET_Batch
[apiInstance connectHubGETBatchWith:connectionBatchGUID
              completionHandler: ^(ConnectionBatchResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.ConnectHubApi()
var connectionBatchGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new ConnectHubApi();
            var connectionBatchGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // ConnectHub_GET_Batch
                ConnectionBatchResponse result = apiInstance.connectHubGETBatch(connectionBatchGUID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectHubApi.connectHubGETBatch: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ConnectHubApi();
$connectionBatchGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ConnectHubApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ConnectHubApi->new();
my $connectionBatchGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

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

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

# Create an instance of the API class
api_instance = openapi_client.ConnectHubApi()
connectionBatchGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # ConnectHub_GET_Batch
    api_response = api_instance.connect_hub_get_batch(connectionBatchGUID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectHubApi->connectHubGETBatch: %s\n" % e)

extern crate ConnectHubApi;

pub fn main() {
    let connectionBatchGUID = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = ConnectHubApi::Context::default();
    let result = client.connectHubGETBatch(connectionBatchGUID, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ConnectHubApi;

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

public class ConnectHubApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ConnectHubApi apiInstance = new ConnectHubApi();
        Date startDateTimeFrom = 2013-10-20T19:20:30+01:00; // Date | 
        Date startDateTimeTo = 2013-10-20T19:20:30+01:00; // Date | 
        array[BatchStatus] statuses = ; // array[BatchStatus] | 
        array[BatchDirection] directions = ; // array[BatchDirection] | 
        array[DataType] dataTypes = ; // array[DataType] | 

        try {
            ConnectionBatches result = apiInstance.connectHubGETBatches(startDateTimeFrom, startDateTimeTo, statuses, directions, dataTypes);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubGETBatches");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Date startDateTimeFrom = new Date(); // Date | 
final Date startDateTimeTo = new Date(); // Date | 
final array[BatchStatus] statuses = new array[BatchStatus](); // array[BatchStatus] | 
final array[BatchDirection] directions = new array[BatchDirection](); // array[BatchDirection] | 
final array[DataType] dataTypes = new array[DataType](); // array[DataType] | 

try {
    final result = await api_instance.connectHubGETBatches(startDateTimeFrom, startDateTimeTo, statuses, directions, dataTypes);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->connectHubGETBatches: $e\n');
}

import org.openapitools.client.api.ConnectHubApi;

public class ConnectHubApiExample {
    public static void main(String[] args) {
        ConnectHubApi apiInstance = new ConnectHubApi();
        Date startDateTimeFrom = 2013-10-20T19:20:30+01:00; // Date | 
        Date startDateTimeTo = 2013-10-20T19:20:30+01:00; // Date | 
        array[BatchStatus] statuses = ; // array[BatchStatus] | 
        array[BatchDirection] directions = ; // array[BatchDirection] | 
        array[DataType] dataTypes = ; // array[DataType] | 

        try {
            ConnectionBatches result = apiInstance.connectHubGETBatches(startDateTimeFrom, startDateTimeTo, statuses, directions, dataTypes);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubGETBatches");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ConnectHubApi *apiInstance = [[ConnectHubApi alloc] init];
Date *startDateTimeFrom = 2013-10-20T19:20:30+01:00; //  (optional) (default to null)
Date *startDateTimeTo = 2013-10-20T19:20:30+01:00; //  (optional) (default to null)
array[BatchStatus] *statuses = ; //  (optional) (default to null)
array[BatchDirection] *directions = ; //  (optional) (default to null)
array[DataType] *dataTypes = ; //  (optional) (default to null)

// ConnectHub_GET_Batches
[apiInstance connectHubGETBatchesWith:startDateTimeFrom
    startDateTimeTo:startDateTimeTo
    statuses:statuses
    directions:directions
    dataTypes:dataTypes
              completionHandler: ^(ConnectionBatches output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.ConnectHubApi()
var opts = {
  'startDateTimeFrom': 2013-10-20T19:20:30+01:00, // {Date} 
  'startDateTimeTo': 2013-10-20T19:20:30+01:00, // {Date} 
  'statuses': , // {array[BatchStatus]} 
  'directions': , // {array[BatchDirection]} 
  'dataTypes':  // {array[DataType]} 
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new ConnectHubApi();
            var startDateTimeFrom = 2013-10-20T19:20:30+01:00;  // Date |  (optional)  (default to null)
            var startDateTimeTo = 2013-10-20T19:20:30+01:00;  // Date |  (optional)  (default to null)
            var statuses = new array[BatchStatus](); // array[BatchStatus] |  (optional)  (default to null)
            var directions = new array[BatchDirection](); // array[BatchDirection] |  (optional)  (default to null)
            var dataTypes = new array[DataType](); // array[DataType] |  (optional)  (default to null)

            try {
                // ConnectHub_GET_Batches
                ConnectionBatches result = apiInstance.connectHubGETBatches(startDateTimeFrom, startDateTimeTo, statuses, directions, dataTypes);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectHubApi.connectHubGETBatches: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ConnectHubApi();
$startDateTimeFrom = 2013-10-20T19:20:30+01:00; // Date | 
$startDateTimeTo = 2013-10-20T19:20:30+01:00; // Date | 
$statuses = ; // array[BatchStatus] | 
$directions = ; // array[BatchDirection] | 
$dataTypes = ; // array[DataType] | 

try {
    $result = $api_instance->connectHubGETBatches($startDateTimeFrom, $startDateTimeTo, $statuses, $directions, $dataTypes);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ConnectHubApi->connectHubGETBatches: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ConnectHubApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ConnectHubApi->new();
my $startDateTimeFrom = 2013-10-20T19:20:30+01:00; # Date | 
my $startDateTimeTo = 2013-10-20T19:20:30+01:00; # Date | 
my $statuses = []; # array[BatchStatus] | 
my $directions = []; # array[BatchDirection] | 
my $dataTypes = []; # array[DataType] | 

eval {
    my $result = $api_instance->connectHubGETBatches(startDateTimeFrom => $startDateTimeFrom, startDateTimeTo => $startDateTimeTo, statuses => $statuses, directions => $directions, dataTypes => $dataTypes);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ConnectHubApi->connectHubGETBatches: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.ConnectHubApi()
startDateTimeFrom = 2013-10-20T19:20:30+01:00 # Date |  (optional) (default to null)
startDateTimeTo = 2013-10-20T19:20:30+01:00 # Date |  (optional) (default to null)
statuses =  # array[BatchStatus] |  (optional) (default to null)
directions =  # array[BatchDirection] |  (optional) (default to null)
dataTypes =  # array[DataType] |  (optional) (default to null)

try:
    # ConnectHub_GET_Batches
    api_response = api_instance.connect_hub_get_batches(startDateTimeFrom=startDateTimeFrom, startDateTimeTo=startDateTimeTo, statuses=statuses, directions=directions, dataTypes=dataTypes)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectHubApi->connectHubGETBatches: %s\n" % e)

extern crate ConnectHubApi;

pub fn main() {
    let startDateTimeFrom = 2013-10-20T19:20:30+01:00; // Date
    let startDateTimeTo = 2013-10-20T19:20:30+01:00; // Date
    let statuses = ; // array[BatchStatus]
    let directions = ; // array[BatchDirection]
    let dataTypes = ; // array[DataType]

    let mut context = ConnectHubApi::Context::default();
    let result = client.connectHubGETBatches(startDateTimeFrom, startDateTimeTo, statuses, directions, dataTypes, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ConnectHubApi;

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

public class ConnectHubApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ConnectHubApi apiInstance = new ConnectHubApi();

        try {
            ConnectionResponse result = apiInstance.connectHubGETConnection();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubGETConnection");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.connectHubGETConnection();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->connectHubGETConnection: $e\n');
}

import org.openapitools.client.api.ConnectHubApi;

public class ConnectHubApiExample {
    public static void main(String[] args) {
        ConnectHubApi apiInstance = new ConnectHubApi();

        try {
            ConnectionResponse result = apiInstance.connectHubGETConnection();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubGETConnection");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ConnectHubApi *apiInstance = [[ConnectHubApi alloc] init];

// ConnectHub_GET_Connection
[apiInstance connectHubGETConnectionWithCompletionHandler: 
              ^(ConnectionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.ConnectHubApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.connectHubGETConnection(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new ConnectHubApi();

            try {
                // ConnectHub_GET_Connection
                ConnectionResponse result = apiInstance.connectHubGETConnection();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectHubApi.connectHubGETConnection: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ConnectHubApi();

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ConnectHubApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ConnectHubApi->new();

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

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

# Create an instance of the API class
api_instance = openapi_client.ConnectHubApi()

try:
    # ConnectHub_GET_Connection
    api_response = api_instance.connect_hub_get_connection()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectHubApi->connectHubGETConnection: %s\n" % e)

extern crate ConnectHubApi;

pub fn main() {

    let mut context = ConnectHubApi::Context::default();
    let result = client.connectHubGETConnection(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ConnectHubApi;

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

public class ConnectHubApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ConnectHubApi apiInstance = new ConnectHubApi();

        try {
            GetConnectionTypesResponse result = apiInstance.connectHubGETConnectionTypes();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubGETConnectionTypes");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.connectHubGETConnectionTypes();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->connectHubGETConnectionTypes: $e\n');
}

import org.openapitools.client.api.ConnectHubApi;

public class ConnectHubApiExample {
    public static void main(String[] args) {
        ConnectHubApi apiInstance = new ConnectHubApi();

        try {
            GetConnectionTypesResponse result = apiInstance.connectHubGETConnectionTypes();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubGETConnectionTypes");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ConnectHubApi *apiInstance = [[ConnectHubApi alloc] init];

// ConnectHub_GET_ConnectionTypes
[apiInstance connectHubGETConnectionTypesWithCompletionHandler: 
              ^(GetConnectionTypesResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.ConnectHubApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.connectHubGETConnectionTypes(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new ConnectHubApi();

            try {
                // ConnectHub_GET_ConnectionTypes
                GetConnectionTypesResponse result = apiInstance.connectHubGETConnectionTypes();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectHubApi.connectHubGETConnectionTypes: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ConnectHubApi();

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ConnectHubApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ConnectHubApi->new();

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

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

# Create an instance of the API class
api_instance = openapi_client.ConnectHubApi()

try:
    # ConnectHub_GET_ConnectionTypes
    api_response = api_instance.connect_hub_get_connection_types()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectHubApi->connectHubGETConnectionTypes: %s\n" % e)

extern crate ConnectHubApi;

pub fn main() {

    let mut context = ConnectHubApi::Context::default();
    let result = client.connectHubGETConnectionTypes(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ConnectHubApi;

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

public class ConnectHubApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ConnectHubApi apiInstance = new ConnectHubApi();
        UpdateConnection updateConnection = {"$type":"connect","connectRequest":{"oAuthCallbackUri":"string","state":"string"}}; // UpdateConnection | 

        try {
            UpdateConnectionResponse result = apiInstance.connectHubPATCHConnection(updateConnection);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubPATCHConnection");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UpdateConnection updateConnection = new UpdateConnection(); // UpdateConnection | 

try {
    final result = await api_instance.connectHubPATCHConnection(updateConnection);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->connectHubPATCHConnection: $e\n');
}

import org.openapitools.client.api.ConnectHubApi;

public class ConnectHubApiExample {
    public static void main(String[] args) {
        ConnectHubApi apiInstance = new ConnectHubApi();
        UpdateConnection updateConnection = {"$type":"connect","connectRequest":{"oAuthCallbackUri":"string","state":"string"}}; // UpdateConnection | 

        try {
            UpdateConnectionResponse result = apiInstance.connectHubPATCHConnection(updateConnection);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubPATCHConnection");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ConnectHubApi *apiInstance = [[ConnectHubApi alloc] init];
UpdateConnection *updateConnection = {"$type":"connect","connectRequest":{"oAuthCallbackUri":"string","state":"string"}}; //  (optional)

// ConnectHub_PATCH_Connection
[apiInstance connectHubPATCHConnectionWith:updateConnection
              completionHandler: ^(UpdateConnectionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.ConnectHubApi()
var opts = {
  'updateConnection': {"$type":"connect","connectRequest":{"oAuthCallbackUri":"string","state":"string"}} // {UpdateConnection} 
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new ConnectHubApi();
            var updateConnection = new UpdateConnection(); // UpdateConnection |  (optional) 

            try {
                // ConnectHub_PATCH_Connection
                UpdateConnectionResponse result = apiInstance.connectHubPATCHConnection(updateConnection);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectHubApi.connectHubPATCHConnection: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ConnectHubApi();
$updateConnection = {"$type":"connect","connectRequest":{"oAuthCallbackUri":"string","state":"string"}}; // UpdateConnection | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ConnectHubApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ConnectHubApi->new();
my $updateConnection = WWW::OPenAPIClient::Object::UpdateConnection->new(); # UpdateConnection | 

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

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

# Create an instance of the API class
api_instance = openapi_client.ConnectHubApi()
updateConnection = {"$type":"connect","connectRequest":{"oAuthCallbackUri":"string","state":"string"}} # UpdateConnection |  (optional)

try:
    # ConnectHub_PATCH_Connection
    api_response = api_instance.connect_hub_patch_connection(updateConnection=updateConnection)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectHubApi->connectHubPATCHConnection: %s\n" % e)

extern crate ConnectHubApi;

pub fn main() {
    let updateConnection = {"$type":"connect","connectRequest":{"oAuthCallbackUri":"string","state":"string"}}; // UpdateConnection

    let mut context = ConnectHubApi::Context::default();
    let result = client.connectHubPATCHConnection(updateConnection, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ConnectHubApi;

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

public class ConnectHubApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ConnectHubApi apiInstance = new ConnectHubApi();
        CreateConnection createConnection = {"connectionType":"Xero"}; // CreateConnection | 

        try {
            ConnectionResponse result = apiInstance.connectHubPOSTConnection(createConnection);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubPOSTConnection");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateConnection createConnection = new CreateConnection(); // CreateConnection | 

try {
    final result = await api_instance.connectHubPOSTConnection(createConnection);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->connectHubPOSTConnection: $e\n');
}

import org.openapitools.client.api.ConnectHubApi;

public class ConnectHubApiExample {
    public static void main(String[] args) {
        ConnectHubApi apiInstance = new ConnectHubApi();
        CreateConnection createConnection = {"connectionType":"Xero"}; // CreateConnection | 

        try {
            ConnectionResponse result = apiInstance.connectHubPOSTConnection(createConnection);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubPOSTConnection");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ConnectHubApi *apiInstance = [[ConnectHubApi alloc] init];
CreateConnection *createConnection = {"connectionType":"Xero"}; //  (optional)

// ConnectHub_POST_Connection
[apiInstance connectHubPOSTConnectionWith:createConnection
              completionHandler: ^(ConnectionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.ConnectHubApi()
var opts = {
  'createConnection': {"connectionType":"Xero"} // {CreateConnection} 
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new ConnectHubApi();
            var createConnection = new CreateConnection(); // CreateConnection |  (optional) 

            try {
                // ConnectHub_POST_Connection
                ConnectionResponse result = apiInstance.connectHubPOSTConnection(createConnection);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectHubApi.connectHubPOSTConnection: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ConnectHubApi();
$createConnection = {"connectionType":"Xero"}; // CreateConnection | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ConnectHubApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ConnectHubApi->new();
my $createConnection = WWW::OPenAPIClient::Object::CreateConnection->new(); # CreateConnection | 

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

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

# Create an instance of the API class
api_instance = openapi_client.ConnectHubApi()
createConnection = {"connectionType":"Xero"} # CreateConnection |  (optional)

try:
    # ConnectHub_POST_Connection
    api_response = api_instance.connect_hub_post_connection(createConnection=createConnection)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectHubApi->connectHubPOSTConnection: %s\n" % e)

extern crate ConnectHubApi;

pub fn main() {
    let createConnection = {"connectionType":"Xero"}; // CreateConnection

    let mut context = ConnectHubApi::Context::default();
    let result = client.connectHubPOSTConnection(createConnection, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ConnectHubApi;

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

public class ConnectHubApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ConnectHubApi apiInstance = new ConnectHubApi();
        ImportDataType dataType = ; // ImportDataType | 

        try {
            Object result = apiInstance.connectHubTestingDELETEData(dataType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubTestingDELETEData");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ImportDataType dataType = new ImportDataType(); // ImportDataType | 

try {
    final result = await api_instance.connectHubTestingDELETEData(dataType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->connectHubTestingDELETEData: $e\n');
}

import org.openapitools.client.api.ConnectHubApi;

public class ConnectHubApiExample {
    public static void main(String[] args) {
        ConnectHubApi apiInstance = new ConnectHubApi();
        ImportDataType dataType = ; // ImportDataType | 

        try {
            Object result = apiInstance.connectHubTestingDELETEData(dataType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubTestingDELETEData");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ConnectHubApi *apiInstance = [[ConnectHubApi alloc] init];
ImportDataType *dataType = ; //  (default to null)

// ConnectHub_Testing_DELETE_Data
[apiInstance connectHubTestingDELETEDataWith:dataType
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.ConnectHubApi()
var dataType = ; // {ImportDataType} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new ConnectHubApi();
            var dataType = new ImportDataType(); // ImportDataType |  (default to null)

            try {
                // ConnectHub_Testing_DELETE_Data
                Object result = apiInstance.connectHubTestingDELETEData(dataType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectHubApi.connectHubTestingDELETEData: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ConnectHubApi();
$dataType = ; // ImportDataType | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ConnectHubApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ConnectHubApi->new();
my $dataType = ; # ImportDataType | 

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

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

# Create an instance of the API class
api_instance = openapi_client.ConnectHubApi()
dataType =  # ImportDataType |  (default to null)

try:
    # ConnectHub_Testing_DELETE_Data
    api_response = api_instance.connect_hub_testing_delete_data(dataType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectHubApi->connectHubTestingDELETEData: %s\n" % e)

extern crate ConnectHubApi;

pub fn main() {
    let dataType = ; // ImportDataType

    let mut context = ConnectHubApi::Context::default();
    let result = client.connectHubTestingDELETEData(dataType, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ConnectHubApi;

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

public class ConnectHubApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ConnectHubApi apiInstance = new ConnectHubApi();
        SetOperatingModeRequest setOperatingModeRequest = {"operatingMode":"Normal"}; // SetOperatingModeRequest | 

        try {
            SetOperatingModeResponse result = apiInstance.connectHubTestingPATCHConnection(setOperatingModeRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubTestingPATCHConnection");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SetOperatingModeRequest setOperatingModeRequest = new SetOperatingModeRequest(); // SetOperatingModeRequest | 

try {
    final result = await api_instance.connectHubTestingPATCHConnection(setOperatingModeRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->connectHubTestingPATCHConnection: $e\n');
}

import org.openapitools.client.api.ConnectHubApi;

public class ConnectHubApiExample {
    public static void main(String[] args) {
        ConnectHubApi apiInstance = new ConnectHubApi();
        SetOperatingModeRequest setOperatingModeRequest = {"operatingMode":"Normal"}; // SetOperatingModeRequest | 

        try {
            SetOperatingModeResponse result = apiInstance.connectHubTestingPATCHConnection(setOperatingModeRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubTestingPATCHConnection");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ConnectHubApi *apiInstance = [[ConnectHubApi alloc] init];
SetOperatingModeRequest *setOperatingModeRequest = {"operatingMode":"Normal"}; //  (optional)

// ConnectHub_Testing_PATCH_Connection
[apiInstance connectHubTestingPATCHConnectionWith:setOperatingModeRequest
              completionHandler: ^(SetOperatingModeResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.ConnectHubApi()
var opts = {
  'setOperatingModeRequest': {"operatingMode":"Normal"} // {SetOperatingModeRequest} 
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new ConnectHubApi();
            var setOperatingModeRequest = new SetOperatingModeRequest(); // SetOperatingModeRequest |  (optional) 

            try {
                // ConnectHub_Testing_PATCH_Connection
                SetOperatingModeResponse result = apiInstance.connectHubTestingPATCHConnection(setOperatingModeRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectHubApi.connectHubTestingPATCHConnection: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ConnectHubApi();
$setOperatingModeRequest = {"operatingMode":"Normal"}; // SetOperatingModeRequest | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ConnectHubApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ConnectHubApi->new();
my $setOperatingModeRequest = WWW::OPenAPIClient::Object::SetOperatingModeRequest->new(); # SetOperatingModeRequest | 

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

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

# Create an instance of the API class
api_instance = openapi_client.ConnectHubApi()
setOperatingModeRequest = {"operatingMode":"Normal"} # SetOperatingModeRequest |  (optional)

try:
    # ConnectHub_Testing_PATCH_Connection
    api_response = api_instance.connect_hub_testing_patch_connection(setOperatingModeRequest=setOperatingModeRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectHubApi->connectHubTestingPATCHConnection: %s\n" % e)

extern crate ConnectHubApi;

pub fn main() {
    let setOperatingModeRequest = {"operatingMode":"Normal"}; // SetOperatingModeRequest

    let mut context = ConnectHubApi::Context::default();
    let result = client.connectHubTestingPATCHConnection(setOperatingModeRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ConnectHubApi;

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

public class ConnectHubApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ConnectHubApi apiInstance = new ConnectHubApi();
        WriteTestDataRequest writeTestDataRequest = {"dataType":"Supplier","jsonValues":["string"]}; // WriteTestDataRequest | 

        try {
            Object result = apiInstance.connectHubTestingPOSTData(writeTestDataRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubTestingPOSTData");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final WriteTestDataRequest writeTestDataRequest = new WriteTestDataRequest(); // WriteTestDataRequest | 

try {
    final result = await api_instance.connectHubTestingPOSTData(writeTestDataRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->connectHubTestingPOSTData: $e\n');
}

import org.openapitools.client.api.ConnectHubApi;

public class ConnectHubApiExample {
    public static void main(String[] args) {
        ConnectHubApi apiInstance = new ConnectHubApi();
        WriteTestDataRequest writeTestDataRequest = {"dataType":"Supplier","jsonValues":["string"]}; // WriteTestDataRequest | 

        try {
            Object result = apiInstance.connectHubTestingPOSTData(writeTestDataRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ConnectHubApi#connectHubTestingPOSTData");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
ConnectHubApi *apiInstance = [[ConnectHubApi alloc] init];
WriteTestDataRequest *writeTestDataRequest = {"dataType":"Supplier","jsonValues":["string"]}; //  (optional)

// ConnectHub_Testing_POST_Data
[apiInstance connectHubTestingPOSTDataWith:writeTestDataRequest
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.ConnectHubApi()
var opts = {
  'writeTestDataRequest': {"dataType":"Supplier","jsonValues":["string"]} // {WriteTestDataRequest} 
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new ConnectHubApi();
            var writeTestDataRequest = new WriteTestDataRequest(); // WriteTestDataRequest |  (optional) 

            try {
                // ConnectHub_Testing_POST_Data
                Object result = apiInstance.connectHubTestingPOSTData(writeTestDataRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ConnectHubApi.connectHubTestingPOSTData: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ConnectHubApi();
$writeTestDataRequest = {"dataType":"Supplier","jsonValues":["string"]}; // WriteTestDataRequest | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ConnectHubApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ConnectHubApi->new();
my $writeTestDataRequest = WWW::OPenAPIClient::Object::WriteTestDataRequest->new(); # WriteTestDataRequest | 

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

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

# Create an instance of the API class
api_instance = openapi_client.ConnectHubApi()
writeTestDataRequest = {"dataType":"Supplier","jsonValues":["string"]} # WriteTestDataRequest |  (optional)

try:
    # ConnectHub_Testing_POST_Data
    api_response = api_instance.connect_hub_testing_post_data(writeTestDataRequest=writeTestDataRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ConnectHubApi->connectHubTestingPOSTData: %s\n" % e)

extern crate ConnectHubApi;

pub fn main() {
    let writeTestDataRequest = {"dataType":"Supplier","jsonValues":["string"]}; // WriteTestDataRequest

    let mut context = ConnectHubApi::Context::default();
    let result = client.connectHubTestingPOSTData(writeTestDataRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.TestingApi;

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

public class TestingApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        TestingApi apiInstance = new TestingApi();
        ImportDataType dataType = ; // ImportDataType | 

        try {
            Object result = apiInstance.connectHubTestingDELETEData(dataType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TestingApi#connectHubTestingDELETEData");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ImportDataType dataType = new ImportDataType(); // ImportDataType | 

try {
    final result = await api_instance.connectHubTestingDELETEData(dataType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->connectHubTestingDELETEData: $e\n');
}

import org.openapitools.client.api.TestingApi;

public class TestingApiExample {
    public static void main(String[] args) {
        TestingApi apiInstance = new TestingApi();
        ImportDataType dataType = ; // ImportDataType | 

        try {
            Object result = apiInstance.connectHubTestingDELETEData(dataType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TestingApi#connectHubTestingDELETEData");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
TestingApi *apiInstance = [[TestingApi alloc] init];
ImportDataType *dataType = ; //  (default to null)

// ConnectHub_Testing_DELETE_Data
[apiInstance connectHubTestingDELETEDataWith:dataType
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.TestingApi()
var dataType = ; // {ImportDataType} 

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new TestingApi();
            var dataType = new ImportDataType(); // ImportDataType |  (default to null)

            try {
                // ConnectHub_Testing_DELETE_Data
                Object result = apiInstance.connectHubTestingDELETEData(dataType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TestingApi.connectHubTestingDELETEData: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TestingApi();
$dataType = ; // ImportDataType | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::TestingApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TestingApi->new();
my $dataType = ; # ImportDataType | 

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

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

# Create an instance of the API class
api_instance = openapi_client.TestingApi()
dataType =  # ImportDataType |  (default to null)

try:
    # ConnectHub_Testing_DELETE_Data
    api_response = api_instance.connect_hub_testing_delete_data(dataType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TestingApi->connectHubTestingDELETEData: %s\n" % e)

extern crate TestingApi;

pub fn main() {
    let dataType = ; // ImportDataType

    let mut context = TestingApi::Context::default();
    let result = client.connectHubTestingDELETEData(dataType, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.TestingApi;

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

public class TestingApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        TestingApi apiInstance = new TestingApi();
        SetOperatingModeRequest setOperatingModeRequest = {"operatingMode":"Normal"}; // SetOperatingModeRequest | 

        try {
            SetOperatingModeResponse result = apiInstance.connectHubTestingPATCHConnection(setOperatingModeRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TestingApi#connectHubTestingPATCHConnection");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SetOperatingModeRequest setOperatingModeRequest = new SetOperatingModeRequest(); // SetOperatingModeRequest | 

try {
    final result = await api_instance.connectHubTestingPATCHConnection(setOperatingModeRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->connectHubTestingPATCHConnection: $e\n');
}

import org.openapitools.client.api.TestingApi;

public class TestingApiExample {
    public static void main(String[] args) {
        TestingApi apiInstance = new TestingApi();
        SetOperatingModeRequest setOperatingModeRequest = {"operatingMode":"Normal"}; // SetOperatingModeRequest | 

        try {
            SetOperatingModeResponse result = apiInstance.connectHubTestingPATCHConnection(setOperatingModeRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TestingApi#connectHubTestingPATCHConnection");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
TestingApi *apiInstance = [[TestingApi alloc] init];
SetOperatingModeRequest *setOperatingModeRequest = {"operatingMode":"Normal"}; //  (optional)

// ConnectHub_Testing_PATCH_Connection
[apiInstance connectHubTestingPATCHConnectionWith:setOperatingModeRequest
              completionHandler: ^(SetOperatingModeResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.TestingApi()
var opts = {
  'setOperatingModeRequest': {"operatingMode":"Normal"} // {SetOperatingModeRequest} 
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new TestingApi();
            var setOperatingModeRequest = new SetOperatingModeRequest(); // SetOperatingModeRequest |  (optional) 

            try {
                // ConnectHub_Testing_PATCH_Connection
                SetOperatingModeResponse result = apiInstance.connectHubTestingPATCHConnection(setOperatingModeRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TestingApi.connectHubTestingPATCHConnection: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TestingApi();
$setOperatingModeRequest = {"operatingMode":"Normal"}; // SetOperatingModeRequest | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::TestingApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TestingApi->new();
my $setOperatingModeRequest = WWW::OPenAPIClient::Object::SetOperatingModeRequest->new(); # SetOperatingModeRequest | 

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

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

# Create an instance of the API class
api_instance = openapi_client.TestingApi()
setOperatingModeRequest = {"operatingMode":"Normal"} # SetOperatingModeRequest |  (optional)

try:
    # ConnectHub_Testing_PATCH_Connection
    api_response = api_instance.connect_hub_testing_patch_connection(setOperatingModeRequest=setOperatingModeRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TestingApi->connectHubTestingPATCHConnection: %s\n" % e)

extern crate TestingApi;

pub fn main() {
    let setOperatingModeRequest = {"operatingMode":"Normal"}; // SetOperatingModeRequest

    let mut context = TestingApi::Context::default();
    let result = client.connectHubTestingPATCHConnection(setOperatingModeRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.TestingApi;

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

public class TestingApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        TestingApi apiInstance = new TestingApi();
        WriteTestDataRequest writeTestDataRequest = {"dataType":"Supplier","jsonValues":["string"]}; // WriteTestDataRequest | 

        try {
            Object result = apiInstance.connectHubTestingPOSTData(writeTestDataRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TestingApi#connectHubTestingPOSTData");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final WriteTestDataRequest writeTestDataRequest = new WriteTestDataRequest(); // WriteTestDataRequest | 

try {
    final result = await api_instance.connectHubTestingPOSTData(writeTestDataRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->connectHubTestingPOSTData: $e\n');
}

import org.openapitools.client.api.TestingApi;

public class TestingApiExample {
    public static void main(String[] args) {
        TestingApi apiInstance = new TestingApi();
        WriteTestDataRequest writeTestDataRequest = {"dataType":"Supplier","jsonValues":["string"]}; // WriteTestDataRequest | 

        try {
            Object result = apiInstance.connectHubTestingPOSTData(writeTestDataRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TestingApi#connectHubTestingPOSTData");
            e.printStackTrace();
        }
    }
}

// Create an instance of the API class
TestingApi *apiInstance = [[TestingApi alloc] init];
WriteTestDataRequest *writeTestDataRequest = {"dataType":"Supplier","jsonValues":["string"]}; //  (optional)

// ConnectHub_Testing_POST_Data
[apiInstance connectHubTestingPOSTDataWith:writeTestDataRequest
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var SpendaApi = require('spenda_api');

// Create an instance of the API class
var api = new SpendaApi.TestingApi()
var opts = {
  'writeTestDataRequest': {"dataType":"Supplier","jsonValues":["string"]} // {WriteTestDataRequest} 
};

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

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new TestingApi();
            var writeTestDataRequest = new WriteTestDataRequest(); // WriteTestDataRequest |  (optional) 

            try {
                // ConnectHub_Testing_POST_Data
                Object result = apiInstance.connectHubTestingPOSTData(writeTestDataRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TestingApi.connectHubTestingPOSTData: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TestingApi();
$writeTestDataRequest = {"dataType":"Supplier","jsonValues":["string"]}; // WriteTestDataRequest | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::TestingApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TestingApi->new();
my $writeTestDataRequest = WWW::OPenAPIClient::Object::WriteTestDataRequest->new(); # WriteTestDataRequest | 

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

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

# Create an instance of the API class
api_instance = openapi_client.TestingApi()
writeTestDataRequest = {"dataType":"Supplier","jsonValues":["string"]} # WriteTestDataRequest |  (optional)

try:
    # ConnectHub_Testing_POST_Data
    api_response = api_instance.connect_hub_testing_post_data(writeTestDataRequest=writeTestDataRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TestingApi->connectHubTestingPOSTData: %s\n" % e)

extern crate TestingApi;

pub fn main() {
    let writeTestDataRequest = {"dataType":"Supplier","jsonValues":["string"]}; // WriteTestDataRequest

    let mut context = TestingApi::Context::default();
    let result = client.connectHubTestingPOSTData(writeTestDataRequest, &context).wait();

    println!("{:?}", result);
}