import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        Account account = new Account();
        account.setCode("123456");
        account.setName("FooBar");
        account.setType(com.xero.models.accounting.AccountType.EXPENSE);
        account.setDescription("Hello World");

        try {
            Accounts result = apiInstance.createAccount(accessToken, xeroTenantId, account);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createAccount");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        Account account = { "Code":"123456", "Name":"Foobar", "Type":"EXPENSE", "Description":"Hello World" }; // Account | 
        try {
            Accounts result = apiInstance.createAccount(xeroTenantId, account);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createAccount");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
Account *account = { "Code":"123456", "Name":"Foobar", "Type":"EXPENSE", "Description":"Hello World" }; // 

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

// Creates a new chart of accounts
[apiInstance createAccountWith:xeroTenantId
    account:account
              completionHandler: ^(Accounts output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const account: Account = { code: "123456", name: "Foobar", type: AccountType.EXPENSE, description: "Hello World" }

try {
  const response = await xero.accountingApi.createAccount(xeroTenantId, account);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var account = new Account(); // Account | 

            try
            {
                // Creates a new chart of accounts
                Accounts result = apiInstance.createAccount(xeroTenantId, account);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createAccount: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";

$account = new XeroAPI\XeroPHP\Models\Accounting\Account;
$account->setCode('123456');
$account->setName('FooBar');
$account->setType(XeroAPI\XeroPHP\Models\Accounting\AccountType::EXPENSE);
$account->setDescription('Hello World');

try {
  $result = $apiInstance->createAccount($xeroTenantId, $account);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createAccount: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $account = ::Object::Account->new(); # Account | 

eval { 
    my $result = $api_instance->createAccount(xeroTenantId => $xeroTenantId, account => $account);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createAccount: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_account():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'

    account = Account(
        code = "123456",
        name = "FooBar",
        type = AccountType.EXPENSE,
        description = "Hello World")
    
    try:
        api_response = api_instance.create_account(xeroTenantId, account)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createAccount: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let account = { "Code":"123456", "Name":"Foobar", "Type":"EXPENSE", "Description":"Hello World" }; // Account

    let mut context = AccountingApi::Context::default();
    let result = client.createAccount(xeroTenantId, account, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID accountID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        String fileName = "xero-dev.jpg";
        File input = new File("/path/to/local/xero-dev.jpg");
        java.nio.file.Path inputPath = input.toPath();
        byte[] body = FileUtils.readFileToByteArray(input);
        String mimeType = Files.probeContentType(inputPath);

        try {
            Attachments result = apiInstance.createAccountAttachmentByFileName(accessToken, xeroTenantId, accountID, fileName, body, mimeType);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createAccountAttachmentByFileName");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID accountID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for Account object
        String fileName = xero-dev.jpg; // String | Name of the attachment
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 
        try {
            Attachments result = apiInstance.createAccountAttachmentByFileName(xeroTenantId, accountID, fileName, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createAccountAttachmentByFileName");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *accountID = 00000000-0000-0000-0000-000000000000; // Unique identifier for Account object (default to null)
String *fileName = xero-dev.jpg; // Name of the attachment (default to null)
byte[] *body = BYTE_ARRAY_DATA_HERE; // 

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

// Creates an attachment on a specific account
[apiInstance createAccountAttachmentByFileNameWith:xeroTenantId
    accountID:accountID
    fileName:fileName
    body:body
              completionHandler: ^(Attachments output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const accountID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for Account object
const fileName = "xero-dev.jpg";  // {String} Name of the attachment
const path = require("path");
const mime = require("mime-types");
const pathToUpload = path.resolve(__dirname, "../public/images/xero-dev.jpg"); // determine the path to your file
import * as fs from "fs";
const body = fs.createReadStream(pathToUpload); // {fs.ReadStream} read the file
const contentType = mime.lookup(fileName);

try {
  const response = await xero.accountingApi.createAccountAttachmentByFileName(xeroTenantId, accountID, fileName, body, {
    headers: {
      "Content-Type": contentType,
    }
  });
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var accountID = new UUID(); // UUID | Unique identifier for Account object (default to null)
            var fileName = xero-dev.jpg;  // String | Name of the attachment (default to null)
            var body = BYTE_ARRAY_DATA_HERE;  // byte[] | 

            try
            {
                // Creates an attachment on a specific account
                Attachments result = apiInstance.createAccountAttachmentByFileName(xeroTenantId, accountID, fileName, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createAccountAttachmentByFileName: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$accountID = "00000000-0000-0000-0000-000000000000";
$fileName = "xero-dev.jpg";

$handle = fopen($fileName, "r");
$body = fread($handle, filesize($fileName));
fclose($handle);

try {
  $result = $apiInstance->createAccountAttachmentByFileName($xeroTenantId, $accountID, $fileName, $body);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createAccountAttachmentByFileName: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $accountID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for Account object
my $fileName = xero-dev.jpg; # String | Name of the attachment
my $body = ::Object::byte[]->new(); # byte[] | 

eval { 
    my $result = $api_instance->createAccountAttachmentByFileName(xeroTenantId => $xeroTenantId, accountID => $accountID, fileName => $fileName, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createAccountAttachmentByFileName: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_account_attachment_by_file_name():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    accountID = '00000000-0000-0000-0000-000000000000'
    fileName = 'xero-dev.jpg'
    
        // TODO: BINARY CREATE 
    try:
        api_response = api_instance.create_account_attachment_by_file_name(xeroTenantId, accountID, fileName, body)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createAccountAttachmentByFileName: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let accountID = 00000000-0000-0000-0000-000000000000; // UUID
    let fileName = xero-dev.jpg; // String
    let body = BYTE_ARRAY_DATA_HERE; // byte[]

    let mut context = AccountingApi::Context::default();
    let result = client.createAccountAttachmentByFileName(xeroTenantId, accountID, fileName, body, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID bankTransactionID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        String fileName = "xero-dev.jpg";
        File input = new File("/path/to/local/xero-dev.jpg");
        java.nio.file.Path inputPath = input.toPath();
        byte[] body = FileUtils.readFileToByteArray(input);
        String mimeType = Files.probeContentType(inputPath);

        try {
            Attachments result = apiInstance.createBankTransactionAttachmentByFileName(accessToken, xeroTenantId, bankTransactionID, fileName, body, mimeType);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createBankTransactionAttachmentByFileName");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID bankTransactionID = 00000000-0000-0000-0000-000000000000; // UUID | Xero generated unique identifier for a bank transaction
        String fileName = xero-dev.jpg; // String | The name of the file being attached
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 
        try {
            Attachments result = apiInstance.createBankTransactionAttachmentByFileName(xeroTenantId, bankTransactionID, fileName, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createBankTransactionAttachmentByFileName");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *bankTransactionID = 00000000-0000-0000-0000-000000000000; // Xero generated unique identifier for a bank transaction (default to null)
String *fileName = xero-dev.jpg; // The name of the file being attached (default to null)
byte[] *body = BYTE_ARRAY_DATA_HERE; // 

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

// Creates an attachment for a specific bank transaction by filename
[apiInstance createBankTransactionAttachmentByFileNameWith:xeroTenantId
    bankTransactionID:bankTransactionID
    fileName:fileName
    body:body
              completionHandler: ^(Attachments output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const bankTransactionID = "00000000-0000-0000-0000-000000000000";  // {UUID} Xero generated unique identifier for a bank transaction
const fileName = "xero-dev.jpg";  // {String} The name of the file being attached
const path = require("path");
const mime = require("mime-types");
const pathToUpload = path.resolve(__dirname, "../public/images/xero-dev.jpg"); // determine the path to your file
import * as fs from "fs";
const body = fs.createReadStream(pathToUpload); // {fs.ReadStream} read the file
const contentType = mime.lookup(fileName);

try {
  const response = await xero.accountingApi.createBankTransactionAttachmentByFileName(xeroTenantId, bankTransactionID, fileName, body, {
    headers: {
      "Content-Type": contentType,
    }
  });
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var bankTransactionID = new UUID(); // UUID | Xero generated unique identifier for a bank transaction (default to null)
            var fileName = xero-dev.jpg;  // String | The name of the file being attached (default to null)
            var body = BYTE_ARRAY_DATA_HERE;  // byte[] | 

            try
            {
                // Creates an attachment for a specific bank transaction by filename
                Attachments result = apiInstance.createBankTransactionAttachmentByFileName(xeroTenantId, bankTransactionID, fileName, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createBankTransactionAttachmentByFileName: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$bankTransactionID = "00000000-0000-0000-0000-000000000000";
$fileName = "xero-dev.jpg";

$handle = fopen($fileName, "r");
$body = fread($handle, filesize($fileName));
fclose($handle);

try {
  $result = $apiInstance->createBankTransactionAttachmentByFileName($xeroTenantId, $bankTransactionID, $fileName, $body);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createBankTransactionAttachmentByFileName: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $bankTransactionID = 00000000-0000-0000-0000-000000000000; # UUID | Xero generated unique identifier for a bank transaction
my $fileName = xero-dev.jpg; # String | The name of the file being attached
my $body = ::Object::byte[]->new(); # byte[] | 

eval { 
    my $result = $api_instance->createBankTransactionAttachmentByFileName(xeroTenantId => $xeroTenantId, bankTransactionID => $bankTransactionID, fileName => $fileName, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createBankTransactionAttachmentByFileName: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_bank_transaction_attachment_by_file_name():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    bankTransactionID = '00000000-0000-0000-0000-000000000000'
    fileName = 'xero-dev.jpg'
    
        // TODO: BINARY CREATE 
    try:
        api_response = api_instance.create_bank_transaction_attachment_by_file_name(xeroTenantId, bankTransactionID, fileName, body)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createBankTransactionAttachmentByFileName: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let bankTransactionID = 00000000-0000-0000-0000-000000000000; // UUID
    let fileName = xero-dev.jpg; // String
    let body = BYTE_ARRAY_DATA_HERE; // byte[]

    let mut context = AccountingApi::Context::default();
    let result = client.createBankTransactionAttachmentByFileName(xeroTenantId, bankTransactionID, fileName, body, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID bankTransactionID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

        try {
            HistoryRecords result = apiInstance.createBankTransactionHistoryRecord(accessToken, xeroTenantId, bankTransactionID, historyRecords);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createBankTransactionHistoryRecord");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID bankTransactionID = 00000000-0000-0000-0000-000000000000; // UUID | Xero generated unique identifier for a bank transaction
        HistoryRecords historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords | 
        try {
            HistoryRecords result = apiInstance.createBankTransactionHistoryRecord(xeroTenantId, bankTransactionID, historyRecords);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createBankTransactionHistoryRecord");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *bankTransactionID = 00000000-0000-0000-0000-000000000000; // Xero generated unique identifier for a bank transaction (default to null)
HistoryRecords *historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // 

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

// Creates a history record for a specific bank transactions
[apiInstance createBankTransactionHistoryRecordWith:xeroTenantId
    bankTransactionID:bankTransactionID
    historyRecords:historyRecords
              completionHandler: ^(HistoryRecords output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);
const historyRecords: HistoryRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] };  // {HistoryRecords} 
const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const bankTransactionID = "00000000-0000-0000-0000-000000000000";  // {UUID} Xero generated unique identifier for a bank transaction


try {
  const response = await xero.accountingApi.createBankTransactionHistoryRecord(xeroTenantId, bankTransactionID, historyRecords);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var bankTransactionID = new UUID(); // UUID | Xero generated unique identifier for a bank transaction (default to null)
            var historyRecords = new HistoryRecords(); // HistoryRecords | 

            try
            {
                // Creates a history record for a specific bank transactions
                HistoryRecords result = apiInstance.createBankTransactionHistoryRecord(xeroTenantId, bankTransactionID, historyRecords);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createBankTransactionHistoryRecord: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$bankTransactionID = "00000000-0000-0000-0000-000000000000";

$historyRecord = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecord;
$historyRecord->setDetails('Hello World');

$historyRecords = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecords;
$arr_history_records = [];
array_push($arr_history_records, $historyRecord);
$historyRecords->setHistoryRecords($arr_history_records);

try {
  $result = $apiInstance->createBankTransactionHistoryRecord($xeroTenantId, $bankTransactionID, $historyRecords);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createBankTransactionHistoryRecord: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $bankTransactionID = 00000000-0000-0000-0000-000000000000; # UUID | Xero generated unique identifier for a bank transaction
my $historyRecords = ::Object::HistoryRecords->new(); # HistoryRecords | 

eval { 
    my $result = $api_instance->createBankTransactionHistoryRecord(xeroTenantId => $xeroTenantId, bankTransactionID => $bankTransactionID, historyRecords => $historyRecords);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createBankTransactionHistoryRecord: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_bank_transaction_history_record():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    bankTransactionID = '00000000-0000-0000-0000-000000000000'

    history_record = HistoryRecord(
        details = "Hello World")

    history_records = HistoryRecords( 
        history_records = [history_record])
    
    try:
        api_response = api_instance.create_bank_transaction_history_record(xeroTenantId, bankTransactionID, historyRecords)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createBankTransactionHistoryRecord: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let bankTransactionID = 00000000-0000-0000-0000-000000000000; // UUID
    let historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords

    let mut context = AccountingApi::Context::default();
    let result = client.createBankTransactionHistoryRecord(xeroTenantId, bankTransactionID, historyRecords, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        Boolean summarizeErrors = true;
        Integer unitdp = 4;
        Contact contact = new Contact();
        contact.setContactID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        LineItem lineItem = new LineItem();
        lineItem.setDescription("Foobar");
        lineItem.setQuantity(1.0);
        lineItem.setUnitAmount(20.0);
        lineItem.setAccountCode("000");
        List<LineItems> lineItems = new ArrayList<LineItems>();
        lineItems.add(lineItem);
        Account bankAccount = new Account();
        bankAccount.setAccountID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        BankTransaction bankTransaction = new BankTransaction();
        bankTransaction.setType(com.xero.models.accounting.BankTransaction.TypeEnum.RECEIVE);
        bankTransaction.setContact(contact);
        bankTransaction.setBankAccount(bankAccount);
        bankTransaction.setLineItems(lineItems);
        BankTransactions bankTransactions = new BankTransactions();
        bankTransactions.addBankTransactionsItem(bankTransaction);

        try {
            BankTransactions result = apiInstance.createBankTransactions(accessToken, xeroTenantId, bankTransactions, summarizeErrors, unitdp);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createBankTransactions");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        BankTransactions bankTransactions = { bankTransactions: [{ type: BankTransaction.TypeEnum.SPEND, contact: { contactID: "00000000-0000-0000-0000-000000000000" }, lineItems: [{ description: "Foobar", quantity: 1.0, unitAmount: 20.0, accountCode: "000" } ], bankAccount: { code: "000" }}]}; // BankTransactions | 
        Boolean summarizeErrors = true; // Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors
        Integer unitdp = 4; // Integer | e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts
        try {
            BankTransactions result = apiInstance.createBankTransactions(xeroTenantId, bankTransactions, summarizeErrors, unitdp);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createBankTransactions");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
BankTransactions *bankTransactions = { bankTransactions: [{ type: BankTransaction.TypeEnum.SPEND, contact: { contactID: "00000000-0000-0000-0000-000000000000" }, lineItems: [{ description: "Foobar", quantity: 1.0, unitAmount: 20.0, accountCode: "000" } ], bankAccount: { code: "000" }}]}; // 
Boolean *summarizeErrors = true; // If false return 200 OK and mix of successfully created objects and any with validation errors (optional) (default to false)
Integer *unitdp = 4; // e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts (optional) (default to null)

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

// Creates one or more spent or received money transaction
[apiInstance createBankTransactionsWith:xeroTenantId
    bankTransactions:bankTransactions
    summarizeErrors:summarizeErrors
    unitdp:unitdp
              completionHandler: ^(BankTransactions output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant


const summarizeErrors = true;  // {Boolean} If false return 200 OK and mix of successfully created objects and any with validation errors

const unitdp = 4;  // {Integer} e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts
const bankTransactions: BankTransactions = { bankTransactions: [{ type: BankTransaction.TypeEnum.SPEND, contact: { contactID: "00000000-0000-0000-0000-000000000000" }, lineItems: [{ description: "Foobar", quantity: 1.0, unitAmount: 20.0, accountCode: "000" } ], bankAccount: { code: "000" }}]}

try {
  const response = await xero.accountingApi.createBankTransactions(xeroTenantId, bankTransactions,  summarizeErrors, unitdp);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var bankTransactions = new BankTransactions(); // BankTransactions | 
            var summarizeErrors = true;  // Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors (optional)  (default to false)
            var unitdp = 4;  // Integer | e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts (optional)  (default to null)

            try
            {
                // Creates one or more spent or received money transaction
                BankTransactions result = apiInstance.createBankTransactions(xeroTenantId, bankTransactions, summarizeErrors, unitdp);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createBankTransactions: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$summarizeErrors = true;
$unitdp = 4;

$contact = new XeroAPI\XeroPHP\Models\Accounting\Contact;
$contact->setContactID('00000000-0000-0000-0000-000000000000');

$lineItem = new XeroAPI\XeroPHP\Models\Accounting\LineItem;
$lineItem->setDescription('Foobar');
$lineItem->setQuantity(1.0);
$lineItem->setUnitAmount(20.0);
$lineItem->setAccountCode('000');
$lineItems = [];
array_push($lineItems, $lineItem);

$bankAccount = new XeroAPI\XeroPHP\Models\Accounting\Account;
$bankAccount->setAccountID('00000000-0000-0000-0000-000000000000');

$bankTransaction = new XeroAPI\XeroPHP\Models\Accounting\BankTransaction;
$bankTransaction->setType(XeroAPI\XeroPHP\Models\Accounting\BankTransaction::TYPE_RECEIVE);
$bankTransaction->setContact($contact);
$bankTransaction->setBankAccount($bankAccount);
$bankTransaction->setLineItems($lineItems);

$bankTransactions = new XeroAPI\XeroPHP\Models\Accounting\BankTransactions;
$arr_bank_transactions = [];
array_push($arr_bank_transactions, $bankTransaction);
$bankTransactions->setBankTransactions($arr_bank_transactions);

try {
  $result = $apiInstance->createBankTransactions($xeroTenantId, $bankTransactions, $summarizeErrors, $unitdp);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createBankTransactions: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $bankTransactions = ::Object::BankTransactions->new(); # BankTransactions | 
my $summarizeErrors = true; # Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors
my $unitdp = 4; # Integer | e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts

eval { 
    my $result = $api_instance->createBankTransactions(xeroTenantId => $xeroTenantId, bankTransactions => $bankTransactions, summarizeErrors => $summarizeErrors, unitdp => $unitdp);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createBankTransactions: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_bank_transactions():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    summarizeErrors = 'True'

    contact = Contact(
        contact_id = "00000000-0000-0000-0000-000000000000")

    line_item = LineItem(
        description = "Foobar",
        quantity = 1.0,
        unit_amount = 20.0,
        account_code = "000")
    
    line_items = []    
    line_items.append(line_item)

    bank_account = Account(
        account_id = "00000000-0000-0000-0000-000000000000")

    bank_transaction = BankTransaction(
        type = "RECEIVE",
        contact = contact,
        bank_account = bank_account)
        lineItems = lineItems,

    bankTransactions = BankTransactions( 
        bank_transactions = [bank_transaction])
    
    try:
        api_response = api_instance.create_bank_transactions(xeroTenantId, bankTransactions, summarizeErrors, unitdp)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createBankTransactions: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let bankTransactions = { bankTransactions: [{ type: BankTransaction.TypeEnum.SPEND, contact: { contactID: "00000000-0000-0000-0000-000000000000" }, lineItems: [{ description: "Foobar", quantity: 1.0, unitAmount: 20.0, accountCode: "000" } ], bankAccount: { code: "000" }}]}; // BankTransactions
    let summarizeErrors = true; // Boolean
    let unitdp = 4; // Integer

    let mut context = AccountingApi::Context::default();
    let result = client.createBankTransactions(xeroTenantId, bankTransactions, summarizeErrors, unitdp, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        Account fromBankAccount = new Account();
        fromBankAccount.setAccountID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        Account toBankAccount = new Account();
        toBankAccount.setAccountID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        BankTransfer bankTransfer = new BankTransfer();
        bankTransfer.setFromBankAccount(fromBankAccount);
        bankTransfer.setToBankAccount(toBankAccount);
        bankTransfer.setAmount(1.0);
        BankTransfers bankTransfers = new BankTransfers();
        bankTransfers.addBankTransfersItem(bankTransfer);

        try {
            BankTransfers result = apiInstance.createBankTransfer(accessToken, xeroTenantId, bankTransfers);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createBankTransfer");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        BankTransfers bankTransfers = { "BankTransfers": [ { "FromBankAccount": { "Code": "090", "Name": "My Savings", "AccountID": "00000000-0000-0000-0000-000000000000", "Type": "BANK", "BankAccountNumber": "123455", "Status": "ACTIVE", "BankAccountType": "BANK", "CurrencyCode": "USD", "TaxType": "NONE", "EnablePaymentsToAccount": false, "ShowInExpenseClaims": false, "Class": "ASSET", "ReportingCode": "ASS", "ReportingCodeName": "Assets", "HasAttachments": false, "UpdatedDateUTC": "2016-10-17T13:45:33.993-07:00" }, "ToBankAccount": { "Code": "088", "Name": "Business Wells Fargo", "AccountID": "00000000-0000-0000-0000-000000000000", "Type": "BANK", "BankAccountNumber": "123455", "Status": "ACTIVE", "BankAccountType": "BANK", "CurrencyCode": "USD", "TaxType": "NONE", "EnablePaymentsToAccount": false, "ShowInExpenseClaims": false, "Class": "ASSET", "ReportingCode": "ASS", "ReportingCodeName": "Assets", "HasAttachments": false, "UpdatedDateUTC": "2016-06-03T08:31:14.517-07:00" }, "Amount": "50.00" } ] }; // BankTransfers | 
        try {
            BankTransfers result = apiInstance.createBankTransfer(xeroTenantId, bankTransfers);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createBankTransfer");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
BankTransfers *bankTransfers = { "BankTransfers": [ { "FromBankAccount": { "Code": "090", "Name": "My Savings", "AccountID": "00000000-0000-0000-0000-000000000000", "Type": "BANK", "BankAccountNumber": "123455", "Status": "ACTIVE", "BankAccountType": "BANK", "CurrencyCode": "USD", "TaxType": "NONE", "EnablePaymentsToAccount": false, "ShowInExpenseClaims": false, "Class": "ASSET", "ReportingCode": "ASS", "ReportingCodeName": "Assets", "HasAttachments": false, "UpdatedDateUTC": "2016-10-17T13:45:33.993-07:00" }, "ToBankAccount": { "Code": "088", "Name": "Business Wells Fargo", "AccountID": "00000000-0000-0000-0000-000000000000", "Type": "BANK", "BankAccountNumber": "123455", "Status": "ACTIVE", "BankAccountType": "BANK", "CurrencyCode": "USD", "TaxType": "NONE", "EnablePaymentsToAccount": false, "ShowInExpenseClaims": false, "Class": "ASSET", "ReportingCode": "ASS", "ReportingCodeName": "Assets", "HasAttachments": false, "UpdatedDateUTC": "2016-06-03T08:31:14.517-07:00" }, "Amount": "50.00" } ] }; // 

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

// Creates a bank transfer
[apiInstance createBankTransferWith:xeroTenantId
    bankTransfers:bankTransfers
              completionHandler: ^(BankTransfers output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const bankTransfers: BankTransfers = { bankTransfers: [{ fromBankAccount: { code: "000", accountID: "00000000-0000-0000-0000-000000000000" }, toBankAccount: { code: "001", accountID: "00000000-0000-0000-0000-000000000000" }, amount: "50.00" }]}

try {
  const response = await xero.accountingApi.createBankTransfer(xeroTenantId, bankTransfers);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var bankTransfers = new BankTransfers(); // BankTransfers | 

            try
            {
                // Creates a bank transfer
                BankTransfers result = apiInstance.createBankTransfer(xeroTenantId, bankTransfers);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createBankTransfer: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";

$fromBankAccount = new XeroAPI\XeroPHP\Models\Accounting\Account;
$fromBankAccount->setAccountID('00000000-0000-0000-0000-000000000000');

$toBankAccount = new XeroAPI\XeroPHP\Models\Accounting\Account;
$toBankAccount->setAccountID('00000000-0000-0000-0000-000000000000');

$bankTransfer = new XeroAPI\XeroPHP\Models\Accounting\BankTransfer;
$bankTransfer->setFromBankAccount($fromBankAccount);
$bankTransfer->setToBankAccount($toBankAccount);
$bankTransfer->setAmount(1.0);

$bankTransfers = new XeroAPI\XeroPHP\Models\Accounting\BankTransfers;
$arr_bank_transfers = [];
array_push($arr_bank_transfers, $bankTransfer);
$bankTransfers->setBankTransfers($arr_bank_transfers);

try {
  $result = $apiInstance->createBankTransfer($xeroTenantId, $bankTransfers);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createBankTransfer: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $bankTransfers = ::Object::BankTransfers->new(); # BankTransfers | 

eval { 
    my $result = $api_instance->createBankTransfer(xeroTenantId => $xeroTenantId, bankTransfers => $bankTransfers);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createBankTransfer: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_bank_transfer():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'

    fromBankAccount = Account(
        account_id = "00000000-0000-0000-0000-000000000000")

    toBankAccount = Account(
        account_id = "00000000-0000-0000-0000-000000000000")

    bank_transfer = BankTransfer(
        from_bank_account = fromBankAccount,
        to_bank_account = toBankAccount,
        amount = 1.0)

    bankTransfers = BankTransfers( 
        bank_transfers = [bank_transfer])
    
    try:
        api_response = api_instance.create_bank_transfer(xeroTenantId, bankTransfers)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createBankTransfer: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let bankTransfers = { "BankTransfers": [ { "FromBankAccount": { "Code": "090", "Name": "My Savings", "AccountID": "00000000-0000-0000-0000-000000000000", "Type": "BANK", "BankAccountNumber": "123455", "Status": "ACTIVE", "BankAccountType": "BANK", "CurrencyCode": "USD", "TaxType": "NONE", "EnablePaymentsToAccount": false, "ShowInExpenseClaims": false, "Class": "ASSET", "ReportingCode": "ASS", "ReportingCodeName": "Assets", "HasAttachments": false, "UpdatedDateUTC": "2016-10-17T13:45:33.993-07:00" }, "ToBankAccount": { "Code": "088", "Name": "Business Wells Fargo", "AccountID": "00000000-0000-0000-0000-000000000000", "Type": "BANK", "BankAccountNumber": "123455", "Status": "ACTIVE", "BankAccountType": "BANK", "CurrencyCode": "USD", "TaxType": "NONE", "EnablePaymentsToAccount": false, "ShowInExpenseClaims": false, "Class": "ASSET", "ReportingCode": "ASS", "ReportingCodeName": "Assets", "HasAttachments": false, "UpdatedDateUTC": "2016-06-03T08:31:14.517-07:00" }, "Amount": "50.00" } ] }; // BankTransfers

    let mut context = AccountingApi::Context::default();
    let result = client.createBankTransfer(xeroTenantId, bankTransfers, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID bankTransferID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        String fileName = "xero-dev.jpg";
        File input = new File("/path/to/local/xero-dev.jpg");
        java.nio.file.Path inputPath = input.toPath();
        byte[] body = FileUtils.readFileToByteArray(input);
        String mimeType = Files.probeContentType(inputPath);

        try {
            Attachments result = apiInstance.createBankTransferAttachmentByFileName(accessToken, xeroTenantId, bankTransferID, fileName, body, mimeType);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createBankTransferAttachmentByFileName");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID bankTransferID = 00000000-0000-0000-0000-000000000000; // UUID | Xero generated unique identifier for a bank transfer
        String fileName = xero-dev.jpg; // String | The name of the file being attached to a Bank Transfer
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 
        try {
            Attachments result = apiInstance.createBankTransferAttachmentByFileName(xeroTenantId, bankTransferID, fileName, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createBankTransferAttachmentByFileName");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *bankTransferID = 00000000-0000-0000-0000-000000000000; // Xero generated unique identifier for a bank transfer (default to null)
String *fileName = xero-dev.jpg; // The name of the file being attached to a Bank Transfer (default to null)
byte[] *body = BYTE_ARRAY_DATA_HERE; // 

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

// 
[apiInstance createBankTransferAttachmentByFileNameWith:xeroTenantId
    bankTransferID:bankTransferID
    fileName:fileName
    body:body
              completionHandler: ^(Attachments output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const bankTransferID = "00000000-0000-0000-0000-000000000000";  // {UUID} Xero generated unique identifier for a bank transfer
const fileName = "xero-dev.jpg";  // {String} The name of the file being attached to a Bank Transfer
const path = require("path");
const mime = require("mime-types");
const pathToUpload = path.resolve(__dirname, "../public/images/xero-dev.jpg"); // determine the path to your file
import * as fs from "fs";
const body = fs.createReadStream(pathToUpload); // {fs.ReadStream} read the file
const contentType = mime.lookup(fileName);

try {
  const response = await xero.accountingApi.createBankTransferAttachmentByFileName(xeroTenantId, bankTransferID, fileName, body, {
    headers: {
      "Content-Type": contentType,
    }
  });
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var bankTransferID = new UUID(); // UUID | Xero generated unique identifier for a bank transfer (default to null)
            var fileName = xero-dev.jpg;  // String | The name of the file being attached to a Bank Transfer (default to null)
            var body = BYTE_ARRAY_DATA_HERE;  // byte[] | 

            try
            {
                // 
                Attachments result = apiInstance.createBankTransferAttachmentByFileName(xeroTenantId, bankTransferID, fileName, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createBankTransferAttachmentByFileName: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$bankTransferID = "00000000-0000-0000-0000-000000000000";
$fileName = "xero-dev.jpg";

$handle = fopen($fileName, "r");
$body = fread($handle, filesize($fileName));
fclose($handle);

try {
  $result = $apiInstance->createBankTransferAttachmentByFileName($xeroTenantId, $bankTransferID, $fileName, $body);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createBankTransferAttachmentByFileName: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $bankTransferID = 00000000-0000-0000-0000-000000000000; # UUID | Xero generated unique identifier for a bank transfer
my $fileName = xero-dev.jpg; # String | The name of the file being attached to a Bank Transfer
my $body = ::Object::byte[]->new(); # byte[] | 

eval { 
    my $result = $api_instance->createBankTransferAttachmentByFileName(xeroTenantId => $xeroTenantId, bankTransferID => $bankTransferID, fileName => $fileName, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createBankTransferAttachmentByFileName: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_bank_transfer_attachment_by_file_name():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    bankTransferID = '00000000-0000-0000-0000-000000000000'
    fileName = 'xero-dev.jpg'
    
        // TODO: BINARY CREATE 
    try:
        api_response = api_instance.create_bank_transfer_attachment_by_file_name(xeroTenantId, bankTransferID, fileName, body)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createBankTransferAttachmentByFileName: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let bankTransferID = 00000000-0000-0000-0000-000000000000; // UUID
    let fileName = xero-dev.jpg; // String
    let body = BYTE_ARRAY_DATA_HERE; // byte[]

    let mut context = AccountingApi::Context::default();
    let result = client.createBankTransferAttachmentByFileName(xeroTenantId, bankTransferID, fileName, body, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID bankTransferID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

        try {
            HistoryRecords result = apiInstance.createBankTransferHistoryRecord(accessToken, xeroTenantId, bankTransferID, historyRecords);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createBankTransferHistoryRecord");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID bankTransferID = 00000000-0000-0000-0000-000000000000; // UUID | Xero generated unique identifier for a bank transfer
        HistoryRecords historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords | 
        try {
            HistoryRecords result = apiInstance.createBankTransferHistoryRecord(xeroTenantId, bankTransferID, historyRecords);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createBankTransferHistoryRecord");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *bankTransferID = 00000000-0000-0000-0000-000000000000; // Xero generated unique identifier for a bank transfer (default to null)
HistoryRecords *historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // 

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

// Creates a history record for a specific bank transfer
[apiInstance createBankTransferHistoryRecordWith:xeroTenantId
    bankTransferID:bankTransferID
    historyRecords:historyRecords
              completionHandler: ^(HistoryRecords output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);
const historyRecords: HistoryRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] };  // {HistoryRecords} 
const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const bankTransferID = "00000000-0000-0000-0000-000000000000";  // {UUID} Xero generated unique identifier for a bank transfer


try {
  const response = await xero.accountingApi.createBankTransferHistoryRecord(xeroTenantId, bankTransferID, historyRecords);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var bankTransferID = new UUID(); // UUID | Xero generated unique identifier for a bank transfer (default to null)
            var historyRecords = new HistoryRecords(); // HistoryRecords | 

            try
            {
                // Creates a history record for a specific bank transfer
                HistoryRecords result = apiInstance.createBankTransferHistoryRecord(xeroTenantId, bankTransferID, historyRecords);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createBankTransferHistoryRecord: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$bankTransferID = "00000000-0000-0000-0000-000000000000";

$historyRecord = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecord;
$historyRecord->setDetails('Hello World');

$historyRecords = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecords;
$arr_history_records = [];
array_push($arr_history_records, $historyRecord);
$historyRecords->setHistoryRecords($arr_history_records);

try {
  $result = $apiInstance->createBankTransferHistoryRecord($xeroTenantId, $bankTransferID, $historyRecords);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createBankTransferHistoryRecord: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $bankTransferID = 00000000-0000-0000-0000-000000000000; # UUID | Xero generated unique identifier for a bank transfer
my $historyRecords = ::Object::HistoryRecords->new(); # HistoryRecords | 

eval { 
    my $result = $api_instance->createBankTransferHistoryRecord(xeroTenantId => $xeroTenantId, bankTransferID => $bankTransferID, historyRecords => $historyRecords);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createBankTransferHistoryRecord: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_bank_transfer_history_record():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    bankTransferID = '00000000-0000-0000-0000-000000000000'

    history_record = HistoryRecord(
        details = "Hello World")

    history_records = HistoryRecords( 
        history_records = [history_record])
    
    try:
        api_response = api_instance.create_bank_transfer_history_record(xeroTenantId, bankTransferID, historyRecords)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createBankTransferHistoryRecord: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let bankTransferID = 00000000-0000-0000-0000-000000000000; // UUID
    let historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords

    let mut context = AccountingApi::Context::default();
    let result = client.createBankTransferHistoryRecord(xeroTenantId, bankTransferID, historyRecords, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        Boolean summarizeErrors = true;
        LocalDate currDate = LocalDate.now();
        Account paymentAccount = new Account();
        paymentAccount.setAccountID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        Account bankAccount = new Account();
        bankAccount.setAccountID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        Invoice invoice = new Invoice();
        invoice.setInvoiceID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        Payment payment = new Payment();
        payment.setAccount(bankAccount);
        payment.setDate(currDate);
        payment.setAmount(1.0);
        payment.setInvoice(invoice);
        List<Payment> payments = new ArrayList<Payment>();
        payments.add(payment);
        BatchPayment batchPayment = new BatchPayment();
        batchPayment.setAccount(paymentAccount);
        batchPayment.setReference("hello foobar");
        batchPayment.setDate(currDate);
        batchPayment.setPayments(payments);
        BatchPayments batchPayments = new BatchPayments();
        batchPayments.addBatchPaymentsItem(batchPayment);

        try {
            BatchPayments result = apiInstance.createBatchPayment(accessToken, xeroTenantId, batchPayments, summarizeErrors);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createBatchPayment");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        BatchPayments batchPayments = { "BatchPayments": [ { "Account": { "AccountID": "00000000-0000-0000-0000-000000000000" }, "Reference": "ref", "Date": "2018-08-01", "Payments": [ { "Account": { "Code": "001" }, "Date": "2019-12-31", "Amount": 500, "Invoice": { "InvoiceID": "00000000-0000-0000-0000-000000000000", "LineItems": [], "Contact": {}, "Type": "ACCPAY" } } ] } ] }; // BatchPayments | 
        Boolean summarizeErrors = true; // Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors
        try {
            BatchPayments result = apiInstance.createBatchPayment(xeroTenantId, batchPayments, summarizeErrors);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createBatchPayment");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
BatchPayments *batchPayments = { "BatchPayments": [ { "Account": { "AccountID": "00000000-0000-0000-0000-000000000000" }, "Reference": "ref", "Date": "2018-08-01", "Payments": [ { "Account": { "Code": "001" }, "Date": "2019-12-31", "Amount": 500, "Invoice": { "InvoiceID": "00000000-0000-0000-0000-000000000000", "LineItems": [], "Contact": {}, "Type": "ACCPAY" } } ] } ] }; // 
Boolean *summarizeErrors = true; // If false return 200 OK and mix of successfully created objects and any with validation errors (optional) (default to false)

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

// Creates one or many batch payments for invoices
[apiInstance createBatchPaymentWith:xeroTenantId
    batchPayments:batchPayments
    summarizeErrors:summarizeErrors
              completionHandler: ^(BatchPayments output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant


const summarizeErrors = true;  // {Boolean} If false return 200 OK and mix of successfully created objects and any with validation errors
const batchPayments: BatchPayments = { batchPayments: [{ account: { accountId: "00000000-0000-0000-0000-000000000000" }, reference: "ref", date: "2018-08-01", payments: [{  account: { code: "001" }, date: "2019-12-31", amount: 500, invoice: { invoiceId: "00000000-0000-0000-0000-000000000000", lineItems: [], contact: {}, type: Invoice.TypeEnum.ACCPAY }}]}]}

try {
  const response = await xero.accountingApi.createBatchPayment(xeroTenantId, batchPayments,  summarizeErrors);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var batchPayments = new BatchPayments(); // BatchPayments | 
            var summarizeErrors = true;  // Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors (optional)  (default to false)

            try
            {
                // Creates one or many batch payments for invoices
                BatchPayments result = apiInstance.createBatchPayment(xeroTenantId, batchPayments, summarizeErrors);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createBatchPayment: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$summarizeErrors = true;
$currDate = new DateTime('2020-12-10');

$paymentAccount = new XeroAPI\XeroPHP\Models\Accounting\Account;
$paymentAccount->setAccountID('00000000-0000-0000-0000-000000000000');

$bankAccount = new XeroAPI\XeroPHP\Models\Accounting\Account;
$bankAccount->setAccountID('00000000-0000-0000-0000-000000000000');

$invoice = new XeroAPI\XeroPHP\Models\Accounting\Invoice;
$invoice->setInvoiceID('00000000-0000-0000-0000-000000000000');

$payment = new XeroAPI\XeroPHP\Models\Accounting\Payment;
$payment->setAccount($bankAccount);
$payment->setDate($currDate);
$payment->setAmount(1.0);
$payment->setInvoice($invoice);
$payments = [];
array_push($payments, $payment);

$batchPayment = new XeroAPI\XeroPHP\Models\Accounting\BatchPayment;
$batchPayment->setAccount($paymentAccount);
$batchPayment->setReference('hello foobar');
$batchPayment->setDate($currDate);
$batchPayment->setPayments($payments);

$batchPayments = new XeroAPI\XeroPHP\Models\Accounting\BatchPayments;
$arr_batch_payments = [];
array_push($arr_batch_payments, $batchPayment);
$batchPayments->setBatchPayments($arr_batch_payments);

try {
  $result = $apiInstance->createBatchPayment($xeroTenantId, $batchPayments, $summarizeErrors);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createBatchPayment: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $batchPayments = ::Object::BatchPayments->new(); # BatchPayments | 
my $summarizeErrors = true; # Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors

eval { 
    my $result = $api_instance->createBatchPayment(xeroTenantId => $xeroTenantId, batchPayments => $batchPayments, summarizeErrors => $summarizeErrors);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createBatchPayment: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_batch_payment():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    summarizeErrors = 'True'
    curr_date = dateutil.parser.parse('2020-12-03T00:00:00Z')

    payment_account = Account(
        account_id = "00000000-0000-0000-0000-000000000000")

    bank_account = Account(
        account_id = "00000000-0000-0000-0000-000000000000")

    invoice = Invoice(
        invoice_id = "00000000-0000-0000-0000-000000000000")

    payment = Payment(
        account = bank_account,
        date = curr_date,
        amount = 1.0,
        invoice = invoice)
    
    payments = []    
    payments.append(payment)

    batch_payment = BatchPayment(
        account = payment_account,
        reference = "hello foobar",
        date = curr_date,
        payments = payments)

    batchPayments = BatchPayments( 
        batch_payments = [batch_payment])
    
    try:
        api_response = api_instance.create_batch_payment(xeroTenantId, batchPayments, summarizeErrors)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createBatchPayment: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let batchPayments = { "BatchPayments": [ { "Account": { "AccountID": "00000000-0000-0000-0000-000000000000" }, "Reference": "ref", "Date": "2018-08-01", "Payments": [ { "Account": { "Code": "001" }, "Date": "2019-12-31", "Amount": 500, "Invoice": { "InvoiceID": "00000000-0000-0000-0000-000000000000", "LineItems": [], "Contact": {}, "Type": "ACCPAY" } } ] } ] }; // BatchPayments
    let summarizeErrors = true; // Boolean

    let mut context = AccountingApi::Context::default();
    let result = client.createBatchPayment(xeroTenantId, batchPayments, summarizeErrors, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID batchPaymentID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

        try {
            HistoryRecords result = apiInstance.createBatchPaymentHistoryRecord(accessToken, xeroTenantId, batchPaymentID, historyRecords);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createBatchPaymentHistoryRecord");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID batchPaymentID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for BatchPayment
        HistoryRecords historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords | 
        try {
            HistoryRecords result = apiInstance.createBatchPaymentHistoryRecord(xeroTenantId, batchPaymentID, historyRecords);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createBatchPaymentHistoryRecord");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *batchPaymentID = 00000000-0000-0000-0000-000000000000; // Unique identifier for BatchPayment (default to null)
HistoryRecords *historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // 

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

// Creates a history record for a specific batch payment
[apiInstance createBatchPaymentHistoryRecordWith:xeroTenantId
    batchPaymentID:batchPaymentID
    historyRecords:historyRecords
              completionHandler: ^(HistoryRecords output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);
const historyRecords: HistoryRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] };  // {HistoryRecords} 
const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const batchPaymentID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for BatchPayment


try {
  const response = await xero.accountingApi.createBatchPaymentHistoryRecord(xeroTenantId, batchPaymentID, historyRecords);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var batchPaymentID = new UUID(); // UUID | Unique identifier for BatchPayment (default to null)
            var historyRecords = new HistoryRecords(); // HistoryRecords | 

            try
            {
                // Creates a history record for a specific batch payment
                HistoryRecords result = apiInstance.createBatchPaymentHistoryRecord(xeroTenantId, batchPaymentID, historyRecords);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createBatchPaymentHistoryRecord: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$batchPaymentID = "00000000-0000-0000-0000-000000000000";

$historyRecord = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecord;
$historyRecord->setDetails('Hello World');

$historyRecords = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecords;
$arr_history_records = [];
array_push($arr_history_records, $historyRecord);
$historyRecords->setHistoryRecords($arr_history_records);

try {
  $result = $apiInstance->createBatchPaymentHistoryRecord($xeroTenantId, $batchPaymentID, $historyRecords);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createBatchPaymentHistoryRecord: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $batchPaymentID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for BatchPayment
my $historyRecords = ::Object::HistoryRecords->new(); # HistoryRecords | 

eval { 
    my $result = $api_instance->createBatchPaymentHistoryRecord(xeroTenantId => $xeroTenantId, batchPaymentID => $batchPaymentID, historyRecords => $historyRecords);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createBatchPaymentHistoryRecord: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_batch_payment_history_record():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    batchPaymentID = '00000000-0000-0000-0000-000000000000'

    history_record = HistoryRecord(
        details = "Hello World")

    history_records = HistoryRecords( 
        history_records = [history_record])
    
    try:
        api_response = api_instance.create_batch_payment_history_record(xeroTenantId, batchPaymentID, historyRecords)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createBatchPaymentHistoryRecord: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let batchPaymentID = 00000000-0000-0000-0000-000000000000; // UUID
    let historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords

    let mut context = AccountingApi::Context::default();
    let result = client.createBatchPaymentHistoryRecord(xeroTenantId, batchPaymentID, historyRecords, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID brandingThemeID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        PaymentService paymentService = new PaymentService();
        paymentService.setPaymentServiceID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        paymentService.setPaymentServiceName("ACME Payments");
        paymentService.setPaymentServiceUrl("https://www.payupnow.com/");
        paymentService.setPayNowText("Pay Now");

        try {
            PaymentServices result = apiInstance.createBrandingThemePaymentServices(accessToken, xeroTenantId, brandingThemeID, paymentService);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createBrandingThemePaymentServices");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID brandingThemeID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for a Branding Theme
        PaymentService paymentService = { "PaymentServiceID": "00000000-0000-0000-0000-000000000000", "PaymentServiceName": "ACME Payments", "PaymentServiceUrl": "https://www.payupnow.com/", "PayNowText": "Pay Now" }; // PaymentService | 
        try {
            PaymentServices result = apiInstance.createBrandingThemePaymentServices(xeroTenantId, brandingThemeID, paymentService);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createBrandingThemePaymentServices");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *brandingThemeID = 00000000-0000-0000-0000-000000000000; // Unique identifier for a Branding Theme (default to null)
PaymentService *paymentService = { "PaymentServiceID": "00000000-0000-0000-0000-000000000000", "PaymentServiceName": "ACME Payments", "PaymentServiceUrl": "https://www.payupnow.com/", "PayNowText": "Pay Now" }; // 

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

// Creates a new custom payment service for a specific branding theme
[apiInstance createBrandingThemePaymentServicesWith:xeroTenantId
    brandingThemeID:brandingThemeID
    paymentService:paymentService
              completionHandler: ^(PaymentServices output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const brandingThemeID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for a Branding Theme
const paymentService: PaymentService = { paymentServiceID: "00000000-0000-0000-0000-000000000000", paymentServiceName: "ACME Payments", paymentServiceUrl: "https://www.payupnow.com/", payNowText: "Pay Now" }

try {
  const response = await xero.accountingApi.createBrandingThemePaymentServices(xeroTenantId, brandingThemeID, paymentService);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var brandingThemeID = new UUID(); // UUID | Unique identifier for a Branding Theme (default to null)
            var paymentService = new PaymentService(); // PaymentService | 

            try
            {
                // Creates a new custom payment service for a specific branding theme
                PaymentServices result = apiInstance.createBrandingThemePaymentServices(xeroTenantId, brandingThemeID, paymentService);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createBrandingThemePaymentServices: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$brandingThemeID = "00000000-0000-0000-0000-000000000000";

$paymentService = new XeroAPI\XeroPHP\Models\Accounting\PaymentService;
$paymentService->setPaymentServiceID('00000000-0000-0000-0000-000000000000');
$paymentService->setPaymentServiceName('ACME Payments');
$paymentService->setPaymentServiceUrl('https://www.payupnow.com/');
$paymentService->setPayNowText('Pay Now');

try {
  $result = $apiInstance->createBrandingThemePaymentServices($xeroTenantId, $brandingThemeID, $paymentService);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createBrandingThemePaymentServices: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $brandingThemeID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for a Branding Theme
my $paymentService = ::Object::PaymentService->new(); # PaymentService | 

eval { 
    my $result = $api_instance->createBrandingThemePaymentServices(xeroTenantId => $xeroTenantId, brandingThemeID => $brandingThemeID, paymentService => $paymentService);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createBrandingThemePaymentServices: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_branding_theme_payment_services():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    brandingThemeID = '00000000-0000-0000-0000-000000000000'

    paymentService = PaymentService(
        paymentServiceID = "00000000-0000-0000-0000-000000000000",
        paymentServiceName = "ACME Payments",
        paymentServiceUrl = "https://www.payupnow.com/",
        payNowText = "Pay Now")
    
    try:
        api_response = api_instance.create_branding_theme_payment_services(xeroTenantId, brandingThemeID, paymentService)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createBrandingThemePaymentServices: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let brandingThemeID = 00000000-0000-0000-0000-000000000000; // UUID
    let paymentService = { "PaymentServiceID": "00000000-0000-0000-0000-000000000000", "PaymentServiceName": "ACME Payments", "PaymentServiceUrl": "https://www.payupnow.com/", "PayNowText": "Pay Now" }; // PaymentService

    let mut context = AccountingApi::Context::default();
    let result = client.createBrandingThemePaymentServices(xeroTenantId, brandingThemeID, paymentService, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID contactID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        String fileName = "xero-dev.jpg";
        File input = new File("/path/to/local/xero-dev.jpg");
        java.nio.file.Path inputPath = input.toPath();
        byte[] body = FileUtils.readFileToByteArray(input);
        String mimeType = Files.probeContentType(inputPath);

        try {
            Attachments result = apiInstance.createContactAttachmentByFileName(accessToken, xeroTenantId, contactID, fileName, body, mimeType);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createContactAttachmentByFileName");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID contactID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for a Contact
        String fileName = xero-dev.jpg; // String | Name for the file you are attaching
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 
        try {
            Attachments result = apiInstance.createContactAttachmentByFileName(xeroTenantId, contactID, fileName, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createContactAttachmentByFileName");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *contactID = 00000000-0000-0000-0000-000000000000; // Unique identifier for a Contact (default to null)
String *fileName = xero-dev.jpg; // Name for the file you are attaching (default to null)
byte[] *body = BYTE_ARRAY_DATA_HERE; // 

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

// 
[apiInstance createContactAttachmentByFileNameWith:xeroTenantId
    contactID:contactID
    fileName:fileName
    body:body
              completionHandler: ^(Attachments output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const contactID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for a Contact
const fileName = "xero-dev.jpg";  // {String} Name for the file you are attaching
const path = require("path");
const mime = require("mime-types");
const pathToUpload = path.resolve(__dirname, "../public/images/xero-dev.jpg"); // determine the path to your file
import * as fs from "fs";
const body = fs.createReadStream(pathToUpload); // {fs.ReadStream} read the file
const contentType = mime.lookup(fileName);

try {
  const response = await xero.accountingApi.createContactAttachmentByFileName(xeroTenantId, contactID, fileName, body, {
    headers: {
      "Content-Type": contentType,
    }
  });
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var contactID = new UUID(); // UUID | Unique identifier for a Contact (default to null)
            var fileName = xero-dev.jpg;  // String | Name for the file you are attaching (default to null)
            var body = BYTE_ARRAY_DATA_HERE;  // byte[] | 

            try
            {
                // 
                Attachments result = apiInstance.createContactAttachmentByFileName(xeroTenantId, contactID, fileName, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createContactAttachmentByFileName: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$contactID = "00000000-0000-0000-0000-000000000000";
$fileName = "xero-dev.jpg";

$handle = fopen($fileName, "r");
$body = fread($handle, filesize($fileName));
fclose($handle);

try {
  $result = $apiInstance->createContactAttachmentByFileName($xeroTenantId, $contactID, $fileName, $body);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createContactAttachmentByFileName: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $contactID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for a Contact
my $fileName = xero-dev.jpg; # String | Name for the file you are attaching
my $body = ::Object::byte[]->new(); # byte[] | 

eval { 
    my $result = $api_instance->createContactAttachmentByFileName(xeroTenantId => $xeroTenantId, contactID => $contactID, fileName => $fileName, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createContactAttachmentByFileName: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_contact_attachment_by_file_name():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    contactID = '00000000-0000-0000-0000-000000000000'
    fileName = 'xero-dev.jpg'
    
        // TODO: BINARY CREATE 
    try:
        api_response = api_instance.create_contact_attachment_by_file_name(xeroTenantId, contactID, fileName, body)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createContactAttachmentByFileName: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let contactID = 00000000-0000-0000-0000-000000000000; // UUID
    let fileName = xero-dev.jpg; // String
    let body = BYTE_ARRAY_DATA_HERE; // byte[]

    let mut context = AccountingApi::Context::default();
    let result = client.createContactAttachmentByFileName(xeroTenantId, contactID, fileName, body, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        ContactGroup contactGroup = new ContactGroup();
        contactGroup.setName("VIPs");
        ContactGroups contactGroups = new ContactGroups();
        contactGroups.addContactGroupsItem(contactGroup);

        try {
            ContactGroups result = apiInstance.createContactGroup(accessToken, xeroTenantId, contactGroups);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createContactGroup");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        ContactGroups contactGroups = { "ContactGroups": [{ "Name": "VIPs" }]}; // ContactGroups | 
        try {
            ContactGroups result = apiInstance.createContactGroup(xeroTenantId, contactGroups);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createContactGroup");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
ContactGroups *contactGroups = { "ContactGroups": [{ "Name": "VIPs" }]}; // 

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

// Creates a contact group
[apiInstance createContactGroupWith:xeroTenantId
    contactGroups:contactGroups
              completionHandler: ^(ContactGroups output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const contactGroups: ContactGroups = { contactGroups: [{ name: "VIPs" }]}

try {
  const response = await xero.accountingApi.createContactGroup(xeroTenantId, contactGroups);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var contactGroups = new ContactGroups(); // ContactGroups | 

            try
            {
                // Creates a contact group
                ContactGroups result = apiInstance.createContactGroup(xeroTenantId, contactGroups);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createContactGroup: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";

$contactGroup = new XeroAPI\XeroPHP\Models\Accounting\ContactGroup;
$contactGroup->setName('VIPs');

$contactGroups = new XeroAPI\XeroPHP\Models\Accounting\ContactGroups;
$arr_contact_groups = [];
array_push($arr_contact_groups, $contactGroup);
$contactGroups->setContactGroups($arr_contact_groups);

try {
  $result = $apiInstance->createContactGroup($xeroTenantId, $contactGroups);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createContactGroup: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $contactGroups = ::Object::ContactGroups->new(); # ContactGroups | 

eval { 
    my $result = $api_instance->createContactGroup(xeroTenantId => $xeroTenantId, contactGroups => $contactGroups);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createContactGroup: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_contact_group():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'

    contact_group = ContactGroup(
        name = "VIPs")

    contactGroups = ContactGroups( 
        contact_groups = [contact_group])
    
    try:
        api_response = api_instance.create_contact_group(xeroTenantId, contactGroups)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createContactGroup: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let contactGroups = { "ContactGroups": [{ "Name": "VIPs" }]}; // ContactGroups

    let mut context = AccountingApi::Context::default();
    let result = client.createContactGroup(xeroTenantId, contactGroups, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID contactGroupID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        Contact contact = new Contact();
        contact.setContactID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        Contacts contacts = new Contacts();
        contacts.addContactsItem(contact);

        try {
            Contacts result = apiInstance.createContactGroupContacts(accessToken, xeroTenantId, contactGroupID, contacts);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createContactGroupContacts");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID contactGroupID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for a Contact Group
        Contacts contacts = { "Contacts": [ { "ContactID": "a3675fc4-f8dd-4f03-ba5b-f1870566bcd7" }, { "ContactID": "4e1753b9-018a-4775-b6aa-1bc7871cfee3" } ] }; // Contacts | 
        try {
            Contacts result = apiInstance.createContactGroupContacts(xeroTenantId, contactGroupID, contacts);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createContactGroupContacts");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *contactGroupID = 00000000-0000-0000-0000-000000000000; // Unique identifier for a Contact Group (default to null)
Contacts *contacts = { "Contacts": [ { "ContactID": "a3675fc4-f8dd-4f03-ba5b-f1870566bcd7" }, { "ContactID": "4e1753b9-018a-4775-b6aa-1bc7871cfee3" } ] }; // 

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

// Creates contacts to a specific contact group
[apiInstance createContactGroupContactsWith:xeroTenantId
    contactGroupID:contactGroupID
    contacts:contacts
              completionHandler: ^(Contacts output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const contactGroupID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for a Contact Group
const contacts: Contacts = { contacts: [{ contactID: "a3675fc4-f8dd-4f03-ba5b-f1870566bcd7" }, { contactID: "4e1753b9-018a-4775-b6aa-1bc7871cfee3" }]}

try {
  const response = await xero.accountingApi.createContactGroupContacts(xeroTenantId, contactGroupID, contacts);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var contactGroupID = new UUID(); // UUID | Unique identifier for a Contact Group (default to null)
            var contacts = new Contacts(); // Contacts | 

            try
            {
                // Creates contacts to a specific contact group
                Contacts result = apiInstance.createContactGroupContacts(xeroTenantId, contactGroupID, contacts);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createContactGroupContacts: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$contactGroupID = "00000000-0000-0000-0000-000000000000";

$contact = new XeroAPI\XeroPHP\Models\Accounting\Contact;
$contact->setContactID('00000000-0000-0000-0000-000000000000');

$contacts = new XeroAPI\XeroPHP\Models\Accounting\Contacts;
$arr_contacts = [];
array_push($arr_contacts, $contact);
$contacts->setContacts($arr_contacts);

try {
  $result = $apiInstance->createContactGroupContacts($xeroTenantId, $contactGroupID, $contacts);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createContactGroupContacts: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $contactGroupID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for a Contact Group
my $contacts = ::Object::Contacts->new(); # Contacts | 

eval { 
    my $result = $api_instance->createContactGroupContacts(xeroTenantId => $xeroTenantId, contactGroupID => $contactGroupID, contacts => $contacts);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createContactGroupContacts: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_contact_group_contacts():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    contactGroupID = '00000000-0000-0000-0000-000000000000'

    contact = Contact(
        contact_id = "00000000-0000-0000-0000-000000000000")

    contacts = Contacts( 
        contacts = [contact])
    
    try:
        api_response = api_instance.create_contact_group_contacts(xeroTenantId, contactGroupID, contacts)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createContactGroupContacts: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let contactGroupID = 00000000-0000-0000-0000-000000000000; // UUID
    let contacts = { "Contacts": [ { "ContactID": "a3675fc4-f8dd-4f03-ba5b-f1870566bcd7" }, { "ContactID": "4e1753b9-018a-4775-b6aa-1bc7871cfee3" } ] }; // Contacts

    let mut context = AccountingApi::Context::default();
    let result = client.createContactGroupContacts(xeroTenantId, contactGroupID, contacts, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID contactID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

        try {
            HistoryRecords result = apiInstance.createContactHistory(accessToken, xeroTenantId, contactID, historyRecords);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createContactHistory");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID contactID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for a Contact
        HistoryRecords historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords | 
        try {
            HistoryRecords result = apiInstance.createContactHistory(xeroTenantId, contactID, historyRecords);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createContactHistory");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *contactID = 00000000-0000-0000-0000-000000000000; // Unique identifier for a Contact (default to null)
HistoryRecords *historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // 

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

// Creates a new history record for a specific contact
[apiInstance createContactHistoryWith:xeroTenantId
    contactID:contactID
    historyRecords:historyRecords
              completionHandler: ^(HistoryRecords output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);
const historyRecords: HistoryRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] };  // {HistoryRecords} 
const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const contactID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for a Contact


try {
  const response = await xero.accountingApi.createContactHistory(xeroTenantId, contactID, historyRecords);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var contactID = new UUID(); // UUID | Unique identifier for a Contact (default to null)
            var historyRecords = new HistoryRecords(); // HistoryRecords | 

            try
            {
                // Creates a new history record for a specific contact
                HistoryRecords result = apiInstance.createContactHistory(xeroTenantId, contactID, historyRecords);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createContactHistory: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$contactID = "00000000-0000-0000-0000-000000000000";

$historyRecord = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecord;
$historyRecord->setDetails('Hello World');

$historyRecords = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecords;
$arr_history_records = [];
array_push($arr_history_records, $historyRecord);
$historyRecords->setHistoryRecords($arr_history_records);

try {
  $result = $apiInstance->createContactHistory($xeroTenantId, $contactID, $historyRecords);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createContactHistory: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $contactID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for a Contact
my $historyRecords = ::Object::HistoryRecords->new(); # HistoryRecords | 

eval { 
    my $result = $api_instance->createContactHistory(xeroTenantId => $xeroTenantId, contactID => $contactID, historyRecords => $historyRecords);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createContactHistory: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_contact_history():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    contactID = '00000000-0000-0000-0000-000000000000'

    history_record = HistoryRecord(
        details = "Hello World")

    history_records = HistoryRecords( 
        history_records = [history_record])
    
    try:
        api_response = api_instance.create_contact_history(xeroTenantId, contactID, historyRecords)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createContactHistory: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let contactID = 00000000-0000-0000-0000-000000000000; // UUID
    let historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords

    let mut context = AccountingApi::Context::default();
    let result = client.createContactHistory(xeroTenantId, contactID, historyRecords, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        Boolean summarizeErrors = true;
        Phone phone = new Phone();
        phone.setPhoneNumber("555-1212");
        phone.setPhoneType(com.xero.models.accounting.Phone.PhoneTypeEnum.MOBILE);
        List<Phone> phones = new ArrayList<Phone>();
        phones.add(phone);
        Contact contact = new Contact();
        contact.setName("Bruce Banner");
        contact.setEmailAddress("hulk@avengers.com");
        contact.setPhones(phones);
        Contacts contacts = new Contacts();
        contacts.addContactsItem(contact);

        try {
            Contacts result = apiInstance.createContacts(accessToken, xeroTenantId, contacts, summarizeErrors);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createContacts");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        Contacts contacts = { "Id": "e997d6d7-6dad-4458-beb8-d9c1bf7f2edf", "Status": "OK", "ProviderName": "Xero API Partner", "DateTimeUTC": "/Date(1551399321121)/", "Contacts": [ { "ContactID": "3ff6d40c-af9a-40a3-89ce-3c1556a25591", "ContactStatus": "ACTIVE", "Name": "Foo9987", "EmailAddress": "sid32476@blah.com", "BankAccountDetails": "", "Addresses": [ { "AddressType": "STREET", "City": "", "Region": "", "PostalCode": "", "Country": "" }, { "AddressType": "POBOX", "City": "", "Region": "", "PostalCode": "", "Country": "" } ], "Phones": [ { "PhoneType": "DEFAULT", "PhoneNumber": "", "PhoneAreaCode": "", "PhoneCountryCode": "" }, { "PhoneType": "DDI", "PhoneNumber": "", "PhoneAreaCode": "", "PhoneCountryCode": "" }, { "PhoneType": "FAX", "PhoneNumber": "", "PhoneAreaCode": "", "PhoneCountryCode": "" }, { "PhoneType": "MOBILE", "PhoneNumber": "555-1212", "PhoneAreaCode": "415", "PhoneCountryCode": "" } ], "UpdatedDateUTC": "/Date(1551399321043+0000)/", "ContactGroups": [], "IsSupplier": false, "IsCustomer": false, "SalesTrackingCategories": [], "PurchasesTrackingCategories": [], "PaymentTerms": { "Bills": { "Day": 15, "Type": "OFCURRENTMONTH" }, "Sales": { "Day": 10, "Type": "DAYSAFTERBILLMONTH" } }, "ContactPersons": [], "HasValidationErrors": false } ] }; // Contacts | 
        Boolean summarizeErrors = true; // Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors
        try {
            Contacts result = apiInstance.createContacts(xeroTenantId, contacts, summarizeErrors);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createContacts");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
Contacts *contacts = { "Id": "e997d6d7-6dad-4458-beb8-d9c1bf7f2edf", "Status": "OK", "ProviderName": "Xero API Partner", "DateTimeUTC": "/Date(1551399321121)/", "Contacts": [ { "ContactID": "3ff6d40c-af9a-40a3-89ce-3c1556a25591", "ContactStatus": "ACTIVE", "Name": "Foo9987", "EmailAddress": "sid32476@blah.com", "BankAccountDetails": "", "Addresses": [ { "AddressType": "STREET", "City": "", "Region": "", "PostalCode": "", "Country": "" }, { "AddressType": "POBOX", "City": "", "Region": "", "PostalCode": "", "Country": "" } ], "Phones": [ { "PhoneType": "DEFAULT", "PhoneNumber": "", "PhoneAreaCode": "", "PhoneCountryCode": "" }, { "PhoneType": "DDI", "PhoneNumber": "", "PhoneAreaCode": "", "PhoneCountryCode": "" }, { "PhoneType": "FAX", "PhoneNumber": "", "PhoneAreaCode": "", "PhoneCountryCode": "" }, { "PhoneType": "MOBILE", "PhoneNumber": "555-1212", "PhoneAreaCode": "415", "PhoneCountryCode": "" } ], "UpdatedDateUTC": "/Date(1551399321043+0000)/", "ContactGroups": [], "IsSupplier": false, "IsCustomer": false, "SalesTrackingCategories": [], "PurchasesTrackingCategories": [], "PaymentTerms": { "Bills": { "Day": 15, "Type": "OFCURRENTMONTH" }, "Sales": { "Day": 10, "Type": "DAYSAFTERBILLMONTH" } }, "ContactPersons": [], "HasValidationErrors": false } ] }; // 
Boolean *summarizeErrors = true; // If false return 200 OK and mix of successfully created objects and any with validation errors (optional) (default to false)

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

// Creates multiple contacts (bulk) in a Xero organisation
[apiInstance createContactsWith:xeroTenantId
    contacts:contacts
    summarizeErrors:summarizeErrors
              completionHandler: ^(Contacts output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant


const summarizeErrors = true;  // {Boolean} If false return 200 OK and mix of successfully created objects and any with validation errors
const contacts: Contacts = { contacts: [{ name: "Bruce Banner", emailAddress: "hulk@avengers.com", phones: [{ phoneType: Phone.PhoneTypeEnum.MOBILE, phoneNumber: "555-1212", phoneAreaCode: "415" }], paymentTerms: { bills: { day: 15, type: PaymentTermType.OFCURRENTMONTH }, sales: { day: 10, type: PaymentTermType.DAYSAFTERBILLMONTH }}}]}

try {
  const response = await xero.accountingApi.createContacts(xeroTenantId, contacts,  summarizeErrors);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var contacts = new Contacts(); // Contacts | 
            var summarizeErrors = true;  // Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors (optional)  (default to false)

            try
            {
                // Creates multiple contacts (bulk) in a Xero organisation
                Contacts result = apiInstance.createContacts(xeroTenantId, contacts, summarizeErrors);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createContacts: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$summarizeErrors = true;

$phone = new XeroAPI\XeroPHP\Models\Accounting\Phone;
$phone->setPhoneNumber('555-1212');
$phone->setPhoneType(XeroAPI\XeroPHP\Models\Accounting\Phone::PHONE_TYPE_MOBILE);
$phones = [];
array_push($phones, $phone);

$contact = new XeroAPI\XeroPHP\Models\Accounting\Contact;
$contact->setName('Bruce Banner');
$contact->setEmailAddress('hulk@avengers.com');
$contact->setPhones($phones);

$contacts = new XeroAPI\XeroPHP\Models\Accounting\Contacts;
$arr_contacts = [];
array_push($arr_contacts, $contact);
$contacts->setContacts($arr_contacts);

try {
  $result = $apiInstance->createContacts($xeroTenantId, $contacts, $summarizeErrors);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createContacts: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $contacts = ::Object::Contacts->new(); # Contacts | 
my $summarizeErrors = true; # Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors

eval { 
    my $result = $api_instance->createContacts(xeroTenantId => $xeroTenantId, contacts => $contacts, summarizeErrors => $summarizeErrors);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createContacts: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_contacts():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    summarizeErrors = 'True'

    phone = Phone(
        phone_number = "555-1212",
        phone_type = "MOBILE")
    
    phones = []    
    phones.append(phone)

    contact = Contact(
        name = "Bruce Banner",
        email_address = "hulk@avengers.com",
        phones = phones)

    contacts = Contacts( 
        contacts = [contact])
    
    try:
        api_response = api_instance.create_contacts(xeroTenantId, contacts, summarizeErrors)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createContacts: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let contacts = { "Id": "e997d6d7-6dad-4458-beb8-d9c1bf7f2edf", "Status": "OK", "ProviderName": "Xero API Partner", "DateTimeUTC": "/Date(1551399321121)/", "Contacts": [ { "ContactID": "3ff6d40c-af9a-40a3-89ce-3c1556a25591", "ContactStatus": "ACTIVE", "Name": "Foo9987", "EmailAddress": "sid32476@blah.com", "BankAccountDetails": "", "Addresses": [ { "AddressType": "STREET", "City": "", "Region": "", "PostalCode": "", "Country": "" }, { "AddressType": "POBOX", "City": "", "Region": "", "PostalCode": "", "Country": "" } ], "Phones": [ { "PhoneType": "DEFAULT", "PhoneNumber": "", "PhoneAreaCode": "", "PhoneCountryCode": "" }, { "PhoneType": "DDI", "PhoneNumber": "", "PhoneAreaCode": "", "PhoneCountryCode": "" }, { "PhoneType": "FAX", "PhoneNumber": "", "PhoneAreaCode": "", "PhoneCountryCode": "" }, { "PhoneType": "MOBILE", "PhoneNumber": "555-1212", "PhoneAreaCode": "415", "PhoneCountryCode": "" } ], "UpdatedDateUTC": "/Date(1551399321043+0000)/", "ContactGroups": [], "IsSupplier": false, "IsCustomer": false, "SalesTrackingCategories": [], "PurchasesTrackingCategories": [], "PaymentTerms": { "Bills": { "Day": 15, "Type": "OFCURRENTMONTH" }, "Sales": { "Day": 10, "Type": "DAYSAFTERBILLMONTH" } }, "ContactPersons": [], "HasValidationErrors": false } ] }; // Contacts
    let summarizeErrors = true; // Boolean

    let mut context = AccountingApi::Context::default();
    let result = client.createContacts(xeroTenantId, contacts, summarizeErrors, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID creditNoteID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        Boolean summarizeErrors = true;
        LocalDate currDate = LocalDate.now();
        Invoice invoice = new Invoice();
        invoice.setInvoiceID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        Allocation allocation = new Allocation();
        allocation.setAmount(1.0);
        allocation.setDate(currDate);
        allocation.setInvoice(invoice);
        Allocations allocations = new Allocations();
        allocations.addAllocationsItem(allocation);

        try {
            Allocations result = apiInstance.createCreditNoteAllocation(accessToken, xeroTenantId, creditNoteID, allocations, summarizeErrors);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createCreditNoteAllocation");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID creditNoteID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for a Credit Note
        Allocations allocations = { "Allocations": [ { "Invoice": { "LineItems": [], "InvoiceID": "c45720a1-ade3-4a38-a064-d15489be6841" }, "Amount": 1, "Date": "2019-03-05" } ] }; // Allocations | 
        Boolean summarizeErrors = true; // Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors
        try {
            Allocations result = apiInstance.createCreditNoteAllocation(xeroTenantId, creditNoteID, allocations, summarizeErrors);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createCreditNoteAllocation");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *creditNoteID = 00000000-0000-0000-0000-000000000000; // Unique identifier for a Credit Note (default to null)
Allocations *allocations = { "Allocations": [ { "Invoice": { "LineItems": [], "InvoiceID": "c45720a1-ade3-4a38-a064-d15489be6841" }, "Amount": 1, "Date": "2019-03-05" } ] }; // 
Boolean *summarizeErrors = true; // If false return 200 OK and mix of successfully created objects and any with validation errors (optional) (default to false)

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

// Creates allocation for a specific credit note
[apiInstance createCreditNoteAllocationWith:xeroTenantId
    creditNoteID:creditNoteID
    allocations:allocations
    summarizeErrors:summarizeErrors
              completionHandler: ^(Allocations output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const creditNoteID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for a Credit Note


const summarizeErrors = true;  // {Boolean} If false return 200 OK and mix of successfully created objects and any with validation errors
const allocations: Allocations = { allocations: [{ amount: 1.0, date: "2019-03-05", invoice: { invoiceID: "c45720a1-ade3-4a38-a064-d15489be6841", lineItems: [], type: Invoice.TypeEnum.ACCPAY, contact: {} }}]}

try {
  const response = await xero.accountingApi.createCreditNoteAllocation(xeroTenantId, creditNoteID, allocations,  summarizeErrors);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var creditNoteID = new UUID(); // UUID | Unique identifier for a Credit Note (default to null)
            var allocations = new Allocations(); // Allocations | 
            var summarizeErrors = true;  // Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors (optional)  (default to false)

            try
            {
                // Creates allocation for a specific credit note
                Allocations result = apiInstance.createCreditNoteAllocation(xeroTenantId, creditNoteID, allocations, summarizeErrors);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createCreditNoteAllocation: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$creditNoteID = "00000000-0000-0000-0000-000000000000";
$summarizeErrors = true;
$currDate = new DateTime('2020-12-10');

$invoice = new XeroAPI\XeroPHP\Models\Accounting\Invoice;
$invoice->setInvoiceID('00000000-0000-0000-0000-000000000000');

$allocation = new XeroAPI\XeroPHP\Models\Accounting\Allocation;
$allocation->setAmount(1.0);
$allocation->setDate($currDate);
$allocation->setInvoice($invoice);

$allocations = new XeroAPI\XeroPHP\Models\Accounting\Allocations;
$arr_allocations = [];
array_push($arr_allocations, $allocation);
$allocations->setAllocations($arr_allocations);

try {
  $result = $apiInstance->createCreditNoteAllocation($xeroTenantId, $creditNoteID, $allocations, $summarizeErrors);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createCreditNoteAllocation: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $creditNoteID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for a Credit Note
my $allocations = ::Object::Allocations->new(); # Allocations | 
my $summarizeErrors = true; # Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors

eval { 
    my $result = $api_instance->createCreditNoteAllocation(xeroTenantId => $xeroTenantId, creditNoteID => $creditNoteID, allocations => $allocations, summarizeErrors => $summarizeErrors);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createCreditNoteAllocation: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_credit_note_allocation():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    creditNoteID = '00000000-0000-0000-0000-000000000000'
    summarizeErrors = 'True'
    curr_date = dateutil.parser.parse('2020-12-03T00:00:00Z')

    invoice = Invoice(
        invoiceID = "00000000-0000-0000-0000-000000000000")

    allocation = Allocation(
        amount = 1.0,
        date = curr_date,
        invoice = invoice)

    allocations = Allocations( 
        allocations = [allocation])
    
    try:
        api_response = api_instance.create_credit_note_allocation(xeroTenantId, creditNoteID, allocations, summarizeErrors)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createCreditNoteAllocation: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let creditNoteID = 00000000-0000-0000-0000-000000000000; // UUID
    let allocations = { "Allocations": [ { "Invoice": { "LineItems": [], "InvoiceID": "c45720a1-ade3-4a38-a064-d15489be6841" }, "Amount": 1, "Date": "2019-03-05" } ] }; // Allocations
    let summarizeErrors = true; // Boolean

    let mut context = AccountingApi::Context::default();
    let result = client.createCreditNoteAllocation(xeroTenantId, creditNoteID, allocations, summarizeErrors, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID creditNoteID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        String fileName = "xero-dev.jpg";
        Boolean includeOnline = true;
        File input = new File("/path/to/local/xero-dev.jpg");
        java.nio.file.Path inputPath = input.toPath();
        byte[] body = FileUtils.readFileToByteArray(input);
        String mimeType = Files.probeContentType(inputPath);

        try {
            Attachments result = apiInstance.createCreditNoteAttachmentByFileName(accessToken, xeroTenantId, creditNoteID, fileName, body, includeOnline, mimeType);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createCreditNoteAttachmentByFileName");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID creditNoteID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for a Credit Note
        String fileName = xero-dev.jpg; // String | Name of the file you are attaching to Credit Note
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 
        Boolean includeOnline = true; // Boolean | Allows an attachment to be seen by the end customer within their online invoice
        try {
            Attachments result = apiInstance.createCreditNoteAttachmentByFileName(xeroTenantId, creditNoteID, fileName, body, includeOnline);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createCreditNoteAttachmentByFileName");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *creditNoteID = 00000000-0000-0000-0000-000000000000; // Unique identifier for a Credit Note (default to null)
String *fileName = xero-dev.jpg; // Name of the file you are attaching to Credit Note (default to null)
byte[] *body = BYTE_ARRAY_DATA_HERE; // 
Boolean *includeOnline = true; // Allows an attachment to be seen by the end customer within their online invoice (optional) (default to false)

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

// Creates an attachment for a specific credit note
[apiInstance createCreditNoteAttachmentByFileNameWith:xeroTenantId
    creditNoteID:creditNoteID
    fileName:fileName
    body:body
    includeOnline:includeOnline
              completionHandler: ^(Attachments output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const creditNoteID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for a Credit Note
const fileName = "xero-dev.jpg";  // {String} Name of the file you are attaching to Credit Note
const path = require("path");
const mime = require("mime-types");
const pathToUpload = path.resolve(__dirname, "../public/images/xero-dev.jpg"); // determine the path to your file
import * as fs from "fs";
const body = fs.createReadStream(pathToUpload); // {fs.ReadStream} read the file
const contentType = mime.lookup(fileName);

const includeOnline = true;  // {Boolean} Allows an attachment to be seen by the end customer within their online invoice


try {
  const response = await xero.accountingApi.createCreditNoteAttachmentByFileName(xeroTenantId, creditNoteID, fileName, body,  includeOnline, {
    headers: {
      "Content-Type": contentType,
    }
  });
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var creditNoteID = new UUID(); // UUID | Unique identifier for a Credit Note (default to null)
            var fileName = xero-dev.jpg;  // String | Name of the file you are attaching to Credit Note (default to null)
            var body = BYTE_ARRAY_DATA_HERE;  // byte[] | 
            var includeOnline = true;  // Boolean | Allows an attachment to be seen by the end customer within their online invoice (optional)  (default to false)

            try
            {
                // Creates an attachment for a specific credit note
                Attachments result = apiInstance.createCreditNoteAttachmentByFileName(xeroTenantId, creditNoteID, fileName, body, includeOnline);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createCreditNoteAttachmentByFileName: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$creditNoteID = "00000000-0000-0000-0000-000000000000";
$fileName = "xero-dev.jpg";
$includeOnline = true;

$handle = fopen($fileName, "r");
$body = fread($handle, filesize($fileName));
fclose($handle);

try {
  $result = $apiInstance->createCreditNoteAttachmentByFileName($xeroTenantId, $creditNoteID, $fileName, $body, $includeOnline);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createCreditNoteAttachmentByFileName: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $creditNoteID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for a Credit Note
my $fileName = xero-dev.jpg; # String | Name of the file you are attaching to Credit Note
my $body = ::Object::byte[]->new(); # byte[] | 
my $includeOnline = true; # Boolean | Allows an attachment to be seen by the end customer within their online invoice

eval { 
    my $result = $api_instance->createCreditNoteAttachmentByFileName(xeroTenantId => $xeroTenantId, creditNoteID => $creditNoteID, fileName => $fileName, body => $body, includeOnline => $includeOnline);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createCreditNoteAttachmentByFileName: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_credit_note_attachment_by_file_name():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    creditNoteID = '00000000-0000-0000-0000-000000000000'
    fileName = 'xero-dev.jpg'
    includeOnline = 'true'
    
        // TODO: BINARY CREATE 
    try:
        api_response = api_instance.create_credit_note_attachment_by_file_name(xeroTenantId, creditNoteID, fileName, body, includeOnline)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createCreditNoteAttachmentByFileName: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let creditNoteID = 00000000-0000-0000-0000-000000000000; // UUID
    let fileName = xero-dev.jpg; // String
    let body = BYTE_ARRAY_DATA_HERE; // byte[]
    let includeOnline = true; // Boolean

    let mut context = AccountingApi::Context::default();
    let result = client.createCreditNoteAttachmentByFileName(xeroTenantId, creditNoteID, fileName, body, includeOnline, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID creditNoteID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

        try {
            HistoryRecords result = apiInstance.createCreditNoteHistory(accessToken, xeroTenantId, creditNoteID, historyRecords);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createCreditNoteHistory");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID creditNoteID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for a Credit Note
        HistoryRecords historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords | 
        try {
            HistoryRecords result = apiInstance.createCreditNoteHistory(xeroTenantId, creditNoteID, historyRecords);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createCreditNoteHistory");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *creditNoteID = 00000000-0000-0000-0000-000000000000; // Unique identifier for a Credit Note (default to null)
HistoryRecords *historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // 

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

// Retrieves history records of a specific credit note
[apiInstance createCreditNoteHistoryWith:xeroTenantId
    creditNoteID:creditNoteID
    historyRecords:historyRecords
              completionHandler: ^(HistoryRecords output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);
const historyRecords: HistoryRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] };  // {HistoryRecords} 
const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const creditNoteID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for a Credit Note


try {
  const response = await xero.accountingApi.createCreditNoteHistory(xeroTenantId, creditNoteID, historyRecords);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var creditNoteID = new UUID(); // UUID | Unique identifier for a Credit Note (default to null)
            var historyRecords = new HistoryRecords(); // HistoryRecords | 

            try
            {
                // Retrieves history records of a specific credit note
                HistoryRecords result = apiInstance.createCreditNoteHistory(xeroTenantId, creditNoteID, historyRecords);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createCreditNoteHistory: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$creditNoteID = "00000000-0000-0000-0000-000000000000";

$historyRecord = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecord;
$historyRecord->setDetails('Hello World');

$historyRecords = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecords;
$arr_history_records = [];
array_push($arr_history_records, $historyRecord);
$historyRecords->setHistoryRecords($arr_history_records);

try {
  $result = $apiInstance->createCreditNoteHistory($xeroTenantId, $creditNoteID, $historyRecords);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createCreditNoteHistory: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $creditNoteID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for a Credit Note
my $historyRecords = ::Object::HistoryRecords->new(); # HistoryRecords | 

eval { 
    my $result = $api_instance->createCreditNoteHistory(xeroTenantId => $xeroTenantId, creditNoteID => $creditNoteID, historyRecords => $historyRecords);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createCreditNoteHistory: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_credit_note_history():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    creditNoteID = '00000000-0000-0000-0000-000000000000'

    history_record = HistoryRecord(
        details = "Hello World")

    history_records = HistoryRecords( 
        history_records = [history_record])
    
    try:
        api_response = api_instance.create_credit_note_history(xeroTenantId, creditNoteID, historyRecords)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createCreditNoteHistory: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let creditNoteID = 00000000-0000-0000-0000-000000000000; // UUID
    let historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords

    let mut context = AccountingApi::Context::default();
    let result = client.createCreditNoteHistory(xeroTenantId, creditNoteID, historyRecords, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        Boolean summarizeErrors = true;
        Integer unitdp = 4;
        LocalDate currDate = LocalDate.now();
        Contact contact = new Contact();
        contact.setContactID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        LineItem lineItem = new LineItem();
        lineItem.setDescription("Foobar");
        lineItem.setQuantity(1.0);
        lineItem.setUnitAmount(20.0);
        lineItem.setAccountCode("000");
        List<LineItems> lineItems = new ArrayList<LineItems>();
        lineItems.add(lineItem);
        CreditNote creditNote = new CreditNote();
        creditNote.setType(com.xero.models.accounting.CreditNote.TypeEnum.ACCPAYCREDIT);
        creditNote.setContact(contact);
        creditNote.setDate(currDate);
        creditNote.setLineItems(lineItems);
        CreditNotes creditNotes = new CreditNotes();
        creditNotes.addCreditNotesItem(creditNote);

        try {
            CreditNotes result = apiInstance.createCreditNotes(accessToken, xeroTenantId, creditNotes, summarizeErrors, unitdp);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createCreditNotes");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        CreditNotes creditNotes = { "CreditNotes":[ { "Type":"ACCPAYCREDIT", "Contact":{ "ContactID":"430fa14a-f945-44d3-9f97-5df5e28441b8" }, "Date":"2019-01-05", "LineItems":[ { "Description":"Foobar", "Quantity":2.0, "UnitAmount":20.0, "AccountCode":"400" } ] } ] }; // CreditNotes | 
        Boolean summarizeErrors = true; // Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors
        Integer unitdp = 4; // Integer | e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts
        try {
            CreditNotes result = apiInstance.createCreditNotes(xeroTenantId, creditNotes, summarizeErrors, unitdp);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createCreditNotes");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
CreditNotes *creditNotes = { "CreditNotes":[ { "Type":"ACCPAYCREDIT", "Contact":{ "ContactID":"430fa14a-f945-44d3-9f97-5df5e28441b8" }, "Date":"2019-01-05", "LineItems":[ { "Description":"Foobar", "Quantity":2.0, "UnitAmount":20.0, "AccountCode":"400" } ] } ] }; // 
Boolean *summarizeErrors = true; // If false return 200 OK and mix of successfully created objects and any with validation errors (optional) (default to false)
Integer *unitdp = 4; // e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts (optional) (default to null)

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

// Creates a new credit note
[apiInstance createCreditNotesWith:xeroTenantId
    creditNotes:creditNotes
    summarizeErrors:summarizeErrors
    unitdp:unitdp
              completionHandler: ^(CreditNotes output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant


const summarizeErrors = true;  // {Boolean} If false return 200 OK and mix of successfully created objects and any with validation errors

const unitdp = 4;  // {Integer} e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts
const creditNotes: CreditNotes = { creditNotes: [{ type: CreditNote.TypeEnum.ACCPAYCREDIT, contact: { contactID: "430fa14a-f945-44d3-9f97-5df5e28441b8" }, date: "2019-01-05", lineItems: [{ description: "Foobar", quantity: 2.0, unitAmount: 20.0, accountCode: "400" }]}]}

try {
  const response = await xero.accountingApi.createCreditNotes(xeroTenantId, creditNotes,  summarizeErrors, unitdp);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var creditNotes = new CreditNotes(); // CreditNotes | 
            var summarizeErrors = true;  // Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors (optional)  (default to false)
            var unitdp = 4;  // Integer | e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts (optional)  (default to null)

            try
            {
                // Creates a new credit note
                CreditNotes result = apiInstance.createCreditNotes(xeroTenantId, creditNotes, summarizeErrors, unitdp);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createCreditNotes: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$summarizeErrors = true;
$unitdp = 4;
$currDate = new DateTime('2020-12-10');

$contact = new XeroAPI\XeroPHP\Models\Accounting\Contact;
$contact->setContactID('00000000-0000-0000-0000-000000000000');

$lineItem = new XeroAPI\XeroPHP\Models\Accounting\LineItem;
$lineItem->setDescription('Foobar');
$lineItem->setQuantity(1.0);
$lineItem->setUnitAmount(20.0);
$lineItem->setAccountCode('000');
$lineItems = [];
array_push($lineItems, $lineItem);

$creditNote = new XeroAPI\XeroPHP\Models\Accounting\CreditNote;
$creditNote->setType(XeroAPI\XeroPHP\Models\Accounting\CreditNote::TYPE_ACCPAYCREDIT);
$creditNote->setContact($contact);
$creditNote->setDate($currDate);
$creditNote->setLineItems($lineItems);

$creditNotes = new XeroAPI\XeroPHP\Models\Accounting\CreditNotes;
$arr_credit_notes = [];
array_push($arr_credit_notes, $creditNote);
$creditNotes->setCreditNotes($arr_credit_notes);

try {
  $result = $apiInstance->createCreditNotes($xeroTenantId, $creditNotes, $summarizeErrors, $unitdp);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createCreditNotes: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $creditNotes = ::Object::CreditNotes->new(); # CreditNotes | 
my $summarizeErrors = true; # Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors
my $unitdp = 4; # Integer | e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts

eval { 
    my $result = $api_instance->createCreditNotes(xeroTenantId => $xeroTenantId, creditNotes => $creditNotes, summarizeErrors => $summarizeErrors, unitdp => $unitdp);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createCreditNotes: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_credit_notes():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    summarizeErrors = 'True'
    curr_date = dateutil.parser.parse('2020-12-03T00:00:00Z')

    contact = Contact(
        contact_id = "00000000-0000-0000-0000-000000000000")

    line_item = LineItem(
        description = "Foobar",
        quantity = 1.0,
        unit_amount = 20.0,
        account_code = "000")
    
    line_items = []    
    line_items.append(line_item)

    credit_note = CreditNote(
        type = "ACCPAYCREDIT",
        contact = contact,
        date = curr_date,
        line_items = line_items)

    creditNotes = CreditNotes( 
        credit_notes = [credit_note])
    
    try:
        api_response = api_instance.create_credit_notes(xeroTenantId, creditNotes, summarizeErrors, unitdp)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createCreditNotes: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let creditNotes = { "CreditNotes":[ { "Type":"ACCPAYCREDIT", "Contact":{ "ContactID":"430fa14a-f945-44d3-9f97-5df5e28441b8" }, "Date":"2019-01-05", "LineItems":[ { "Description":"Foobar", "Quantity":2.0, "UnitAmount":20.0, "AccountCode":"400" } ] } ] }; // CreditNotes
    let summarizeErrors = true; // Boolean
    let unitdp = 4; // Integer

    let mut context = AccountingApi::Context::default();
    let result = client.createCreditNotes(xeroTenantId, creditNotes, summarizeErrors, unitdp, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        Currency currency = new Currency();
        currency.setCode(com.xero.models.accounting.CurrencyCode.USD);
        currency.setDescription("United States Dollar");

        try {
            Currencies result = apiInstance.createCurrency(accessToken, xeroTenantId, currency);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createCurrency");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        Currency currency = { "Code": "USD", "Description": "United States Dollar" }; // Currency | 
        try {
            Currencies result = apiInstance.createCurrency(xeroTenantId, currency);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createCurrency");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
Currency *currency = { "Code": "USD", "Description": "United States Dollar" }; // 

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

// Create a new currency for a Xero organisation
[apiInstance createCurrencyWith:xeroTenantId
    currency:currency
              completionHandler: ^(Currencies output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const currency: Currency = { code: CurrencyCode.USD, description: "United States Dollar" }

try {
  const response = await xero.accountingApi.createCurrency(xeroTenantId, currency);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var currency = new Currency(); // Currency | 

            try
            {
                // Create a new currency for a Xero organisation
                Currencies result = apiInstance.createCurrency(xeroTenantId, currency);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createCurrency: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";

$currency = new XeroAPI\XeroPHP\Models\Accounting\Currency;
$currency->setCode(XeroAPI\XeroPHP\Models\Accounting\CurrencyCode::USD);
$currency->setDescription('United States Dollar');

try {
  $result = $apiInstance->createCurrency($xeroTenantId, $currency);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createCurrency: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $currency = ::Object::Currency->new(); # Currency | 

eval { 
    my $result = $api_instance->createCurrency(xeroTenantId => $xeroTenantId, currency => $currency);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createCurrency: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_currency():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'

    currency = Currency(
        code = CurrencyCode.USD,
        description = "United States Dollar")
    
    try:
        api_response = api_instance.create_currency(xeroTenantId, currency)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createCurrency: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let currency = { "Code": "USD", "Description": "United States Dollar" }; // Currency

    let mut context = AccountingApi::Context::default();
    let result = client.createCurrency(xeroTenantId, currency, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        Boolean summarizeErrors = true;
        Employee employee = new Employee();
        employee.setFirstName("Nick");
        employee.setLastName("Fury");
        Employees employees = new Employees();
        employees.addEmployeesItem(employee);

        try {
            Employees result = apiInstance.createEmployees(accessToken, xeroTenantId, employees, summarizeErrors);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createEmployees");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        Employees employees = { "Employees": [ { "FirstName": "Nick", "LastName": "Fury", "ExternalLink": { "Url": "http://twitter.com/#!/search/Nick+Fury" } } ] }; // Employees | 
        Boolean summarizeErrors = true; // Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors
        try {
            Employees result = apiInstance.createEmployees(xeroTenantId, employees, summarizeErrors);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createEmployees");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
Employees *employees = { "Employees": [ { "FirstName": "Nick", "LastName": "Fury", "ExternalLink": { "Url": "http://twitter.com/#!/search/Nick+Fury" } } ] }; // 
Boolean *summarizeErrors = true; // If false return 200 OK and mix of successfully created objects and any with validation errors (optional) (default to false)

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

// Creates new employees used in Xero payrun
[apiInstance createEmployeesWith:xeroTenantId
    employees:employees
    summarizeErrors:summarizeErrors
              completionHandler: ^(Employees output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant


const summarizeErrors = true;  // {Boolean} If false return 200 OK and mix of successfully created objects and any with validation errors
const employees: Employees = { employees: [{ firstName: "Nick", lastName: "Fury", externalLink: { url: "http://twitter.com/#!/search/Nick+Fury" }}]}

try {
  const response = await xero.accountingApi.createEmployees(xeroTenantId, employees,  summarizeErrors);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var employees = new Employees(); // Employees | 
            var summarizeErrors = true;  // Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors (optional)  (default to false)

            try
            {
                // Creates new employees used in Xero payrun
                Employees result = apiInstance.createEmployees(xeroTenantId, employees, summarizeErrors);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createEmployees: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$summarizeErrors = true;

$employee = new XeroAPI\XeroPHP\Models\Accounting\Employee;
$employee->setFirstName('Nick');
$employee->setLastName('Fury');

$employees = new XeroAPI\XeroPHP\Models\Accounting\Employees;
$arr_employees = [];
array_push($arr_employees, $employee);
$employees->setEmployees($arr_employees);

try {
  $result = $apiInstance->createEmployees($xeroTenantId, $employees, $summarizeErrors);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createEmployees: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $employees = ::Object::Employees->new(); # Employees | 
my $summarizeErrors = true; # Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors

eval { 
    my $result = $api_instance->createEmployees(xeroTenantId => $xeroTenantId, employees => $employees, summarizeErrors => $summarizeErrors);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createEmployees: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_employees():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    summarizeErrors = 'True'

    employee = Employee(
        first_name = "Nick",
        last_name = "Fury")

    employees = Employees( 
        employees = [employee])
    
    try:
        api_response = api_instance.create_employees(xeroTenantId, employees, summarizeErrors)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createEmployees: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let employees = { "Employees": [ { "FirstName": "Nick", "LastName": "Fury", "ExternalLink": { "Url": "http://twitter.com/#!/search/Nick+Fury" } } ] }; // Employees
    let summarizeErrors = true; // Boolean

    let mut context = AccountingApi::Context::default();
    let result = client.createEmployees(xeroTenantId, employees, summarizeErrors, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID expenseClaimID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

        try {
            HistoryRecords result = apiInstance.createExpenseClaimHistory(accessToken, xeroTenantId, expenseClaimID, historyRecords);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createExpenseClaimHistory");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID expenseClaimID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for a ExpenseClaim
        HistoryRecords historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords | 
        try {
            HistoryRecords result = apiInstance.createExpenseClaimHistory(xeroTenantId, expenseClaimID, historyRecords);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createExpenseClaimHistory");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *expenseClaimID = 00000000-0000-0000-0000-000000000000; // Unique identifier for a ExpenseClaim (default to null)
HistoryRecords *historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // 

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

// Creates a history record for a specific expense claim
[apiInstance createExpenseClaimHistoryWith:xeroTenantId
    expenseClaimID:expenseClaimID
    historyRecords:historyRecords
              completionHandler: ^(HistoryRecords output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);
const historyRecords: HistoryRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] };  // {HistoryRecords} 
const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const expenseClaimID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for a ExpenseClaim


try {
  const response = await xero.accountingApi.createExpenseClaimHistory(xeroTenantId, expenseClaimID, historyRecords);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var expenseClaimID = new UUID(); // UUID | Unique identifier for a ExpenseClaim (default to null)
            var historyRecords = new HistoryRecords(); // HistoryRecords | 

            try
            {
                // Creates a history record for a specific expense claim
                HistoryRecords result = apiInstance.createExpenseClaimHistory(xeroTenantId, expenseClaimID, historyRecords);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createExpenseClaimHistory: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$expenseClaimID = "00000000-0000-0000-0000-000000000000";

$historyRecord = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecord;
$historyRecord->setDetails('Hello World');

$historyRecords = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecords;
$arr_history_records = [];
array_push($arr_history_records, $historyRecord);
$historyRecords->setHistoryRecords($arr_history_records);

try {
  $result = $apiInstance->createExpenseClaimHistory($xeroTenantId, $expenseClaimID, $historyRecords);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createExpenseClaimHistory: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $expenseClaimID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for a ExpenseClaim
my $historyRecords = ::Object::HistoryRecords->new(); # HistoryRecords | 

eval { 
    my $result = $api_instance->createExpenseClaimHistory(xeroTenantId => $xeroTenantId, expenseClaimID => $expenseClaimID, historyRecords => $historyRecords);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createExpenseClaimHistory: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_expense_claim_history():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    expenseClaimID = '00000000-0000-0000-0000-000000000000'

    history_record = HistoryRecord(
        details = "Hello World")

    history_records = HistoryRecords( 
        history_records = [history_record])
    
    try:
        api_response = api_instance.create_expense_claim_history(xeroTenantId, expenseClaimID, historyRecords)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createExpenseClaimHistory: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let expenseClaimID = 00000000-0000-0000-0000-000000000000; // UUID
    let historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords

    let mut context = AccountingApi::Context::default();
    let result = client.createExpenseClaimHistory(xeroTenantId, expenseClaimID, historyRecords, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        LocalDate currDate = LocalDate.now();
        User user = new User();
        user.setUserID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        Receipt receipt = new Receipt();
        receipt.setReceiptID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        receipt.setDate(currDate);
        List<Receipt> receipts = new ArrayList<Receipt>();
        receipts.add(receipt);
        ExpenseClaim expenseClaim = new ExpenseClaim();
        expenseClaim.setStatus(com.xero.models.accounting.ExpenseClaim.StatusEnum.SUBMITTED);
        expenseClaim.setUser(user);
        expenseClaim.setReceipts(receipts);
        ExpenseClaims expenseClaims = new ExpenseClaims();
        expenseClaims.addExpenseClaimsItem(expenseClaim);

        try {
            ExpenseClaims result = apiInstance.createExpenseClaims(accessToken, xeroTenantId, expenseClaims);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createExpenseClaims");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        ExpenseClaims expenseClaims = { "ExpenseClaims": [ { "Status": "SUBMITTED", "User": { "UserID": "d1164823-0ac1-41ad-987b-b4e30fe0b273" }, "Receipts": [ { "Lineitems": [], "ReceiptID": "dc1c7f6d-0a4c-402f-acac-551d62ce5816" } ] } ] }; // ExpenseClaims | 
        try {
            ExpenseClaims result = apiInstance.createExpenseClaims(xeroTenantId, expenseClaims);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createExpenseClaims");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
ExpenseClaims *expenseClaims = { "ExpenseClaims": [ { "Status": "SUBMITTED", "User": { "UserID": "d1164823-0ac1-41ad-987b-b4e30fe0b273" }, "Receipts": [ { "Lineitems": [], "ReceiptID": "dc1c7f6d-0a4c-402f-acac-551d62ce5816" } ] } ] }; // 

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

// Creates expense claims
[apiInstance createExpenseClaimsWith:xeroTenantId
    expenseClaims:expenseClaims
              completionHandler: ^(ExpenseClaims output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const expenseClaims: ExpenseClaims = { expenseClaims: [{ status: ExpenseClaim.StatusEnum.SUBMITTED, user: { userID: "d1164823-0ac1-41ad-987b-b4e30fe0b273" }, receipts: [{ receiptID: "dc1c7f6d-0a4c-402f-acac-551d62ce5816", lineItems: [], contact: {}, user: {}, date: "2018-01-01" }]}]}

try {
  const response = await xero.accountingApi.createExpenseClaims(xeroTenantId, expenseClaims);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var expenseClaims = new ExpenseClaims(); // ExpenseClaims | 

            try
            {
                // Creates expense claims
                ExpenseClaims result = apiInstance.createExpenseClaims(xeroTenantId, expenseClaims);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createExpenseClaims: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$currDate = new DateTime('2020-12-10');

$user = new XeroAPI\XeroPHP\Models\Accounting\User;
$user->setUserID('00000000-0000-0000-0000-000000000000');

$receipt = new XeroAPI\XeroPHP\Models\Accounting\Receipt;
$receipt->setReceiptID('00000000-0000-0000-0000-000000000000');
$receipt->setDate($currDate);
$receipts = [];
array_push($receipts, $receipt);

$expenseClaim = new XeroAPI\XeroPHP\Models\Accounting\ExpenseClaim;
$expenseClaim->setStatus(XeroAPI\XeroPHP\Models\Accounting\ExpenseClaim::STATUS_SUBMITTED);
$expenseClaim->setUser($user);
$expenseClaim->setReceipts($receipts);

$expenseClaims = new XeroAPI\XeroPHP\Models\Accounting\ExpenseClaims;
$arr_expense_claims = [];
array_push($arr_expense_claims, $expenseClaim);
$expenseClaims->setExpenseClaims($arr_expense_claims);

try {
  $result = $apiInstance->createExpenseClaims($xeroTenantId, $expenseClaims);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createExpenseClaims: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $expenseClaims = ::Object::ExpenseClaims->new(); # ExpenseClaims | 

eval { 
    my $result = $api_instance->createExpenseClaims(xeroTenantId => $xeroTenantId, expenseClaims => $expenseClaims);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createExpenseClaims: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_expense_claims():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    curr_date = dateutil.parser.parse('2020-12-03T00:00:00Z')

    user = User(
        user_id = "00000000-0000-0000-0000-000000000000")

    receipt = Receipt(
        receipt_id = "00000000-0000-0000-0000-000000000000",
        date = curr_date)
    
    receipts = []    
    receipts.append(receipt)

    expense_claim = ExpenseClaim(
        status = "SUBMITTED",
        user = user,
        receipts = receipts)

    expenseClaims = ExpenseClaims( 
        expense_claims = [expense_claim])
    
    try:
        api_response = api_instance.create_expense_claims(xeroTenantId, expenseClaims)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createExpenseClaims: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let expenseClaims = { "ExpenseClaims": [ { "Status": "SUBMITTED", "User": { "UserID": "d1164823-0ac1-41ad-987b-b4e30fe0b273" }, "Receipts": [ { "Lineitems": [], "ReceiptID": "dc1c7f6d-0a4c-402f-acac-551d62ce5816" } ] } ] }; // ExpenseClaims

    let mut context = AccountingApi::Context::default();
    let result = client.createExpenseClaims(xeroTenantId, expenseClaims, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID invoiceID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        String fileName = "xero-dev.jpg";
        Boolean includeOnline = true;
        File input = new File("/path/to/local/xero-dev.jpg");
        java.nio.file.Path inputPath = input.toPath();
        byte[] body = FileUtils.readFileToByteArray(input);
        String mimeType = Files.probeContentType(inputPath);

        try {
            Attachments result = apiInstance.createInvoiceAttachmentByFileName(accessToken, xeroTenantId, invoiceID, fileName, body, includeOnline, mimeType);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createInvoiceAttachmentByFileName");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID invoiceID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for an Invoice
        String fileName = xero-dev.jpg; // String | Name of the file you are attaching
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 
        Boolean includeOnline = true; // Boolean | Allows an attachment to be seen by the end customer within their online invoice
        try {
            Attachments result = apiInstance.createInvoiceAttachmentByFileName(xeroTenantId, invoiceID, fileName, body, includeOnline);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createInvoiceAttachmentByFileName");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *invoiceID = 00000000-0000-0000-0000-000000000000; // Unique identifier for an Invoice (default to null)
String *fileName = xero-dev.jpg; // Name of the file you are attaching (default to null)
byte[] *body = BYTE_ARRAY_DATA_HERE; // 
Boolean *includeOnline = true; // Allows an attachment to be seen by the end customer within their online invoice (optional) (default to false)

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

// Creates an attachment for a specific invoice or purchase bill by filename
[apiInstance createInvoiceAttachmentByFileNameWith:xeroTenantId
    invoiceID:invoiceID
    fileName:fileName
    body:body
    includeOnline:includeOnline
              completionHandler: ^(Attachments output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const invoiceID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for an Invoice
const fileName = "xero-dev.jpg";  // {String} Name of the file you are attaching
const path = require("path");
const mime = require("mime-types");
const pathToUpload = path.resolve(__dirname, "../public/images/xero-dev.jpg"); // determine the path to your file
import * as fs from "fs";
const body = fs.createReadStream(pathToUpload); // {fs.ReadStream} read the file
const contentType = mime.lookup(fileName);

const includeOnline = true;  // {Boolean} Allows an attachment to be seen by the end customer within their online invoice


try {
  const response = await xero.accountingApi.createInvoiceAttachmentByFileName(xeroTenantId, invoiceID, fileName, body,  includeOnline, {
    headers: {
      "Content-Type": contentType,
    }
  });
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var invoiceID = new UUID(); // UUID | Unique identifier for an Invoice (default to null)
            var fileName = xero-dev.jpg;  // String | Name of the file you are attaching (default to null)
            var body = BYTE_ARRAY_DATA_HERE;  // byte[] | 
            var includeOnline = true;  // Boolean | Allows an attachment to be seen by the end customer within their online invoice (optional)  (default to false)

            try
            {
                // Creates an attachment for a specific invoice or purchase bill by filename
                Attachments result = apiInstance.createInvoiceAttachmentByFileName(xeroTenantId, invoiceID, fileName, body, includeOnline);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createInvoiceAttachmentByFileName: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$invoiceID = "00000000-0000-0000-0000-000000000000";
$fileName = "xero-dev.jpg";
$includeOnline = true;

$handle = fopen($fileName, "r");
$body = fread($handle, filesize($fileName));
fclose($handle);

try {
  $result = $apiInstance->createInvoiceAttachmentByFileName($xeroTenantId, $invoiceID, $fileName, $body, $includeOnline);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createInvoiceAttachmentByFileName: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $invoiceID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for an Invoice
my $fileName = xero-dev.jpg; # String | Name of the file you are attaching
my $body = ::Object::byte[]->new(); # byte[] | 
my $includeOnline = true; # Boolean | Allows an attachment to be seen by the end customer within their online invoice

eval { 
    my $result = $api_instance->createInvoiceAttachmentByFileName(xeroTenantId => $xeroTenantId, invoiceID => $invoiceID, fileName => $fileName, body => $body, includeOnline => $includeOnline);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createInvoiceAttachmentByFileName: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_invoice_attachment_by_file_name():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    invoiceID = '00000000-0000-0000-0000-000000000000'
    fileName = 'xero-dev.jpg'
    includeOnline = 'true'
    
        // TODO: BINARY CREATE 
    try:
        api_response = api_instance.create_invoice_attachment_by_file_name(xeroTenantId, invoiceID, fileName, body, includeOnline)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createInvoiceAttachmentByFileName: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let invoiceID = 00000000-0000-0000-0000-000000000000; // UUID
    let fileName = xero-dev.jpg; // String
    let body = BYTE_ARRAY_DATA_HERE; // byte[]
    let includeOnline = true; // Boolean

    let mut context = AccountingApi::Context::default();
    let result = client.createInvoiceAttachmentByFileName(xeroTenantId, invoiceID, fileName, body, includeOnline, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID invoiceID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

        try {
            HistoryRecords result = apiInstance.createInvoiceHistory(accessToken, xeroTenantId, invoiceID, historyRecords);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createInvoiceHistory");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID invoiceID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for an Invoice
        HistoryRecords historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords | 
        try {
            HistoryRecords result = apiInstance.createInvoiceHistory(xeroTenantId, invoiceID, historyRecords);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createInvoiceHistory");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *invoiceID = 00000000-0000-0000-0000-000000000000; // Unique identifier for an Invoice (default to null)
HistoryRecords *historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // 

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

// Creates a history record for a specific invoice
[apiInstance createInvoiceHistoryWith:xeroTenantId
    invoiceID:invoiceID
    historyRecords:historyRecords
              completionHandler: ^(HistoryRecords output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);
const historyRecords: HistoryRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] };  // {HistoryRecords} 
const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const invoiceID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for an Invoice


try {
  const response = await xero.accountingApi.createInvoiceHistory(xeroTenantId, invoiceID, historyRecords);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var invoiceID = new UUID(); // UUID | Unique identifier for an Invoice (default to null)
            var historyRecords = new HistoryRecords(); // HistoryRecords | 

            try
            {
                // Creates a history record for a specific invoice
                HistoryRecords result = apiInstance.createInvoiceHistory(xeroTenantId, invoiceID, historyRecords);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createInvoiceHistory: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$invoiceID = "00000000-0000-0000-0000-000000000000";

$historyRecord = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecord;
$historyRecord->setDetails('Hello World');

$historyRecords = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecords;
$arr_history_records = [];
array_push($arr_history_records, $historyRecord);
$historyRecords->setHistoryRecords($arr_history_records);

try {
  $result = $apiInstance->createInvoiceHistory($xeroTenantId, $invoiceID, $historyRecords);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createInvoiceHistory: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $invoiceID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for an Invoice
my $historyRecords = ::Object::HistoryRecords->new(); # HistoryRecords | 

eval { 
    my $result = $api_instance->createInvoiceHistory(xeroTenantId => $xeroTenantId, invoiceID => $invoiceID, historyRecords => $historyRecords);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createInvoiceHistory: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_invoice_history():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    invoiceID = '00000000-0000-0000-0000-000000000000'

    history_record = HistoryRecord(
        details = "Hello World")

    history_records = HistoryRecords( 
        history_records = [history_record])
    
    try:
        api_response = api_instance.create_invoice_history(xeroTenantId, invoiceID, historyRecords)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createInvoiceHistory: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let invoiceID = 00000000-0000-0000-0000-000000000000; // UUID
    let historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords

    let mut context = AccountingApi::Context::default();
    let result = client.createInvoiceHistory(xeroTenantId, invoiceID, historyRecords, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        Boolean summarizeErrors = true;
        Integer unitdp = 4;
        LocalDate dateValue = LocalDate.of(2020, Month.OCTOBER, 10);
        LocalDate dueDateValue = LocalDate.of(2020, Month.OCTOBER, 28);
        Contact contact = new Contact();
        contact.setContactID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        LineItemTracking lineItemTracking = new LineItemTracking();
        lineItemTracking.setTrackingCategoryID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        lineItemTracking.setTrackingOptionID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        List<LineItemTracking> lineItemTrackings = new ArrayList<LineItemTracking>();
        lineItemTrackings.add(lineItemTracking);
        LineItem lineItem = new LineItem();
        lineItem.setDescription("Foobar");
        lineItem.setQuantity(1.0);
        lineItem.setUnitAmount(20.0);
        lineItem.setAccountCode("000");
        lineItem.setTracking(lineItemTrackings);
        List<LineItems> lineItems = new ArrayList<LineItems>();
        lineItems.add(lineItem);
        Invoice invoice = new Invoice();
        invoice.setType(com.xero.models.accounting.Invoice.TypeEnum.ACCREC);
        invoice.setContact(contact);
        invoice.setDate(dateValue);
        invoice.setDueDate(dueDateValue);
        invoice.setLineItems(lineItems);
        invoice.setReference("Website Design");
        invoice.setStatus(com.xero.models.accounting.Invoice.StatusEnum.DRAFT);
        Invoices invoices = new Invoices();
        invoices.addInvoicesItem(invoice);

        try {
            Invoices result = apiInstance.createInvoices(accessToken, xeroTenantId, invoices, summarizeErrors, unitdp);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createInvoices");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        Invoices invoices = { "Invoices": [ { "Type": "ACCREC", "Contact": { "ContactID": "430fa14a-f945-44d3-9f97-5df5e28441b8" }, "LineItems": [ { "Description": "Acme Tires", "Quantity": 2, "UnitAmount": 20, "AccountCode": "200", "TaxType": "NONE", "LineAmount": 40 } ], "Date": "2019-03-11", "DueDate": "2018-12-10", "Reference": "Website Design", "Status": "AUTHORISED" } ] }; // Invoices | 
        Boolean summarizeErrors = true; // Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors
        Integer unitdp = 4; // Integer | e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts
        try {
            Invoices result = apiInstance.createInvoices(xeroTenantId, invoices, summarizeErrors, unitdp);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createInvoices");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
Invoices *invoices = { "Invoices": [ { "Type": "ACCREC", "Contact": { "ContactID": "430fa14a-f945-44d3-9f97-5df5e28441b8" }, "LineItems": [ { "Description": "Acme Tires", "Quantity": 2, "UnitAmount": 20, "AccountCode": "200", "TaxType": "NONE", "LineAmount": 40 } ], "Date": "2019-03-11", "DueDate": "2018-12-10", "Reference": "Website Design", "Status": "AUTHORISED" } ] }; // 
Boolean *summarizeErrors = true; // If false return 200 OK and mix of successfully created objects and any with validation errors (optional) (default to false)
Integer *unitdp = 4; // e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts (optional) (default to null)

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

// Creates one or more sales invoices or purchase bills
[apiInstance createInvoicesWith:xeroTenantId
    invoices:invoices
    summarizeErrors:summarizeErrors
    unitdp:unitdp
              completionHandler: ^(Invoices output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant


const summarizeErrors = true;  // {Boolean} If false return 200 OK and mix of successfully created objects and any with validation errors

const unitdp = 4;  // {Integer} e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts
const invoices: Invoices = { invoices: [{ type: Invoice.TypeEnum.ACCREC, contact: { contactID: "00000000-0000-0000-0000-000000000000" }, lineItems: [{ description: "Acme Tires", quantity: 2.0, unitAmount: 20.0, accountCode: "000", taxType: TaxType.NONE, lineAmount: 40.0 }], date: "2019-03-11", dueDate: "2018-12-10", reference: "Website Design", status: Invoice.StatusEnum.DRAFT }]}

try {
  const response = await xero.accountingApi.createInvoices(xeroTenantId, invoices,  summarizeErrors, unitdp);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var invoices = new Invoices(); // Invoices | 
            var summarizeErrors = true;  // Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors (optional)  (default to false)
            var unitdp = 4;  // Integer | e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts (optional)  (default to null)

            try
            {
                // Creates one or more sales invoices or purchase bills
                Invoices result = apiInstance.createInvoices(xeroTenantId, invoices, summarizeErrors, unitdp);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createInvoices: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$summarizeErrors = true;
$unitdp = 4;
$dateValue = new DateTime('2020-10-10');
$dueDateValue = new DateTime('2020-10-28');

$contact = new XeroAPI\XeroPHP\Models\Accounting\Contact;
$contact->setContactID('00000000-0000-0000-0000-000000000000');

$lineItemTracking = new XeroAPI\XeroPHP\Models\Accounting\LineItemTracking;
$lineItemTracking->setTrackingCategoryID('00000000-0000-0000-0000-000000000000');
$lineItemTracking->setTrackingOptionID('00000000-0000-0000-0000-000000000000');
$lineItemTrackings = [];
array_push($lineItemTrackings, $lineItemTracking);

$lineItem = new XeroAPI\XeroPHP\Models\Accounting\LineItem;
$lineItem->setDescription('Foobar');
$lineItem->setQuantity(1.0);
$lineItem->setUnitAmount(20.0);
$lineItem->setAccountCode('000');
$lineItem->setTracking(lineItemTrackings);
$lineItems = [];
array_push($lineItems, $lineItem);

$invoice = new XeroAPI\XeroPHP\Models\Accounting\Invoice;
$invoice->setType(XeroAPI\XeroPHP\Models\Accounting\Invoice::TYPE_ACCREC);
$invoice->setContact($contact);
$invoice->setDate($dateValue);
$invoice->setDueDate($dueDateValue);
$invoice->setLineItems($lineItems);
$invoice->setReference('Website Design');
$invoice->setStatus(XeroAPI\XeroPHP\Models\Accounting\Invoice::STATUS_DRAFT);

$invoices = new XeroAPI\XeroPHP\Models\Accounting\Invoices;
$arr_invoices = [];
array_push($arr_invoices, $invoice);
$invoices->setInvoices($arr_invoices);

try {
  $result = $apiInstance->createInvoices($xeroTenantId, $invoices, $summarizeErrors, $unitdp);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createInvoices: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $invoices = ::Object::Invoices->new(); # Invoices | 
my $summarizeErrors = true; # Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors
my $unitdp = 4; # Integer | e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts

eval { 
    my $result = $api_instance->createInvoices(xeroTenantId => $xeroTenantId, invoices => $invoices, summarizeErrors => $summarizeErrors, unitdp => $unitdp);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createInvoices: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_invoices():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    summarizeErrors = 'True'
    date_value = dateutil.parser.parse('2020-10-10T00:00:00Z')
    due_date_value = dateutil.parser.parse('2020-10-28T00:00:00Z')

    contact = Contact(
        contact_id = "00000000-0000-0000-0000-000000000000")

    line_item_tracking = LineItemTracking(
        tracking_category_id = "00000000-0000-0000-0000-000000000000",
        tracking_option_id = "00000000-0000-0000-0000-000000000000")
    
    line_item_trackings = []    
    line_item_trackings.append(line_item_tracking)

    line_item = LineItem(
        description = "Foobar",
        quantity = 1.0,
        unit_amount = 20.0,
        account_code = "000",
        tracking = lineItemTrackings)
    
    line_items = []    
    line_items.append(line_item)

    invoice = Invoice(
        type = "ACCREC",
        contact = contact,
        date = date_value,
        due_date = due_date_value,
        line_items = line_items,
        reference = "Website Design",
        status = "DRAFT")

    invoices = Invoices( 
        invoices = [invoice])
    
    try:
        api_response = api_instance.create_invoices(xeroTenantId, invoices, summarizeErrors, unitdp)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createInvoices: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let invoices = { "Invoices": [ { "Type": "ACCREC", "Contact": { "ContactID": "430fa14a-f945-44d3-9f97-5df5e28441b8" }, "LineItems": [ { "Description": "Acme Tires", "Quantity": 2, "UnitAmount": 20, "AccountCode": "200", "TaxType": "NONE", "LineAmount": 40 } ], "Date": "2019-03-11", "DueDate": "2018-12-10", "Reference": "Website Design", "Status": "AUTHORISED" } ] }; // Invoices
    let summarizeErrors = true; // Boolean
    let unitdp = 4; // Integer

    let mut context = AccountingApi::Context::default();
    let result = client.createInvoices(xeroTenantId, invoices, summarizeErrors, unitdp, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID itemID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

        try {
            HistoryRecords result = apiInstance.createItemHistory(accessToken, xeroTenantId, itemID, historyRecords);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createItemHistory");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID itemID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for an Item
        HistoryRecords historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords | 
        try {
            HistoryRecords result = apiInstance.createItemHistory(xeroTenantId, itemID, historyRecords);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createItemHistory");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *itemID = 00000000-0000-0000-0000-000000000000; // Unique identifier for an Item (default to null)
HistoryRecords *historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // 

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

// Creates a history record for a specific item
[apiInstance createItemHistoryWith:xeroTenantId
    itemID:itemID
    historyRecords:historyRecords
              completionHandler: ^(HistoryRecords output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);
const historyRecords: HistoryRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] };  // {HistoryRecords} 
const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const itemID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for an Item


try {
  const response = await xero.accountingApi.createItemHistory(xeroTenantId, itemID, historyRecords);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var itemID = new UUID(); // UUID | Unique identifier for an Item (default to null)
            var historyRecords = new HistoryRecords(); // HistoryRecords | 

            try
            {
                // Creates a history record for a specific item
                HistoryRecords result = apiInstance.createItemHistory(xeroTenantId, itemID, historyRecords);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createItemHistory: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$itemID = "00000000-0000-0000-0000-000000000000";

$historyRecord = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecord;
$historyRecord->setDetails('Hello World');

$historyRecords = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecords;
$arr_history_records = [];
array_push($arr_history_records, $historyRecord);
$historyRecords->setHistoryRecords($arr_history_records);

try {
  $result = $apiInstance->createItemHistory($xeroTenantId, $itemID, $historyRecords);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createItemHistory: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $itemID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for an Item
my $historyRecords = ::Object::HistoryRecords->new(); # HistoryRecords | 

eval { 
    my $result = $api_instance->createItemHistory(xeroTenantId => $xeroTenantId, itemID => $itemID, historyRecords => $historyRecords);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createItemHistory: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_item_history():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    itemID = '00000000-0000-0000-0000-000000000000'

    history_record = HistoryRecord(
        details = "Hello World")

    history_records = HistoryRecords( 
        history_records = [history_record])
    
    try:
        api_response = api_instance.create_item_history(xeroTenantId, itemID, historyRecords)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createItemHistory: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let itemID = 00000000-0000-0000-0000-000000000000; // UUID
    let historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords

    let mut context = AccountingApi::Context::default();
    let result = client.createItemHistory(xeroTenantId, itemID, historyRecords, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        Boolean summarizeErrors = true;
        Integer unitdp = 4;
        Purchase purchaseDetails = new Purchase();
        purchaseDetails.setCoGSAccountCode("500");
        Item item = new Item();
        item.setCode("abcXYZ123");
        item.setName("HelloWorld");
        item.setDescription("Foobar");
        item.setInventoryAssetAccountCode("140");
        item.setPurchaseDetails(purchaseDetails);
        Items items = new Items();
        items.addItemsItem(item);

        try {
            Items result = apiInstance.createItems(accessToken, xeroTenantId, items, summarizeErrors, unitdp);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createItems");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        Items items = { "Items": [ { "Code": "code123", "Name": "Item Name XYZ", "Description": "Foobar", "InventoryAssetAccountCode": "140", "PurchaseDetails": { "COGSAccountCode": "500" } } ] }; // Items | 
        Boolean summarizeErrors = true; // Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors
        Integer unitdp = 4; // Integer | e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts
        try {
            Items result = apiInstance.createItems(xeroTenantId, items, summarizeErrors, unitdp);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createItems");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
Items *items = { "Items": [ { "Code": "code123", "Name": "Item Name XYZ", "Description": "Foobar", "InventoryAssetAccountCode": "140", "PurchaseDetails": { "COGSAccountCode": "500" } } ] }; // 
Boolean *summarizeErrors = true; // If false return 200 OK and mix of successfully created objects and any with validation errors (optional) (default to false)
Integer *unitdp = 4; // e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts (optional) (default to null)

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

// Creates one or more items
[apiInstance createItemsWith:xeroTenantId
    items:items
    summarizeErrors:summarizeErrors
    unitdp:unitdp
              completionHandler: ^(Items output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant


const summarizeErrors = true;  // {Boolean} If false return 200 OK and mix of successfully created objects and any with validation errors

const unitdp = 4;  // {Integer} e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts
const items: Items = { items: [{ code: "abcXYZ123", name: "HelloWorld11", description: "Foobar", inventoryAssetAccountCode: "140", purchaseDetails: { cOGSAccountCode: "500" }}]}

try {
  const response = await xero.accountingApi.createItems(xeroTenantId, items,  summarizeErrors, unitdp);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var items = new Items(); // Items | 
            var summarizeErrors = true;  // Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors (optional)  (default to false)
            var unitdp = 4;  // Integer | e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts (optional)  (default to null)

            try
            {
                // Creates one or more items
                Items result = apiInstance.createItems(xeroTenantId, items, summarizeErrors, unitdp);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createItems: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$summarizeErrors = true;
$unitdp = 4;

$purchaseDetails = new XeroAPI\XeroPHP\Models\Accounting\Purchase;
$purchaseDetails->setCoGSAccountCode('500');

$item = new XeroAPI\XeroPHP\Models\Accounting\Item;
$item->setCode('abcXYZ123');
$item->setName('HelloWorld');
$item->setDescription('Foobar');
$item->setInventoryAssetAccountCode('140');
$item->setPurchaseDetails($purchaseDetails);

$items = new XeroAPI\XeroPHP\Models\Accounting\Items;
$arr_items = [];
array_push($arr_items, $item);
$items->setItems($arr_items);

try {
  $result = $apiInstance->createItems($xeroTenantId, $items, $summarizeErrors, $unitdp);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createItems: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $items = ::Object::Items->new(); # Items | 
my $summarizeErrors = true; # Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors
my $unitdp = 4; # Integer | e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts

eval { 
    my $result = $api_instance->createItems(xeroTenantId => $xeroTenantId, items => $items, summarizeErrors => $summarizeErrors, unitdp => $unitdp);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createItems: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_items():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    summarizeErrors = 'True'

    purchase_details = Purchase(
        cogs_account_code = "500")

    item = Item(
        code = "abcXYZ123",
        name = "HelloWorld",
        description = "Foobar",
        inventory_asset_account_code = "140",
        purchase_details = purchase_details)

    items = Items( 
        items = [item])
    
    try:
        api_response = api_instance.create_items(xeroTenantId, items, summarizeErrors, unitdp)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createItems: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let items = { "Items": [ { "Code": "code123", "Name": "Item Name XYZ", "Description": "Foobar", "InventoryAssetAccountCode": "140", "PurchaseDetails": { "COGSAccountCode": "500" } } ] }; // Items
    let summarizeErrors = true; // Boolean
    let unitdp = 4; // Integer

    let mut context = AccountingApi::Context::default();
    let result = client.createItems(xeroTenantId, items, summarizeErrors, unitdp, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        LinkedTransaction linkedTransaction = new LinkedTransaction();
        linkedTransaction.setSourceTransactionID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        linkedTransaction.setSourceLineItemID(UUID.fromString("00000000-0000-0000-0000-000000000000"));

        try {
            LinkedTransactions result = apiInstance.createLinkedTransaction(accessToken, xeroTenantId, linkedTransaction);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createLinkedTransaction");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        LinkedTransaction linkedTransaction = { "LinkedTransactions": [ { "SourceTransactionID": "a848644a-f20f-4630-98c3-386bd7505631", "SourceLineItemID": "b0df260d-3cc8-4ced-9bd6-41924f624ed3" } ] }; // LinkedTransaction | 
        try {
            LinkedTransactions result = apiInstance.createLinkedTransaction(xeroTenantId, linkedTransaction);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createLinkedTransaction");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
LinkedTransaction *linkedTransaction = { "LinkedTransactions": [ { "SourceTransactionID": "a848644a-f20f-4630-98c3-386bd7505631", "SourceLineItemID": "b0df260d-3cc8-4ced-9bd6-41924f624ed3" } ] }; // 

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

// Creates linked transactions (billable expenses)
[apiInstance createLinkedTransactionWith:xeroTenantId
    linkedTransaction:linkedTransaction
              completionHandler: ^(LinkedTransactions output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const linkedTransaction: LinkedTransaction = { sourceTransactionID: "00000000-0000-0000-0000-000000000000", sourceLineItemID: "00000000-0000-0000-0000-000000000000" }

try {
  const response = await xero.accountingApi.createLinkedTransaction(xeroTenantId, linkedTransaction);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var linkedTransaction = new LinkedTransaction(); // LinkedTransaction | 

            try
            {
                // Creates linked transactions (billable expenses)
                LinkedTransactions result = apiInstance.createLinkedTransaction(xeroTenantId, linkedTransaction);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createLinkedTransaction: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";

$linkedTransaction = new XeroAPI\XeroPHP\Models\Accounting\LinkedTransaction;
$linkedTransaction->setSourceTransactionID('00000000-0000-0000-0000-000000000000');
$linkedTransaction->setSourceLineItemID('00000000-0000-0000-0000-000000000000');

try {
  $result = $apiInstance->createLinkedTransaction($xeroTenantId, $linkedTransaction);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createLinkedTransaction: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $linkedTransaction = ::Object::LinkedTransaction->new(); # LinkedTransaction | 

eval { 
    my $result = $api_instance->createLinkedTransaction(xeroTenantId => $xeroTenantId, linkedTransaction => $linkedTransaction);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createLinkedTransaction: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_linked_transaction():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'

    linked_transaction = LinkedTransaction(
        source_transaction_id = "00000000-0000-0000-0000-000000000000",
        source_line_item_id = "00000000-0000-0000-0000-000000000000")
    
    try:
        api_response = api_instance.create_linked_transaction(xeroTenantId, linkedTransaction)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createLinkedTransaction: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let linkedTransaction = { "LinkedTransactions": [ { "SourceTransactionID": "a848644a-f20f-4630-98c3-386bd7505631", "SourceLineItemID": "b0df260d-3cc8-4ced-9bd6-41924f624ed3" } ] }; // LinkedTransaction

    let mut context = AccountingApi::Context::default();
    let result = client.createLinkedTransaction(xeroTenantId, linkedTransaction, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID manualJournalID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        String fileName = "xero-dev.jpg";
        File input = new File("/path/to/local/xero-dev.jpg");
        java.nio.file.Path inputPath = input.toPath();
        byte[] body = FileUtils.readFileToByteArray(input);
        String mimeType = Files.probeContentType(inputPath);

        try {
            Attachments result = apiInstance.createManualJournalAttachmentByFileName(accessToken, xeroTenantId, manualJournalID, fileName, body, mimeType);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createManualJournalAttachmentByFileName");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID manualJournalID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for a ManualJournal
        String fileName = xero-dev.jpg; // String | The name of the file being attached to a ManualJournal
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 
        try {
            Attachments result = apiInstance.createManualJournalAttachmentByFileName(xeroTenantId, manualJournalID, fileName, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createManualJournalAttachmentByFileName");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *manualJournalID = 00000000-0000-0000-0000-000000000000; // Unique identifier for a ManualJournal (default to null)
String *fileName = xero-dev.jpg; // The name of the file being attached to a ManualJournal (default to null)
byte[] *body = BYTE_ARRAY_DATA_HERE; // 

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

// Creates a specific attachment for a specific manual journal by file name
[apiInstance createManualJournalAttachmentByFileNameWith:xeroTenantId
    manualJournalID:manualJournalID
    fileName:fileName
    body:body
              completionHandler: ^(Attachments output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const manualJournalID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for a ManualJournal
const fileName = "xero-dev.jpg";  // {String} The name of the file being attached to a ManualJournal
const path = require("path");
const mime = require("mime-types");
const pathToUpload = path.resolve(__dirname, "../public/images/xero-dev.jpg"); // determine the path to your file
import * as fs from "fs";
const body = fs.createReadStream(pathToUpload); // {fs.ReadStream} read the file
const contentType = mime.lookup(fileName);

try {
  const response = await xero.accountingApi.createManualJournalAttachmentByFileName(xeroTenantId, manualJournalID, fileName, body, {
    headers: {
      "Content-Type": contentType,
    }
  });
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var manualJournalID = new UUID(); // UUID | Unique identifier for a ManualJournal (default to null)
            var fileName = xero-dev.jpg;  // String | The name of the file being attached to a ManualJournal (default to null)
            var body = BYTE_ARRAY_DATA_HERE;  // byte[] | 

            try
            {
                // Creates a specific attachment for a specific manual journal by file name
                Attachments result = apiInstance.createManualJournalAttachmentByFileName(xeroTenantId, manualJournalID, fileName, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createManualJournalAttachmentByFileName: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$manualJournalID = "00000000-0000-0000-0000-000000000000";
$fileName = "xero-dev.jpg";

$handle = fopen($fileName, "r");
$body = fread($handle, filesize($fileName));
fclose($handle);

try {
  $result = $apiInstance->createManualJournalAttachmentByFileName($xeroTenantId, $manualJournalID, $fileName, $body);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createManualJournalAttachmentByFileName: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $manualJournalID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for a ManualJournal
my $fileName = xero-dev.jpg; # String | The name of the file being attached to a ManualJournal
my $body = ::Object::byte[]->new(); # byte[] | 

eval { 
    my $result = $api_instance->createManualJournalAttachmentByFileName(xeroTenantId => $xeroTenantId, manualJournalID => $manualJournalID, fileName => $fileName, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createManualJournalAttachmentByFileName: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_manual_journal_attachment_by_file_name():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    manualJournalID = '00000000-0000-0000-0000-000000000000'
    fileName = 'xero-dev.jpg'
    
        // TODO: BINARY CREATE 
    try:
        api_response = api_instance.create_manual_journal_attachment_by_file_name(xeroTenantId, manualJournalID, fileName, body)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createManualJournalAttachmentByFileName: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let manualJournalID = 00000000-0000-0000-0000-000000000000; // UUID
    let fileName = xero-dev.jpg; // String
    let body = BYTE_ARRAY_DATA_HERE; // byte[]

    let mut context = AccountingApi::Context::default();
    let result = client.createManualJournalAttachmentByFileName(xeroTenantId, manualJournalID, fileName, body, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID manualJournalID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

        try {
            HistoryRecords result = apiInstance.createManualJournalHistoryRecord(accessToken, xeroTenantId, manualJournalID, historyRecords);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createManualJournalHistoryRecord");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID manualJournalID = 00000000-0000-0000-0000-000000000000; // UUID | Xero generated unique identifier for a manual journal
        HistoryRecords historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords | 
        try {
            HistoryRecords result = apiInstance.createManualJournalHistoryRecord(xeroTenantId, manualJournalID, historyRecords);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createManualJournalHistoryRecord");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *manualJournalID = 00000000-0000-0000-0000-000000000000; // Xero generated unique identifier for a manual journal (default to null)
HistoryRecords *historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // 

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

// Creates a history record for a specific manual journal
[apiInstance createManualJournalHistoryRecordWith:xeroTenantId
    manualJournalID:manualJournalID
    historyRecords:historyRecords
              completionHandler: ^(HistoryRecords output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);
const historyRecords: HistoryRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] };  // {HistoryRecords} 
const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const manualJournalID = "00000000-0000-0000-0000-000000000000";  // {UUID} Xero generated unique identifier for a manual journal


try {
  const response = await xero.accountingApi.createManualJournalHistoryRecord(xeroTenantId, manualJournalID, historyRecords);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var manualJournalID = new UUID(); // UUID | Xero generated unique identifier for a manual journal (default to null)
            var historyRecords = new HistoryRecords(); // HistoryRecords | 

            try
            {
                // Creates a history record for a specific manual journal
                HistoryRecords result = apiInstance.createManualJournalHistoryRecord(xeroTenantId, manualJournalID, historyRecords);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createManualJournalHistoryRecord: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$manualJournalID = "00000000-0000-0000-0000-000000000000";

$historyRecord = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecord;
$historyRecord->setDetails('Hello World');

$historyRecords = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecords;
$arr_history_records = [];
array_push($arr_history_records, $historyRecord);
$historyRecords->setHistoryRecords($arr_history_records);

try {
  $result = $apiInstance->createManualJournalHistoryRecord($xeroTenantId, $manualJournalID, $historyRecords);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createManualJournalHistoryRecord: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $manualJournalID = 00000000-0000-0000-0000-000000000000; # UUID | Xero generated unique identifier for a manual journal
my $historyRecords = ::Object::HistoryRecords->new(); # HistoryRecords | 

eval { 
    my $result = $api_instance->createManualJournalHistoryRecord(xeroTenantId => $xeroTenantId, manualJournalID => $manualJournalID, historyRecords => $historyRecords);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createManualJournalHistoryRecord: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_manual_journal_history_record():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    manualJournalID = '00000000-0000-0000-0000-000000000000'

    history_record = HistoryRecord(
        details = "Hello World")

    history_records = HistoryRecords( 
        history_records = [history_record])
    
    try:
        api_response = api_instance.create_manual_journal_history_record(xeroTenantId, manualJournalID, historyRecords)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createManualJournalHistoryRecord: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let manualJournalID = 00000000-0000-0000-0000-000000000000; // UUID
    let historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords

    let mut context = AccountingApi::Context::default();
    let result = client.createManualJournalHistoryRecord(xeroTenantId, manualJournalID, historyRecords, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        Boolean summarizeErrors = true;
        LocalDate dateValue = LocalDate.of(2020, Month.OCTOBER, 10);
        List<ManualJournalLine> manualJournalLines = new ArrayList<ManualJournalLine>();
        ManualJournalLine credit = new ManualJournalLine();
        credit.setLineAmount(100.0);
        credit.setAccountCode("400");
        credit.setDescription("Hello there");
        manualJournalLines.add(credit);
        ManualJournalLine debit = new ManualJournalLine();
        debit.setLineAmount(-100.0);
        debit.setAccountCode("120");
        debit.setDescription("Hello there");
        manualJournalLines.add(debit);
        ManualJournal manualJournal = new ManualJournal();
        manualJournal.setNarration("Foobar");
        manualJournal.setDate(dateValue);
        manualJournal.setJournalLines(manualJournalLines);
        ManualJournals manualJournals = new ManualJournals();
        manualJournals.addManualJournalsItem(manualJournal);

        try {
            ManualJournals result = apiInstance.createManualJournals(accessToken, xeroTenantId, manualJournals, summarizeErrors);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createManualJournals");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        ManualJournals manualJournals = { "ManualJournals": [ { "Narration": "Journal Desc", "JournalLines": [ { "LineAmount": 100, "AccountCode": "400", "Description": "Money Movement" }, { "LineAmount": -100, "AccountCode": "400", "Description": "Prepayment of things", "Tracking": [ { "Name": "North", "Option": "Region" } ] } ], "Date": "2019-03-14" } ] }; // ManualJournals | 
        Boolean summarizeErrors = true; // Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors
        try {
            ManualJournals result = apiInstance.createManualJournals(xeroTenantId, manualJournals, summarizeErrors);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createManualJournals");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
ManualJournals *manualJournals = { "ManualJournals": [ { "Narration": "Journal Desc", "JournalLines": [ { "LineAmount": 100, "AccountCode": "400", "Description": "Money Movement" }, { "LineAmount": -100, "AccountCode": "400", "Description": "Prepayment of things", "Tracking": [ { "Name": "North", "Option": "Region" } ] } ], "Date": "2019-03-14" } ] }; // 
Boolean *summarizeErrors = true; // If false return 200 OK and mix of successfully created objects and any with validation errors (optional) (default to false)

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

// Creates one or more manual journals
[apiInstance createManualJournalsWith:xeroTenantId
    manualJournals:manualJournals
    summarizeErrors:summarizeErrors
              completionHandler: ^(ManualJournals output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant


const summarizeErrors = true;  // {Boolean} If false return 200 OK and mix of successfully created objects and any with validation errors
const manualJournals: ManualJournals = { manualJournals: [{ narration: "Foo bar", date: "2019-03-14", journalLines: [{ lineAmount: 100.0, accountCode: "400", description: "Hello there" }, { lineAmount: -100.0, accountCode: "400", description: "Goodbye", tracking: [{ name: "Simpson", option: "Bart" }] }]}]}

try {
  const response = await xero.accountingApi.createManualJournals(xeroTenantId, manualJournals,  summarizeErrors);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var manualJournals = new ManualJournals(); // ManualJournals | 
            var summarizeErrors = true;  // Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors (optional)  (default to false)

            try
            {
                // Creates one or more manual journals
                ManualJournals result = apiInstance.createManualJournals(xeroTenantId, manualJournals, summarizeErrors);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createManualJournals: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$summarizeErrors = true;
$dateValue = new DateTime('2019-10-10');
$manualJournalLines = [];

$credit = new XeroAPI\XeroPHP\Models\Accounting\ManualJournalLine;
$credit->setLineAmount(100.0);
$credit->setAccountCode('400');
$credit->setDescription('Hello there');
array_push($manualJournalLines, $credit);

$debit = new XeroAPI\XeroPHP\Models\Accounting\ManualJournalLine;
$debit->setLineAmount(-100.0);
$debit->setAccountCode('120');
$debit->setDescription('Hello there');
array_push($manualJournalLines, $debit);

$manualJournal = new XeroAPI\XeroPHP\Models\Accounting\ManualJournal;
$manualJournal->setNarration('Foobar');
$manualJournal->setDate($dateValue);
$manualJournal->setJournalLines($manualJournalLines);

$manualJournals = new XeroAPI\XeroPHP\Models\Accounting\ManualJournals;
$arr_manual_journals = [];
array_push($arr_manual_journals, $manualJournal);
$manualJournals->setManualJournals($arr_manual_journals);

try {
  $result = $apiInstance->createManualJournals($xeroTenantId, $manualJournals, $summarizeErrors);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createManualJournals: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $manualJournals = ::Object::ManualJournals->new(); # ManualJournals | 
my $summarizeErrors = true; # Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors

eval { 
    my $result = $api_instance->createManualJournals(xeroTenantId => $xeroTenantId, manualJournals => $manualJournals, summarizeErrors => $summarizeErrors);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createManualJournals: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_manual_journals():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    summarizeErrors = 'True'
    date_value = dateutil.parser.parse('2020-12-03T00:00:00Z')
    
    manual_journal_lines = []

    credit = ManualJournalLine(
        line_amount = 100.0,
        account_code = "400",
        description = "Hello there")    
    manual_journal_lines.append(credit)

    debit = ManualJournalLine(
        line_amount = -100.0,
        account_code = "120",
        description = "Hello there")    
    manual_journal_lines.append(debit)

    manual_journal = ManualJournal(
        narration = "Foobar",
        date = date_value,
        journal_lines = manual_journal_lines)

    manualJournals = ManualJournals( 
        manual_journals = [manual_journal])
    
    try:
        api_response = api_instance.create_manual_journals(xeroTenantId, manualJournals, summarizeErrors)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createManualJournals: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let manualJournals = { "ManualJournals": [ { "Narration": "Journal Desc", "JournalLines": [ { "LineAmount": 100, "AccountCode": "400", "Description": "Money Movement" }, { "LineAmount": -100, "AccountCode": "400", "Description": "Prepayment of things", "Tracking": [ { "Name": "North", "Option": "Region" } ] } ], "Date": "2019-03-14" } ] }; // ManualJournals
    let summarizeErrors = true; // Boolean

    let mut context = AccountingApi::Context::default();
    let result = client.createManualJournals(xeroTenantId, manualJournals, summarizeErrors, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID overpaymentID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        Boolean summarizeErrors = true;
        LocalDate currDate = LocalDate.now();
        Invoice invoice = new Invoice();
        invoice.setInvoiceID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        Allocation allocation = new Allocation();
        allocation.setAmount(1.0);
        allocation.setDate(currDate);
        allocation.setInvoice(invoice);
        Allocations allocations = new Allocations();
        allocations.addAllocationsItem(allocation);

        try {
            Allocations result = apiInstance.createOverpaymentAllocations(accessToken, xeroTenantId, overpaymentID, allocations, summarizeErrors);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createOverpaymentAllocations");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID overpaymentID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for a Overpayment
        Allocations allocations = { "Allocations": [ { "Invoice": { "InvoiceID": "00000000-0000-0000-0000-000000000000", "LineItems": [], "Contact": {}, "Type": "ACCPAY" }, "Amount": 10.00, "Date": "2019-03-12" } ] }; // Allocations | 
        Boolean summarizeErrors = true; // Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors
        try {
            Allocations result = apiInstance.createOverpaymentAllocations(xeroTenantId, overpaymentID, allocations, summarizeErrors);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createOverpaymentAllocations");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *overpaymentID = 00000000-0000-0000-0000-000000000000; // Unique identifier for a Overpayment (default to null)
Allocations *allocations = { "Allocations": [ { "Invoice": { "InvoiceID": "00000000-0000-0000-0000-000000000000", "LineItems": [], "Contact": {}, "Type": "ACCPAY" }, "Amount": 10.00, "Date": "2019-03-12" } ] }; // 
Boolean *summarizeErrors = true; // If false return 200 OK and mix of successfully created objects and any with validation errors (optional) (default to false)

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

// Creates a single allocation for a specific overpayment
[apiInstance createOverpaymentAllocationsWith:xeroTenantId
    overpaymentID:overpaymentID
    allocations:allocations
    summarizeErrors:summarizeErrors
              completionHandler: ^(Allocations output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const overpaymentID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for a Overpayment


const summarizeErrors = true;  // {Boolean} If false return 200 OK and mix of successfully created objects and any with validation errors
const allocations: Allocations = { allocations: [{ invoice: { invoiceID: "00000000-0000-0000-0000-000000000000", lineItems: [], contact: {}, type: Invoice.TypeEnum.ACCPAY }, amount: 10.0, date: "2019-03-12" }]}

try {
  const response = await xero.accountingApi.createOverpaymentAllocations(xeroTenantId, overpaymentID, allocations,  summarizeErrors);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var overpaymentID = new UUID(); // UUID | Unique identifier for a Overpayment (default to null)
            var allocations = new Allocations(); // Allocations | 
            var summarizeErrors = true;  // Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors (optional)  (default to false)

            try
            {
                // Creates a single allocation for a specific overpayment
                Allocations result = apiInstance.createOverpaymentAllocations(xeroTenantId, overpaymentID, allocations, summarizeErrors);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createOverpaymentAllocations: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$overpaymentID = "00000000-0000-0000-0000-000000000000";
$summarizeErrors = true;
$currDate = new DateTime('2020-12-10');

$invoice = new XeroAPI\XeroPHP\Models\Accounting\Invoice;
$invoice->setInvoiceID('00000000-0000-0000-0000-000000000000');

$allocation = new XeroAPI\XeroPHP\Models\Accounting\Allocation;
$allocation->setAmount(1.0);
$allocation->setDate($currDate);
$allocation->setInvoice($invoice);

$allocations = new XeroAPI\XeroPHP\Models\Accounting\Allocations;
$arr_allocations = [];
array_push($arr_allocations, $allocation);
$allocations->setAllocations($arr_allocations);

try {
  $result = $apiInstance->createOverpaymentAllocations($xeroTenantId, $overpaymentID, $allocations, $summarizeErrors);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createOverpaymentAllocations: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $overpaymentID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for a Overpayment
my $allocations = ::Object::Allocations->new(); # Allocations | 
my $summarizeErrors = true; # Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors

eval { 
    my $result = $api_instance->createOverpaymentAllocations(xeroTenantId => $xeroTenantId, overpaymentID => $overpaymentID, allocations => $allocations, summarizeErrors => $summarizeErrors);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createOverpaymentAllocations: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_overpayment_allocations():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    overpaymentID = '00000000-0000-0000-0000-000000000000'
    summarizeErrors = 'True'
    curr_date = dateutil.parser.parse('2020-12-03T00:00:00Z')

    invoice = Invoice(
        invoice_id = "00000000-0000-0000-0000-000000000000")

    allocation = Allocation(
        amount = 1.0,
        date = curr_date,
        invoice = invoice)

    allocations = Allocations( 
        allocations = [allocation])
    
    try:
        api_response = api_instance.create_overpayment_allocations(xeroTenantId, overpaymentID, allocations, summarizeErrors)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createOverpaymentAllocations: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let overpaymentID = 00000000-0000-0000-0000-000000000000; // UUID
    let allocations = { "Allocations": [ { "Invoice": { "InvoiceID": "00000000-0000-0000-0000-000000000000", "LineItems": [], "Contact": {}, "Type": "ACCPAY" }, "Amount": 10.00, "Date": "2019-03-12" } ] }; // Allocations
    let summarizeErrors = true; // Boolean

    let mut context = AccountingApi::Context::default();
    let result = client.createOverpaymentAllocations(xeroTenantId, overpaymentID, allocations, summarizeErrors, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID overpaymentID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

        try {
            HistoryRecords result = apiInstance.createOverpaymentHistory(accessToken, xeroTenantId, overpaymentID, historyRecords);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createOverpaymentHistory");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID overpaymentID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for a Overpayment
        HistoryRecords historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords | 
        try {
            HistoryRecords result = apiInstance.createOverpaymentHistory(xeroTenantId, overpaymentID, historyRecords);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createOverpaymentHistory");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *overpaymentID = 00000000-0000-0000-0000-000000000000; // Unique identifier for a Overpayment (default to null)
HistoryRecords *historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // 

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

// Creates a history record for a specific overpayment
[apiInstance createOverpaymentHistoryWith:xeroTenantId
    overpaymentID:overpaymentID
    historyRecords:historyRecords
              completionHandler: ^(HistoryRecords output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);
const historyRecords: HistoryRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] };  // {HistoryRecords} 
const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const overpaymentID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for a Overpayment


try {
  const response = await xero.accountingApi.createOverpaymentHistory(xeroTenantId, overpaymentID, historyRecords);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var overpaymentID = new UUID(); // UUID | Unique identifier for a Overpayment (default to null)
            var historyRecords = new HistoryRecords(); // HistoryRecords | 

            try
            {
                // Creates a history record for a specific overpayment
                HistoryRecords result = apiInstance.createOverpaymentHistory(xeroTenantId, overpaymentID, historyRecords);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createOverpaymentHistory: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$overpaymentID = "00000000-0000-0000-0000-000000000000";

$historyRecord = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecord;
$historyRecord->setDetails('Hello World');

$historyRecords = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecords;
$arr_history_records = [];
array_push($arr_history_records, $historyRecord);
$historyRecords->setHistoryRecords($arr_history_records);

try {
  $result = $apiInstance->createOverpaymentHistory($xeroTenantId, $overpaymentID, $historyRecords);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createOverpaymentHistory: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $overpaymentID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for a Overpayment
my $historyRecords = ::Object::HistoryRecords->new(); # HistoryRecords | 

eval { 
    my $result = $api_instance->createOverpaymentHistory(xeroTenantId => $xeroTenantId, overpaymentID => $overpaymentID, historyRecords => $historyRecords);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createOverpaymentHistory: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_overpayment_history():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    overpaymentID = '00000000-0000-0000-0000-000000000000'

    history_record = HistoryRecord(
        details = "Hello World")

    history_records = HistoryRecords( 
        history_records = [history_record])
    
    try:
        api_response = api_instance.create_overpayment_history(xeroTenantId, overpaymentID, historyRecords)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createOverpaymentHistory: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let overpaymentID = 00000000-0000-0000-0000-000000000000; // UUID
    let historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords

    let mut context = AccountingApi::Context::default();
    let result = client.createOverpaymentHistory(xeroTenantId, overpaymentID, historyRecords, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        LocalDate dateValue = LocalDate.of(2020, Month.OCTOBER, 10);
        Invoice invoice = new Invoice();
        invoice.setInvoiceID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        Account account = new Account();
        account.setAccountID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        Payment payment = new Payment();
        payment.setInvoice(invoice);
        payment.setAccount(account);
        payment.setAmount(1.0);
        payment.setDate(dateValue);
        Payments payments = new Payments();
        payments.addPaymentsItem(payment);

        try {
            Payments result = apiInstance.createPayment(accessToken, xeroTenantId, payment);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createPayment");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        Payment payment = { "Payments": [ { "Invoice": { "LineItems": [], "InvoiceID": "00000000-0000-0000-0000-000000000000" }, "Account": { "Code": "970" }, "Date": "2019-03-12", "Amount": 1 } ] }; // Payment | 
        try {
            Payments result = apiInstance.createPayment(xeroTenantId, payment);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createPayment");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
Payment *payment = { "Payments": [ { "Invoice": { "LineItems": [], "InvoiceID": "00000000-0000-0000-0000-000000000000" }, "Account": { "Code": "970" }, "Date": "2019-03-12", "Amount": 1 } ] }; // 

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

// Creates a single payment for invoice or credit notes
[apiInstance createPaymentWith:xeroTenantId
    payment:payment
              completionHandler: ^(Payments output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const payment: Payment = { invoice: { invoiceID: "00000000-0000-0000-0000-000000000000", lineItems: [], contact: {}, type: Invoice.TypeEnum.ACCPAY }, account: { code: "970" }, date: "2019-03-12", amount: 1.0 }

try {
  const response = await xero.accountingApi.createPayment(xeroTenantId, payment);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var payment = new Payment(); // Payment | 

            try
            {
                // Creates a single payment for invoice or credit notes
                Payments result = apiInstance.createPayment(xeroTenantId, payment);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createPayment: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$dateValue = new DateTime('2020-10-10');

$invoice = new XeroAPI\XeroPHP\Models\Accounting\Invoice;
$invoice->setInvoiceID('00000000-0000-0000-0000-000000000000');

$account = new XeroAPI\XeroPHP\Models\Accounting\Account;
$account->setAccountID('00000000-0000-0000-0000-000000000000');

$payment = new XeroAPI\XeroPHP\Models\Accounting\Payment;
$payment->setInvoice($invoice);
$payment->setAccount($account);
$payment->setAmount(1.0);
$payment->setDate($dateValue);

$payments = new XeroAPI\XeroPHP\Models\Accounting\Payments;
$arr_payments = [];
array_push($arr_payments, $payment);
$payments->setPayments($arr_payments);

try {
  $result = $apiInstance->createPayment($xeroTenantId, $payment);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createPayment: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $payment = ::Object::Payment->new(); # Payment | 

eval { 
    my $result = $api_instance->createPayment(xeroTenantId => $xeroTenantId, payment => $payment);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createPayment: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_payment():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    date_value = dateutil.parser.parse('2020-10-10T00:00:00Z')

    invoice = Invoice(
        invoice_id = "00000000-0000-0000-0000-000000000000")

    account = Account(
        account_id = "00000000-0000-0000-0000-000000000000")

    payment = Payment(
        invoice = invoice,
        account = account,
        amount = 1.0,
        date = date_value)

    payments = Payments( 
        payments = [payment])
    
    try:
        api_response = api_instance.create_payment(xeroTenantId, payment)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createPayment: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let payment = { "Payments": [ { "Invoice": { "LineItems": [], "InvoiceID": "00000000-0000-0000-0000-000000000000" }, "Account": { "Code": "970" }, "Date": "2019-03-12", "Amount": 1 } ] }; // Payment

    let mut context = AccountingApi::Context::default();
    let result = client.createPayment(xeroTenantId, payment, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID paymentID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

        try {
            HistoryRecords result = apiInstance.createPaymentHistory(accessToken, xeroTenantId, paymentID, historyRecords);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createPaymentHistory");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID paymentID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for a Payment
        HistoryRecords historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords | 
        try {
            HistoryRecords result = apiInstance.createPaymentHistory(xeroTenantId, paymentID, historyRecords);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createPaymentHistory");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *paymentID = 00000000-0000-0000-0000-000000000000; // Unique identifier for a Payment (default to null)
HistoryRecords *historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // 

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

// Creates a history record for a specific payment
[apiInstance createPaymentHistoryWith:xeroTenantId
    paymentID:paymentID
    historyRecords:historyRecords
              completionHandler: ^(HistoryRecords output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);
const historyRecords: HistoryRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] };  // {HistoryRecords} 
const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const paymentID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for a Payment


try {
  const response = await xero.accountingApi.createPaymentHistory(xeroTenantId, paymentID, historyRecords);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var paymentID = new UUID(); // UUID | Unique identifier for a Payment (default to null)
            var historyRecords = new HistoryRecords(); // HistoryRecords | 

            try
            {
                // Creates a history record for a specific payment
                HistoryRecords result = apiInstance.createPaymentHistory(xeroTenantId, paymentID, historyRecords);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createPaymentHistory: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$paymentID = "00000000-0000-0000-0000-000000000000";

$historyRecord = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecord;
$historyRecord->setDetails('Hello World');

$historyRecords = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecords;
$arr_history_records = [];
array_push($arr_history_records, $historyRecord);
$historyRecords->setHistoryRecords($arr_history_records);

try {
  $result = $apiInstance->createPaymentHistory($xeroTenantId, $paymentID, $historyRecords);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createPaymentHistory: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $paymentID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for a Payment
my $historyRecords = ::Object::HistoryRecords->new(); # HistoryRecords | 

eval { 
    my $result = $api_instance->createPaymentHistory(xeroTenantId => $xeroTenantId, paymentID => $paymentID, historyRecords => $historyRecords);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createPaymentHistory: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_payment_history():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    paymentID = '00000000-0000-0000-0000-000000000000'

    history_record = HistoryRecord(
        details = "Hello World")

    history_records = HistoryRecords( 
        history_records = [history_record])
    
    try:
        api_response = api_instance.create_payment_history(xeroTenantId, paymentID, historyRecords)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createPaymentHistory: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let paymentID = 00000000-0000-0000-0000-000000000000; // UUID
    let historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords

    let mut context = AccountingApi::Context::default();
    let result = client.createPaymentHistory(xeroTenantId, paymentID, historyRecords, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        PaymentService paymentService = new PaymentService();
        paymentService.setPaymentServiceName("ACME Payments");
        paymentService.setPaymentServiceUrl("https://www.payupnow.com/");
        paymentService.setPayNowText("Pay Now");
        PaymentServices paymentServices = new PaymentServices();
        paymentServices.addPaymentServicesItem(paymentService);

        try {
            PaymentServices result = apiInstance.createPaymentService(accessToken, xeroTenantId, paymentServices);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createPaymentService");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        PaymentServices paymentServices = { "PaymentServices": [ { "PaymentServiceName": "PayUpNow", "PaymentServiceUrl": "https://www.payupnow.com/", "PayNowText": "Time To Pay" } ] }; // PaymentServices | 
        try {
            PaymentServices result = apiInstance.createPaymentService(xeroTenantId, paymentServices);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createPaymentService");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
PaymentServices *paymentServices = { "PaymentServices": [ { "PaymentServiceName": "PayUpNow", "PaymentServiceUrl": "https://www.payupnow.com/", "PayNowText": "Time To Pay" } ] }; // 

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

// Creates a payment service
[apiInstance createPaymentServiceWith:xeroTenantId
    paymentServices:paymentServices
              completionHandler: ^(PaymentServices output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const paymentServices: PaymentServices = { paymentServices: [{ paymentServiceName: "PayUpNow", paymentServiceUrl: "https://www.payupnow.com/", payNowText: "Time To Pay" }]}

try {
  const response = await xero.accountingApi.createPaymentService(xeroTenantId, paymentServices);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var paymentServices = new PaymentServices(); // PaymentServices | 

            try
            {
                // Creates a payment service
                PaymentServices result = apiInstance.createPaymentService(xeroTenantId, paymentServices);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createPaymentService: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";

$paymentService = new XeroAPI\XeroPHP\Models\Accounting\PaymentService;
$paymentService->setPaymentServiceName('ACME Payments');
$paymentService->setPaymentServiceUrl('https://www.payupnow.com/');
$paymentService->setPayNowText('Pay Now');

$paymentServices = new XeroAPI\XeroPHP\Models\Accounting\PaymentServices;
$arr_paymentServices = [];
array_push($arr_paymentServices, $paymentService);
$paymentServices->setPaymentServices($arr_paymentServices);

try {
  $result = $apiInstance->createPaymentService($xeroTenantId, $paymentServices);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createPaymentService: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $paymentServices = ::Object::PaymentServices->new(); # PaymentServices | 

eval { 
    my $result = $api_instance->createPaymentService(xeroTenantId => $xeroTenantId, paymentServices => $paymentServices);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createPaymentService: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_payment_service():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'

    payment_service = PaymentService(
        payment_service_name = "ACME Payments",
        payment_service_url = "https://www.payupnow.com/",
        pay_now_text = "Pay Now")

    paymentServices = PaymentServices( 
        paymentServices = [paymentService])
    
    try:
        api_response = api_instance.create_payment_service(xeroTenantId, paymentServices)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createPaymentService: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let paymentServices = { "PaymentServices": [ { "PaymentServiceName": "PayUpNow", "PaymentServiceUrl": "https://www.payupnow.com/", "PayNowText": "Time To Pay" } ] }; // PaymentServices

    let mut context = AccountingApi::Context::default();
    let result = client.createPaymentService(xeroTenantId, paymentServices, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        Boolean summarizeErrors = true;
        LocalDate dateValue = LocalDate.of(2020, Month.OCTOBER, 10);
        Invoice invoice = new Invoice();
        invoice.setInvoiceID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        Account account = new Account();
        account.setAccountID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        Payment payment = new Payment();
        payment.setInvoice(invoice);
        payment.setAccount(account);
        payment.setAmount(1.0);
        payment.setDate(dateValue);
        Payments payments = new Payments();
        payments.addPaymentsItem(payment);

        try {
            Payments result = apiInstance.createPayments(accessToken, xeroTenantId, payments, summarizeErrors);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createPayments");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        Payments payments = { "Payments": [ { "Invoice": { "LineItems": [], "InvoiceID": "00000000-0000-0000-0000-000000000000" }, "Account": { "Code": "970" }, "Date": "2019-03-12", "Amount": 1 } ] }; // Payments | 
        Boolean summarizeErrors = true; // Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors
        try {
            Payments result = apiInstance.createPayments(xeroTenantId, payments, summarizeErrors);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createPayments");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
Payments *payments = { "Payments": [ { "Invoice": { "LineItems": [], "InvoiceID": "00000000-0000-0000-0000-000000000000" }, "Account": { "Code": "970" }, "Date": "2019-03-12", "Amount": 1 } ] }; // 
Boolean *summarizeErrors = true; // If false return 200 OK and mix of successfully created objects and any with validation errors (optional) (default to false)

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

// Creates multiple payments for invoices or credit notes
[apiInstance createPaymentsWith:xeroTenantId
    payments:payments
    summarizeErrors:summarizeErrors
              completionHandler: ^(Payments output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant


const summarizeErrors = true;  // {Boolean} If false return 200 OK and mix of successfully created objects and any with validation errors
const payments: Payments = { payments: [{ invoice: { invoiceID: "00000000-0000-0000-0000-000000000000", lineItems: [], contact: {}, type: Invoice.TypeEnum.ACCPAY }, account: { code: "970" }, date: "2019-03-12", amount: 1.0 }]}

try {
  const response = await xero.accountingApi.createPayments(xeroTenantId, payments,  summarizeErrors);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var payments = new Payments(); // Payments | 
            var summarizeErrors = true;  // Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors (optional)  (default to false)

            try
            {
                // Creates multiple payments for invoices or credit notes
                Payments result = apiInstance.createPayments(xeroTenantId, payments, summarizeErrors);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createPayments: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$summarizeErrors = true;
$dateValue = new DateTime('2020-10-10');

$invoice = new XeroAPI\XeroPHP\Models\Accounting\Invoice;
$invoice->setInvoiceID('00000000-0000-0000-0000-000000000000');

$account = new XeroAPI\XeroPHP\Models\Accounting\Account;
$account->setAccountID('00000000-0000-0000-0000-000000000000');

$payment = new XeroAPI\XeroPHP\Models\Accounting\Payment;
$payment->setInvoice($invoice);
$payment->setAccount($account);
$payment->setAmount(1.0);
$payment->setDate($dateValue);

$payments = new XeroAPI\XeroPHP\Models\Accounting\Payments;
$arr_payments = [];
array_push($arr_payments, $payment);
$payments->setPayments($arr_payments);

try {
  $result = $apiInstance->createPayments($xeroTenantId, $payments, $summarizeErrors);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createPayments: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $payments = ::Object::Payments->new(); # Payments | 
my $summarizeErrors = true; # Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors

eval { 
    my $result = $api_instance->createPayments(xeroTenantId => $xeroTenantId, payments => $payments, summarizeErrors => $summarizeErrors);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createPayments: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_payments():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    summarizeErrors = 'True'
    date_value = dateutil.parser.parse('2020-10-10T00:00:00Z')

    invoice = Invoice(
        invoice_id = "00000000-0000-0000-0000-000000000000")

    account = Account(
        account_id = "00000000-0000-0000-0000-000000000000")

    payment = Payment(
        invoice = invoice,
        account = account,
        amount = 1.0,
        date = date_value)

    payments = Payments( 
        payments = [payment])
    
    try:
        api_response = api_instance.create_payments(xeroTenantId, payments, summarizeErrors)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createPayments: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let payments = { "Payments": [ { "Invoice": { "LineItems": [], "InvoiceID": "00000000-0000-0000-0000-000000000000" }, "Account": { "Code": "970" }, "Date": "2019-03-12", "Amount": 1 } ] }; // Payments
    let summarizeErrors = true; // Boolean

    let mut context = AccountingApi::Context::default();
    let result = client.createPayments(xeroTenantId, payments, summarizeErrors, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID prepaymentID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        Boolean summarizeErrors = true;
        LocalDate currDate = LocalDate.now();
        Invoice invoice = new Invoice();
        invoice.setInvoiceID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        Allocation allocation = new Allocation();
        allocation.setInvoice(invoice);
        allocation.setAmount(1.0);
        allocation.setDate(currDate);
        Allocations allocations = new Allocations();
        allocations.addAllocationsItem(allocation);

        try {
            Allocations result = apiInstance.createPrepaymentAllocations(accessToken, xeroTenantId, prepaymentID, allocations, summarizeErrors);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createPrepaymentAllocations");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID prepaymentID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for Prepayment
        Allocations allocations = { "Allocations": [ { "Invoice": { "LineItems": [], "InvoiceID": "00000000-0000-0000-0000-000000000000" }, "Amount": 1, "Date": "2019-01-10" } ] }; // Allocations | 
        Boolean summarizeErrors = true; // Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors
        try {
            Allocations result = apiInstance.createPrepaymentAllocations(xeroTenantId, prepaymentID, allocations, summarizeErrors);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createPrepaymentAllocations");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *prepaymentID = 00000000-0000-0000-0000-000000000000; // Unique identifier for Prepayment (default to null)
Allocations *allocations = { "Allocations": [ { "Invoice": { "LineItems": [], "InvoiceID": "00000000-0000-0000-0000-000000000000" }, "Amount": 1, "Date": "2019-01-10" } ] }; // 
Boolean *summarizeErrors = true; // If false return 200 OK and mix of successfully created objects and any with validation errors (optional) (default to false)

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

// Allows you to create an Allocation for prepayments
[apiInstance createPrepaymentAllocationsWith:xeroTenantId
    prepaymentID:prepaymentID
    allocations:allocations
    summarizeErrors:summarizeErrors
              completionHandler: ^(Allocations output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const prepaymentID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for Prepayment


const summarizeErrors = true;  // {Boolean} If false return 200 OK and mix of successfully created objects and any with validation errors
const allocations: Allocations = { allocations: [{ invoice: { invoiceID: "00000000-0000-0000-0000-000000000000", lineItems: [], contact: {}, type: null }, amount: 1.0, date: "2019-03-13" }]}

try {
  const response = await xero.accountingApi.createPrepaymentAllocations(xeroTenantId, prepaymentID, allocations,  summarizeErrors);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var prepaymentID = new UUID(); // UUID | Unique identifier for Prepayment (default to null)
            var allocations = new Allocations(); // Allocations | 
            var summarizeErrors = true;  // Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors (optional)  (default to false)

            try
            {
                // Allows you to create an Allocation for prepayments
                Allocations result = apiInstance.createPrepaymentAllocations(xeroTenantId, prepaymentID, allocations, summarizeErrors);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createPrepaymentAllocations: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$prepaymentID = "00000000-0000-0000-0000-000000000000";
$summarizeErrors = true;
$currDate = new DateTime('2020-12-10');

$invoice = new XeroAPI\XeroPHP\Models\Accounting\Invoice;
$invoice->setInvoiceID('00000000-0000-0000-0000-000000000000');

$allocation = new XeroAPI\XeroPHP\Models\Accounting\Allocation;
$allocation->setInvoice($invoice);
$allocation->setAmount(1.0);
$allocation->setDate($currDate);

$allocations = new XeroAPI\XeroPHP\Models\Accounting\Allocations;
$arr_allocations = [];
array_push($arr_allocations, $allocation);
$allocations->setAllocations($arr_allocations);

try {
  $result = $apiInstance->createPrepaymentAllocations($xeroTenantId, $prepaymentID, $allocations, $summarizeErrors);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createPrepaymentAllocations: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $prepaymentID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for Prepayment
my $allocations = ::Object::Allocations->new(); # Allocations | 
my $summarizeErrors = true; # Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors

eval { 
    my $result = $api_instance->createPrepaymentAllocations(xeroTenantId => $xeroTenantId, prepaymentID => $prepaymentID, allocations => $allocations, summarizeErrors => $summarizeErrors);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createPrepaymentAllocations: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_prepayment_allocations():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    prepaymentID = '00000000-0000-0000-0000-000000000000'
    summarizeErrors = 'True'
    curr_date = dateutil.parser.parse('2020-12-03T00:00:00Z')

    invoice = Invoice(
        invoice_id = "00000000-0000-0000-0000-000000000000")

    allocation = Allocation(
        invoice = invoice,
        amount = 1.0,
        date = curr_date)

    allocations = Allocations( 
        allocations = [allocation])
    
    try:
        api_response = api_instance.create_prepayment_allocations(xeroTenantId, prepaymentID, allocations, summarizeErrors)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createPrepaymentAllocations: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let prepaymentID = 00000000-0000-0000-0000-000000000000; // UUID
    let allocations = { "Allocations": [ { "Invoice": { "LineItems": [], "InvoiceID": "00000000-0000-0000-0000-000000000000" }, "Amount": 1, "Date": "2019-01-10" } ] }; // Allocations
    let summarizeErrors = true; // Boolean

    let mut context = AccountingApi::Context::default();
    let result = client.createPrepaymentAllocations(xeroTenantId, prepaymentID, allocations, summarizeErrors, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID prepaymentID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

        try {
            HistoryRecords result = apiInstance.createPrepaymentHistory(accessToken, xeroTenantId, prepaymentID, historyRecords);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createPrepaymentHistory");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID prepaymentID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for a PrePayment
        HistoryRecords historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords | 
        try {
            HistoryRecords result = apiInstance.createPrepaymentHistory(xeroTenantId, prepaymentID, historyRecords);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createPrepaymentHistory");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *prepaymentID = 00000000-0000-0000-0000-000000000000; // Unique identifier for a PrePayment (default to null)
HistoryRecords *historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // 

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

// Creates a history record for a specific prepayment
[apiInstance createPrepaymentHistoryWith:xeroTenantId
    prepaymentID:prepaymentID
    historyRecords:historyRecords
              completionHandler: ^(HistoryRecords output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);
const historyRecords: HistoryRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] };  // {HistoryRecords} 
const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const prepaymentID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for a PrePayment


try {
  const response = await xero.accountingApi.createPrepaymentHistory(xeroTenantId, prepaymentID, historyRecords);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var prepaymentID = new UUID(); // UUID | Unique identifier for a PrePayment (default to null)
            var historyRecords = new HistoryRecords(); // HistoryRecords | 

            try
            {
                // Creates a history record for a specific prepayment
                HistoryRecords result = apiInstance.createPrepaymentHistory(xeroTenantId, prepaymentID, historyRecords);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createPrepaymentHistory: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$prepaymentID = "00000000-0000-0000-0000-000000000000";

$historyRecord = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecord;
$historyRecord->setDetails('Hello World');

$historyRecords = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecords;
$arr_history_records = [];
array_push($arr_history_records, $historyRecord);
$historyRecords->setHistoryRecords($arr_history_records);

try {
  $result = $apiInstance->createPrepaymentHistory($xeroTenantId, $prepaymentID, $historyRecords);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createPrepaymentHistory: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $prepaymentID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for a PrePayment
my $historyRecords = ::Object::HistoryRecords->new(); # HistoryRecords | 

eval { 
    my $result = $api_instance->createPrepaymentHistory(xeroTenantId => $xeroTenantId, prepaymentID => $prepaymentID, historyRecords => $historyRecords);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createPrepaymentHistory: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_prepayment_history():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    prepaymentID = '00000000-0000-0000-0000-000000000000'

    history_record = HistoryRecord(
        details = "Hello World")

    history_records = HistoryRecords( 
        history_records = [history_record])
    
    try:
        api_response = api_instance.create_prepayment_history(xeroTenantId, prepaymentID, historyRecords)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createPrepaymentHistory: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let prepaymentID = 00000000-0000-0000-0000-000000000000; // UUID
    let historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords

    let mut context = AccountingApi::Context::default();
    let result = client.createPrepaymentHistory(xeroTenantId, prepaymentID, historyRecords, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID purchaseOrderID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        String fileName = "xero-dev.png";
        File input = new File("/path/to/local/xero-dev.jpg");
        java.nio.file.Path inputPath = input.toPath();
        byte[] body = FileUtils.readFileToByteArray(input);
        String mimeType = Files.probeContentType(inputPath);

        try {
            Attachments result = apiInstance.createPurchaseOrderAttachmentByFileName(accessToken, xeroTenantId, purchaseOrderID, fileName, body, mimeType);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createPurchaseOrderAttachmentByFileName");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID purchaseOrderID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for Purchase Order object
        String fileName = xero-dev.png; // String | Name of the attachment
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 
        try {
            Attachments result = apiInstance.createPurchaseOrderAttachmentByFileName(xeroTenantId, purchaseOrderID, fileName, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createPurchaseOrderAttachmentByFileName");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *purchaseOrderID = 00000000-0000-0000-0000-000000000000; // Unique identifier for Purchase Order object (default to null)
String *fileName = xero-dev.png; // Name of the attachment (default to null)
byte[] *body = BYTE_ARRAY_DATA_HERE; // 

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

// Creates attachment for a specific purchase order
[apiInstance createPurchaseOrderAttachmentByFileNameWith:xeroTenantId
    purchaseOrderID:purchaseOrderID
    fileName:fileName
    body:body
              completionHandler: ^(Attachments output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const purchaseOrderID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for Purchase Order object
const fileName = "xero-dev.png";  // {String} Name of the attachment
const path = require("path");
const mime = require("mime-types");
const pathToUpload = path.resolve(__dirname, "../public/images/xero-dev.jpg"); // determine the path to your file
import * as fs from "fs";
const body = fs.createReadStream(pathToUpload); // {fs.ReadStream} read the file
const contentType = mime.lookup(fileName);

try {
  const response = await xero.accountingApi.createPurchaseOrderAttachmentByFileName(xeroTenantId, purchaseOrderID, fileName, body, {
    headers: {
      "Content-Type": contentType,
    }
  });
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var purchaseOrderID = new UUID(); // UUID | Unique identifier for Purchase Order object (default to null)
            var fileName = xero-dev.png;  // String | Name of the attachment (default to null)
            var body = BYTE_ARRAY_DATA_HERE;  // byte[] | 

            try
            {
                // Creates attachment for a specific purchase order
                Attachments result = apiInstance.createPurchaseOrderAttachmentByFileName(xeroTenantId, purchaseOrderID, fileName, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createPurchaseOrderAttachmentByFileName: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$purchaseOrderID = "00000000-0000-0000-0000-000000000000";
$fileName = "xero-dev.png";

$handle = fopen($fileName, "r");
$body = fread($handle, filesize($fileName));
fclose($handle);

try {
  $result = $apiInstance->createPurchaseOrderAttachmentByFileName($xeroTenantId, $purchaseOrderID, $fileName, $body);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createPurchaseOrderAttachmentByFileName: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $purchaseOrderID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for Purchase Order object
my $fileName = xero-dev.png; # String | Name of the attachment
my $body = ::Object::byte[]->new(); # byte[] | 

eval { 
    my $result = $api_instance->createPurchaseOrderAttachmentByFileName(xeroTenantId => $xeroTenantId, purchaseOrderID => $purchaseOrderID, fileName => $fileName, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createPurchaseOrderAttachmentByFileName: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_purchase_order_attachment_by_file_name():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    purchaseOrderID = '00000000-0000-0000-0000-000000000000'
    fileName = 'xero-dev.png'
    
        // TODO: BINARY CREATE 
    try:
        api_response = api_instance.create_purchase_order_attachment_by_file_name(xeroTenantId, purchaseOrderID, fileName, body)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createPurchaseOrderAttachmentByFileName: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let purchaseOrderID = 00000000-0000-0000-0000-000000000000; // UUID
    let fileName = xero-dev.png; // String
    let body = BYTE_ARRAY_DATA_HERE; // byte[]

    let mut context = AccountingApi::Context::default();
    let result = client.createPurchaseOrderAttachmentByFileName(xeroTenantId, purchaseOrderID, fileName, body, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID purchaseOrderID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

        try {
            HistoryRecords result = apiInstance.createPurchaseOrderHistory(accessToken, xeroTenantId, purchaseOrderID, historyRecords);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createPurchaseOrderHistory");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID purchaseOrderID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for a PurchaseOrder
        HistoryRecords historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords | 
        try {
            HistoryRecords result = apiInstance.createPurchaseOrderHistory(xeroTenantId, purchaseOrderID, historyRecords);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createPurchaseOrderHistory");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *purchaseOrderID = 00000000-0000-0000-0000-000000000000; // Unique identifier for a PurchaseOrder (default to null)
HistoryRecords *historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // 

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

// Creates a history record for a specific purchase orders
[apiInstance createPurchaseOrderHistoryWith:xeroTenantId
    purchaseOrderID:purchaseOrderID
    historyRecords:historyRecords
              completionHandler: ^(HistoryRecords output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);
const historyRecords: HistoryRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] };  // {HistoryRecords} 
const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const purchaseOrderID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for a PurchaseOrder


try {
  const response = await xero.accountingApi.createPurchaseOrderHistory(xeroTenantId, purchaseOrderID, historyRecords);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var purchaseOrderID = new UUID(); // UUID | Unique identifier for a PurchaseOrder (default to null)
            var historyRecords = new HistoryRecords(); // HistoryRecords | 

            try
            {
                // Creates a history record for a specific purchase orders
                HistoryRecords result = apiInstance.createPurchaseOrderHistory(xeroTenantId, purchaseOrderID, historyRecords);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createPurchaseOrderHistory: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$purchaseOrderID = "00000000-0000-0000-0000-000000000000";

$historyRecord = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecord;
$historyRecord->setDetails('Hello World');

$historyRecords = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecords;
$arr_history_records = [];
array_push($arr_history_records, $historyRecord);
$historyRecords->setHistoryRecords($arr_history_records);

try {
  $result = $apiInstance->createPurchaseOrderHistory($xeroTenantId, $purchaseOrderID, $historyRecords);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createPurchaseOrderHistory: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $purchaseOrderID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for a PurchaseOrder
my $historyRecords = ::Object::HistoryRecords->new(); # HistoryRecords | 

eval { 
    my $result = $api_instance->createPurchaseOrderHistory(xeroTenantId => $xeroTenantId, purchaseOrderID => $purchaseOrderID, historyRecords => $historyRecords);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createPurchaseOrderHistory: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_purchase_order_history():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    purchaseOrderID = '00000000-0000-0000-0000-000000000000'

    history_record = HistoryRecord(
        details = "Hello World")

    history_records = HistoryRecords( 
        history_records = [history_record])
    
    try:
        api_response = api_instance.create_purchase_order_history(xeroTenantId, purchaseOrderID, historyRecords)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createPurchaseOrderHistory: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let purchaseOrderID = 00000000-0000-0000-0000-000000000000; // UUID
    let historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords

    let mut context = AccountingApi::Context::default();
    let result = client.createPurchaseOrderHistory(xeroTenantId, purchaseOrderID, historyRecords, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        Boolean summarizeErrors = true;
        LocalDate dateValue = LocalDate.of(2020, Month.OCTOBER, 10);
        Contact contact = new Contact();
        contact.setContactID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        LineItem lineItem = new LineItem();
        lineItem.setDescription("Foobar");
        lineItem.setQuantity(1.0);
        lineItem.setUnitAmount(20.0);
        lineItem.setAccountCode("000");
        List<LineItems> lineItems = new ArrayList<LineItems>();
        lineItems.add(lineItem);
        PurchaseOrder purchaseOrder = new PurchaseOrder();
        purchaseOrder.setContact(contact);
        purchaseOrder.setLineItems(lineItems);
        purchaseOrder.setDate(dateValue);
        PurchaseOrders purchaseOrders = new PurchaseOrders();
        purchaseOrders.addPurchaseOrdersItem(purchaseOrder);

        try {
            PurchaseOrders result = apiInstance.createPurchaseOrders(accessToken, xeroTenantId, purchaseOrders, summarizeErrors);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createPurchaseOrders");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        PurchaseOrders purchaseOrders = { "PurchaseOrders": [ { "Contact": { "ContactID": "00000000-0000-0000-0000-000000000000" }, "LineItems": [ { "Description": "Foobar", "Quantity": 1, "UnitAmount": 20, "AccountCode": "710" } ], "Date": "2019-03-13" } ] }; // PurchaseOrders | 
        Boolean summarizeErrors = true; // Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors
        try {
            PurchaseOrders result = apiInstance.createPurchaseOrders(xeroTenantId, purchaseOrders, summarizeErrors);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createPurchaseOrders");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
PurchaseOrders *purchaseOrders = { "PurchaseOrders": [ { "Contact": { "ContactID": "00000000-0000-0000-0000-000000000000" }, "LineItems": [ { "Description": "Foobar", "Quantity": 1, "UnitAmount": 20, "AccountCode": "710" } ], "Date": "2019-03-13" } ] }; // 
Boolean *summarizeErrors = true; // If false return 200 OK and mix of successfully created objects and any with validation errors (optional) (default to false)

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

// Creates one or more purchase orders
[apiInstance createPurchaseOrdersWith:xeroTenantId
    purchaseOrders:purchaseOrders
    summarizeErrors:summarizeErrors
              completionHandler: ^(PurchaseOrders output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant


const summarizeErrors = true;  // {Boolean} If false return 200 OK and mix of successfully created objects and any with validation errors
const purchaseOrders: PurchaseOrders = { purchaseOrders: [{ contact: { contactID: "00000000-0000-0000-0000-000000000000" }, lineItems: [{ description: "Foobar", quantity: 1.0, unitAmount: 20.0, accountCode: "710" }], date: "2019-03-13" }]}

try {
  const response = await xero.accountingApi.createPurchaseOrders(xeroTenantId, purchaseOrders,  summarizeErrors);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var purchaseOrders = new PurchaseOrders(); // PurchaseOrders | 
            var summarizeErrors = true;  // Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors (optional)  (default to false)

            try
            {
                // Creates one or more purchase orders
                PurchaseOrders result = apiInstance.createPurchaseOrders(xeroTenantId, purchaseOrders, summarizeErrors);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createPurchaseOrders: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$summarizeErrors = true;
$dateValue = new DateTime('2020-12-10');

$contact = new XeroAPI\XeroPHP\Models\Accounting\Contact;
$contact->setContactID('00000000-0000-0000-0000-000000000000');

$lineItem = new XeroAPI\XeroPHP\Models\Accounting\LineItem;
$lineItem->setDescription('Foobar');
$lineItem->setQuantity(1.0);
$lineItem->setUnitAmount(20.0);
$lineItem->setAccountCode('000');
$lineItems = [];
array_push($lineItems, $lineItem);

$purchaseOrder = new XeroAPI\XeroPHP\Models\Accounting\PurchaseOrder;
$purchaseOrder->setContact($contact);
$purchaseOrder->setLineItems($lineItems);
$purchaseOrder->setDate($dateValue);

$purchaseOrders = new XeroAPI\XeroPHP\Models\Accounting\PurchaseOrders;
$arr_purchase_orders = [];
array_push($arr_purchase_orders, $purchaseOrder);
$purchaseOrders->setPurchaseOrders($arr_purchase_orders);

try {
  $result = $apiInstance->createPurchaseOrders($xeroTenantId, $purchaseOrders, $summarizeErrors);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createPurchaseOrders: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $purchaseOrders = ::Object::PurchaseOrders->new(); # PurchaseOrders | 
my $summarizeErrors = true; # Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors

eval { 
    my $result = $api_instance->createPurchaseOrders(xeroTenantId => $xeroTenantId, purchaseOrders => $purchaseOrders, summarizeErrors => $summarizeErrors);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createPurchaseOrders: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_purchase_orders():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    summarizeErrors = 'True'
    date_value = dateutil.parser.parse('2020-12-03T00:00:00Z')

    contact = Contact(
        contact_id = "00000000-0000-0000-0000-000000000000")

    line_item = LineItem(
        description = "Foobar",
        quantity = 1.0,
        unit_amount = 20.0,
        account_code = "000")
    
    line_items = []    
    line_items.append(line_item)

    purchase_order = PurchaseOrder(
        contact = contact,
        line_items = line_items,
        date = date_value)

    purchaseOrders = PurchaseOrders( 
        purchase_orders = [purchase_order])
    
    try:
        api_response = api_instance.create_purchase_orders(xeroTenantId, purchaseOrders, summarizeErrors)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createPurchaseOrders: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let purchaseOrders = { "PurchaseOrders": [ { "Contact": { "ContactID": "00000000-0000-0000-0000-000000000000" }, "LineItems": [ { "Description": "Foobar", "Quantity": 1, "UnitAmount": 20, "AccountCode": "710" } ], "Date": "2019-03-13" } ] }; // PurchaseOrders
    let summarizeErrors = true; // Boolean

    let mut context = AccountingApi::Context::default();
    let result = client.createPurchaseOrders(xeroTenantId, purchaseOrders, summarizeErrors, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID quoteID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        String fileName = "xero-dev.jpg";
        File input = new File("/path/to/local/xero-dev.jpg");
        java.nio.file.Path inputPath = input.toPath();
        byte[] body = FileUtils.readFileToByteArray(input);
        String mimeType = Files.probeContentType(inputPath);

        try {
            Attachments result = apiInstance.createQuoteAttachmentByFileName(accessToken, xeroTenantId, quoteID, fileName, body, mimeType);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createQuoteAttachmentByFileName");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID quoteID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for Quote object
        String fileName = xero-dev.jpg; // String | Name of the attachment
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 
        try {
            Attachments result = apiInstance.createQuoteAttachmentByFileName(xeroTenantId, quoteID, fileName, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createQuoteAttachmentByFileName");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *quoteID = 00000000-0000-0000-0000-000000000000; // Unique identifier for Quote object (default to null)
String *fileName = xero-dev.jpg; // Name of the attachment (default to null)
byte[] *body = BYTE_ARRAY_DATA_HERE; // 

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

// Creates attachment for a specific quote
[apiInstance createQuoteAttachmentByFileNameWith:xeroTenantId
    quoteID:quoteID
    fileName:fileName
    body:body
              completionHandler: ^(Attachments output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const quoteID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for Quote object
const fileName = "xero-dev.jpg";  // {String} Name of the attachment
const path = require("path");
const mime = require("mime-types");
const pathToUpload = path.resolve(__dirname, "../public/images/xero-dev.jpg"); // determine the path to your file
import * as fs from "fs";
const body = fs.createReadStream(pathToUpload); // {fs.ReadStream} read the file
const contentType = mime.lookup(fileName);

try {
  const response = await xero.accountingApi.createQuoteAttachmentByFileName(xeroTenantId, quoteID, fileName, body, {
    headers: {
      "Content-Type": contentType,
    }
  });
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var quoteID = new UUID(); // UUID | Unique identifier for Quote object (default to null)
            var fileName = xero-dev.jpg;  // String | Name of the attachment (default to null)
            var body = BYTE_ARRAY_DATA_HERE;  // byte[] | 

            try
            {
                // Creates attachment for a specific quote
                Attachments result = apiInstance.createQuoteAttachmentByFileName(xeroTenantId, quoteID, fileName, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createQuoteAttachmentByFileName: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$quoteID = "00000000-0000-0000-0000-000000000000";
$fileName = "xero-dev.jpg";

$handle = fopen($fileName, "r");
$body = fread($handle, filesize($fileName));
fclose($handle);

try {
  $result = $apiInstance->createQuoteAttachmentByFileName($xeroTenantId, $quoteID, $fileName, $body);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createQuoteAttachmentByFileName: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $quoteID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for Quote object
my $fileName = xero-dev.jpg; # String | Name of the attachment
my $body = ::Object::byte[]->new(); # byte[] | 

eval { 
    my $result = $api_instance->createQuoteAttachmentByFileName(xeroTenantId => $xeroTenantId, quoteID => $quoteID, fileName => $fileName, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createQuoteAttachmentByFileName: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_quote_attachment_by_file_name():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    quoteID = '00000000-0000-0000-0000-000000000000'
    fileName = 'xero-dev.jpg'
    
        // TODO: BINARY CREATE 
    try:
        api_response = api_instance.create_quote_attachment_by_file_name(xeroTenantId, quoteID, fileName, body)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createQuoteAttachmentByFileName: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let quoteID = 00000000-0000-0000-0000-000000000000; // UUID
    let fileName = xero-dev.jpg; // String
    let body = BYTE_ARRAY_DATA_HERE; // byte[]

    let mut context = AccountingApi::Context::default();
    let result = client.createQuoteAttachmentByFileName(xeroTenantId, quoteID, fileName, body, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID quoteID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

        try {
            HistoryRecords result = apiInstance.createQuoteHistory(accessToken, xeroTenantId, quoteID, historyRecords);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createQuoteHistory");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID quoteID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for an Quote
        HistoryRecords historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords | 
        try {
            HistoryRecords result = apiInstance.createQuoteHistory(xeroTenantId, quoteID, historyRecords);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createQuoteHistory");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *quoteID = 00000000-0000-0000-0000-000000000000; // Unique identifier for an Quote (default to null)
HistoryRecords *historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // 

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

// Creates a history record for a specific quote
[apiInstance createQuoteHistoryWith:xeroTenantId
    quoteID:quoteID
    historyRecords:historyRecords
              completionHandler: ^(HistoryRecords output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);
const historyRecords: HistoryRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] };  // {HistoryRecords} 
const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const quoteID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for an Quote


try {
  const response = await xero.accountingApi.createQuoteHistory(xeroTenantId, quoteID, historyRecords);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var quoteID = new UUID(); // UUID | Unique identifier for an Quote (default to null)
            var historyRecords = new HistoryRecords(); // HistoryRecords | 

            try
            {
                // Creates a history record for a specific quote
                HistoryRecords result = apiInstance.createQuoteHistory(xeroTenantId, quoteID, historyRecords);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createQuoteHistory: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$quoteID = "00000000-0000-0000-0000-000000000000";

$historyRecord = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecord;
$historyRecord->setDetails('Hello World');

$historyRecords = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecords;
$arr_history_records = [];
array_push($arr_history_records, $historyRecord);
$historyRecords->setHistoryRecords($arr_history_records);

try {
  $result = $apiInstance->createQuoteHistory($xeroTenantId, $quoteID, $historyRecords);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createQuoteHistory: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $quoteID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for an Quote
my $historyRecords = ::Object::HistoryRecords->new(); # HistoryRecords | 

eval { 
    my $result = $api_instance->createQuoteHistory(xeroTenantId => $xeroTenantId, quoteID => $quoteID, historyRecords => $historyRecords);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createQuoteHistory: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_quote_history():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    quoteID = '00000000-0000-0000-0000-000000000000'

    history_record = HistoryRecord(
        details = "Hello World")

    history_records = HistoryRecords( 
        history_records = [history_record])
    
    try:
        api_response = api_instance.create_quote_history(xeroTenantId, quoteID, historyRecords)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createQuoteHistory: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let quoteID = 00000000-0000-0000-0000-000000000000; // UUID
    let historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords

    let mut context = AccountingApi::Context::default();
    let result = client.createQuoteHistory(xeroTenantId, quoteID, historyRecords, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        Boolean summarizeErrors = true;
        LocalDate dateValue = LocalDate.of(2020, Month.OCTOBER, 10);
        Contact contact = new Contact();
        contact.setContactID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        LineItem lineItem = new LineItem();
        lineItem.setDescription("Foobar");
        lineItem.setQuantity(1.0);
        lineItem.setUnitAmount(20.0);
        lineItem.setAccountCode("000");
        List<LineItems> lineItems = new ArrayList<LineItems>();
        lineItems.add(lineItem);
        Quote quote = new Quote();
        quote.setContact(contact);
        quote.setLineItems(lineItems);
        quote.setDate(dateValue);
        Quotes quotes = new Quotes();
        quotes.addQuotesItem(quote);

        try {
            Quotes result = apiInstance.createQuotes(accessToken, xeroTenantId, quotes, summarizeErrors);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createQuotes");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        Quotes quotes = { "Quotes": [ { "Contact": { "ContactID": "00000000-0000-0000-0000-000000000000" }, "LineItems": [ { "Description": "Foobar", "Quantity": 1, "UnitAmount": 20, "AccountCode": "12775" } ], "Date": "2020-02-01" } ] }; // Quotes | 
        Boolean summarizeErrors = true; // Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors
        try {
            Quotes result = apiInstance.createQuotes(xeroTenantId, quotes, summarizeErrors);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createQuotes");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
Quotes *quotes = { "Quotes": [ { "Contact": { "ContactID": "00000000-0000-0000-0000-000000000000" }, "LineItems": [ { "Description": "Foobar", "Quantity": 1, "UnitAmount": 20, "AccountCode": "12775" } ], "Date": "2020-02-01" } ] }; // 
Boolean *summarizeErrors = true; // If false return 200 OK and mix of successfully created objects and any with validation errors (optional) (default to false)

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

// Create one or more quotes
[apiInstance createQuotesWith:xeroTenantId
    quotes:quotes
    summarizeErrors:summarizeErrors
              completionHandler: ^(Quotes output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant


const summarizeErrors = true;  // {Boolean} If false return 200 OK and mix of successfully created objects and any with validation errors
const quotes: Quotes = { quotes: [{ contact: { contactID: "00000000-0000-0000-0000-000000000000" }, lineItems: [{ description: "Foobar", quantity: 1.0, unitAmount: 20.0, accountCode: "12775" }], date: "2020-02-01" }]}

try {
  const response = await xero.accountingApi.createQuotes(xeroTenantId, quotes,  summarizeErrors);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var quotes = new Quotes(); // Quotes | 
            var summarizeErrors = true;  // Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors (optional)  (default to false)

            try
            {
                // Create one or more quotes
                Quotes result = apiInstance.createQuotes(xeroTenantId, quotes, summarizeErrors);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createQuotes: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$summarizeErrors = true;
$dateValue = new DateTime('2020-12-10');

$contact = new XeroAPI\XeroPHP\Models\Accounting\Contact;
$contact->setContactID('00000000-0000-0000-0000-000000000000');

$lineItem = new XeroAPI\XeroPHP\Models\Accounting\LineItem;
$lineItem->setDescription('Foobar');
$lineItem->setQuantity(1.0);
$lineItem->setUnitAmount(20.0);
$lineItem->setAccountCode('000');
$lineItems = [];
array_push($lineItems, $lineItem);

$quote = new XeroAPI\XeroPHP\Models\Accounting\Quote;
$quote->setContact($contact);
$quote->setLineItems($lineItems);
$quote->setDate($dateValue);

$quotes = new XeroAPI\XeroPHP\Models\Accounting\Quotes;
$arr_quotes = [];
array_push($arr_quotes, $quote);
$quotes->setQuotes($arr_quotes);

try {
  $result = $apiInstance->createQuotes($xeroTenantId, $quotes, $summarizeErrors);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createQuotes: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $quotes = ::Object::Quotes->new(); # Quotes | 
my $summarizeErrors = true; # Boolean | If false return 200 OK and mix of successfully created objects and any with validation errors

eval { 
    my $result = $api_instance->createQuotes(xeroTenantId => $xeroTenantId, quotes => $quotes, summarizeErrors => $summarizeErrors);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createQuotes: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_quotes():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    summarizeErrors = 'True'
    date_value = dateutil.parser.parse('2020-12-03T00:00:00Z')

    contact = Contact(
        contact_id = "00000000-0000-0000-0000-000000000000")

    line_item = LineItem(
        description = "Foobar",
        quantity = 1.0,
        unit_amount = 20.0,
        account_code = "000")
    
    line_items = []    
    line_items.append(line_item)

    quote = Quote(
        contact = contact,
        line_items = line_items,
        date = date_value)

    quotes = Quotes( 
        quotes = [quote])
    
    try:
        api_response = api_instance.create_quotes(xeroTenantId, quotes, summarizeErrors)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createQuotes: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let quotes = { "Quotes": [ { "Contact": { "ContactID": "00000000-0000-0000-0000-000000000000" }, "LineItems": [ { "Description": "Foobar", "Quantity": 1, "UnitAmount": 20, "AccountCode": "12775" } ], "Date": "2020-02-01" } ] }; // Quotes
    let summarizeErrors = true; // Boolean

    let mut context = AccountingApi::Context::default();
    let result = client.createQuotes(xeroTenantId, quotes, summarizeErrors, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        Integer unitdp = 4;
        Contact contact = new Contact();
        contact.setContactID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        User user = new User();
        user.setUserID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        LineItem lineItem = new LineItem();
        lineItem.setDescription("Foobar");
        lineItem.setQuantity(1.0);
        lineItem.setUnitAmount(20.0);
        lineItem.setAccountCode("000");
        List<LineItems> lineItems = new ArrayList<LineItems>();
        lineItems.add(lineItem);
        Receipt receipt = new Receipt();
        receipt.setContact(contact);
        receipt.setUser(user);
        receipt.setLineItems(lineItems);
        receipt.setLineAmountTypes(com.xero.models.accounting.LineAmountTypes.INCLUSIVE);
        receipt.setStatus(com.xero.models.accounting.Receipt.StatusEnum.DRAFT);
        Receipts receipts = new Receipts();
        receipts.addReceiptsItem(receipt);

        try {
            Receipts result = apiInstance.createReceipt(accessToken, xeroTenantId, receipts, unitdp);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createReceipt");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        Receipts receipts = { "Receipts": [ { "Contact": { "ContactID": "00000000-0000-0000-0000-000000000000" }, "Lineitems": [ { "Description": "Foobar", "Quantity": 2, "UnitAmount": 20, "AccountCode": "400", "TaxType": "NONE", "LineAmount": 40 } ], "User": { "UserID": "00000000-0000-0000-0000-000000000000" }, "LineAmountTypes": "NoTax", "Status": "DRAFT" } ] }; // Receipts | 
        Integer unitdp = 4; // Integer | e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts
        try {
            Receipts result = apiInstance.createReceipt(xeroTenantId, receipts, unitdp);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createReceipt");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
Receipts *receipts = { "Receipts": [ { "Contact": { "ContactID": "00000000-0000-0000-0000-000000000000" }, "Lineitems": [ { "Description": "Foobar", "Quantity": 2, "UnitAmount": 20, "AccountCode": "400", "TaxType": "NONE", "LineAmount": 40 } ], "User": { "UserID": "00000000-0000-0000-0000-000000000000" }, "LineAmountTypes": "NoTax", "Status": "DRAFT" } ] }; // 
Integer *unitdp = 4; // e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts (optional) (default to null)

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

// Creates draft expense claim receipts for any user
[apiInstance createReceiptWith:xeroTenantId
    receipts:receipts
    unitdp:unitdp
              completionHandler: ^(Receipts output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant


const unitdp = 4;  // {Integer} e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts
const receipts: Receipts = { receipts: [{ contact: { contactID: "00000000-0000-0000-0000-000000000000" }, lineItems: [{ description: "Foobar", quantity: 2.0, unitAmount: 20.0, accountCode: "400", taxType: TaxType.NONE, lineAmount: 40.0 }], user: { userID: "00000000-0000-0000-0000-000000000000" }, lineAmountTypes: LineAmountTypes.Inclusive, status: Receipt.StatusEnum.DRAFT, date: null} ] }

try {
  const response = await xero.accountingApi.createReceipt(xeroTenantId, receipts,  unitdp);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var receipts = new Receipts(); // Receipts | 
            var unitdp = 4;  // Integer | e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts (optional)  (default to null)

            try
            {
                // Creates draft expense claim receipts for any user
                Receipts result = apiInstance.createReceipt(xeroTenantId, receipts, unitdp);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createReceipt: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$unitdp = 4;

$contact = new XeroAPI\XeroPHP\Models\Accounting\Contact;
$contact->setContactID('00000000-0000-0000-0000-000000000000');

$user = new XeroAPI\XeroPHP\Models\Accounting\User;
$user->setUserID('00000000-0000-0000-0000-000000000000');

$lineItem = new XeroAPI\XeroPHP\Models\Accounting\LineItem;
$lineItem->setDescription('Foobar');
$lineItem->setQuantity(1.0);
$lineItem->setUnitAmount(20.0);
$lineItem->setAccountCode('000');
$lineItems = [];
array_push($lineItems, $lineItem);

$receipt = new XeroAPI\XeroPHP\Models\Accounting\Receipt;
$receipt->setContact($contact);
$receipt->setUser($user);
$receipt->setLineItems($lineItems);
$receipt->setLineAmountTypes(XeroAPI\XeroPHP\Models\Accounting\LineAmountTypes::INCLUSIVE);
$receipt->setStatus(XeroAPI\XeroPHP\Models\Accounting\Receipt::STATUS_DRAFT);

$receipts = new XeroAPI\XeroPHP\Models\Accounting\Receipts;
$arr_receipts = [];
array_push($arr_receipts, $receipt);
$receipts->setReceipts($arr_receipts);

try {
  $result = $apiInstance->createReceipt($xeroTenantId, $receipts, $unitdp);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createReceipt: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $receipts = ::Object::Receipts->new(); # Receipts | 
my $unitdp = 4; # Integer | e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts

eval { 
    my $result = $api_instance->createReceipt(xeroTenantId => $xeroTenantId, receipts => $receipts, unitdp => $unitdp);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createReceipt: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_receipt():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'

    contact = Contact(
        contact_id = "00000000-0000-0000-0000-000000000000")

    user = User(
        user_id = "00000000-0000-0000-0000-000000000000")

    line_item = LineItem(
        description = "Foobar",
        quantity = 1.0,
        unit_amount = 20.0,
        account_code = "000")
    
    line_items = []    
    line_items.append(line_item)

    receipt = Receipt(
        contact = contact,
        user = user,
        line_items = line_items,
        line_amount_types = LineAmountTypes.INCLUSIVE,
        status = "DRAFT")

    receipts = Receipts( 
        receipts = [receipt])
    
    try:
        api_response = api_instance.create_receipt(xeroTenantId, receipts, unitdp)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createReceipt: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let receipts = { "Receipts": [ { "Contact": { "ContactID": "00000000-0000-0000-0000-000000000000" }, "Lineitems": [ { "Description": "Foobar", "Quantity": 2, "UnitAmount": 20, "AccountCode": "400", "TaxType": "NONE", "LineAmount": 40 } ], "User": { "UserID": "00000000-0000-0000-0000-000000000000" }, "LineAmountTypes": "NoTax", "Status": "DRAFT" } ] }; // Receipts
    let unitdp = 4; // Integer

    let mut context = AccountingApi::Context::default();
    let result = client.createReceipt(xeroTenantId, receipts, unitdp, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID receiptID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        String fileName = "xero-dev.jpg";
        File input = new File("/path/to/local/xero-dev.jpg");
        java.nio.file.Path inputPath = input.toPath();
        byte[] body = FileUtils.readFileToByteArray(input);
        String mimeType = Files.probeContentType(inputPath);

        try {
            Attachments result = apiInstance.createReceiptAttachmentByFileName(accessToken, xeroTenantId, receiptID, fileName, body, mimeType);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createReceiptAttachmentByFileName");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID receiptID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for a Receipt
        String fileName = xero-dev.jpg; // String | The name of the file being attached to the Receipt
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 
        try {
            Attachments result = apiInstance.createReceiptAttachmentByFileName(xeroTenantId, receiptID, fileName, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createReceiptAttachmentByFileName");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *receiptID = 00000000-0000-0000-0000-000000000000; // Unique identifier for a Receipt (default to null)
String *fileName = xero-dev.jpg; // The name of the file being attached to the Receipt (default to null)
byte[] *body = BYTE_ARRAY_DATA_HERE; // 

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

// Creates an attachment on a specific expense claim receipts by file name
[apiInstance createReceiptAttachmentByFileNameWith:xeroTenantId
    receiptID:receiptID
    fileName:fileName
    body:body
              completionHandler: ^(Attachments output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const receiptID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for a Receipt
const fileName = "xero-dev.jpg";  // {String} The name of the file being attached to the Receipt
const path = require("path");
const mime = require("mime-types");
const pathToUpload = path.resolve(__dirname, "../public/images/xero-dev.jpg"); // determine the path to your file
import * as fs from "fs";
const body = fs.createReadStream(pathToUpload); // {fs.ReadStream} read the file
const contentType = mime.lookup(fileName);

try {
  const response = await xero.accountingApi.createReceiptAttachmentByFileName(xeroTenantId, receiptID, fileName, body, {
    headers: {
      "Content-Type": contentType,
    }
  });
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var receiptID = new UUID(); // UUID | Unique identifier for a Receipt (default to null)
            var fileName = xero-dev.jpg;  // String | The name of the file being attached to the Receipt (default to null)
            var body = BYTE_ARRAY_DATA_HERE;  // byte[] | 

            try
            {
                // Creates an attachment on a specific expense claim receipts by file name
                Attachments result = apiInstance.createReceiptAttachmentByFileName(xeroTenantId, receiptID, fileName, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createReceiptAttachmentByFileName: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$receiptID = "00000000-0000-0000-0000-000000000000";
$fileName = "xero-dev.jpg";

$handle = fopen($fileName, "r");
$body = fread($handle, filesize($fileName));
fclose($handle);

try {
  $result = $apiInstance->createReceiptAttachmentByFileName($xeroTenantId, $receiptID, $fileName, $body);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createReceiptAttachmentByFileName: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $receiptID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for a Receipt
my $fileName = xero-dev.jpg; # String | The name of the file being attached to the Receipt
my $body = ::Object::byte[]->new(); # byte[] | 

eval { 
    my $result = $api_instance->createReceiptAttachmentByFileName(xeroTenantId => $xeroTenantId, receiptID => $receiptID, fileName => $fileName, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createReceiptAttachmentByFileName: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_receipt_attachment_by_file_name():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    receiptID = '00000000-0000-0000-0000-000000000000'
    fileName = 'xero-dev.jpg'
    
        // TODO: BINARY CREATE 
    try:
        api_response = api_instance.create_receipt_attachment_by_file_name(xeroTenantId, receiptID, fileName, body)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createReceiptAttachmentByFileName: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let receiptID = 00000000-0000-0000-0000-000000000000; // UUID
    let fileName = xero-dev.jpg; // String
    let body = BYTE_ARRAY_DATA_HERE; // byte[]

    let mut context = AccountingApi::Context::default();
    let result = client.createReceiptAttachmentByFileName(xeroTenantId, receiptID, fileName, body, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID receiptID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

        try {
            HistoryRecords result = apiInstance.createReceiptHistory(accessToken, xeroTenantId, receiptID, historyRecords);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createReceiptHistory");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID receiptID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for a Receipt
        HistoryRecords historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords | 
        try {
            HistoryRecords result = apiInstance.createReceiptHistory(xeroTenantId, receiptID, historyRecords);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createReceiptHistory");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *receiptID = 00000000-0000-0000-0000-000000000000; // Unique identifier for a Receipt (default to null)
HistoryRecords *historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // 

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

// Creates a history record for a specific receipt
[apiInstance createReceiptHistoryWith:xeroTenantId
    receiptID:receiptID
    historyRecords:historyRecords
              completionHandler: ^(HistoryRecords output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);
const historyRecords: HistoryRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] };  // {HistoryRecords} 
const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const receiptID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for a Receipt


try {
  const response = await xero.accountingApi.createReceiptHistory(xeroTenantId, receiptID, historyRecords);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var receiptID = new UUID(); // UUID | Unique identifier for a Receipt (default to null)
            var historyRecords = new HistoryRecords(); // HistoryRecords | 

            try
            {
                // Creates a history record for a specific receipt
                HistoryRecords result = apiInstance.createReceiptHistory(xeroTenantId, receiptID, historyRecords);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createReceiptHistory: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$receiptID = "00000000-0000-0000-0000-000000000000";

$historyRecord = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecord;
$historyRecord->setDetails('Hello World');

$historyRecords = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecords;
$arr_history_records = [];
array_push($arr_history_records, $historyRecord);
$historyRecords->setHistoryRecords($arr_history_records);

try {
  $result = $apiInstance->createReceiptHistory($xeroTenantId, $receiptID, $historyRecords);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createReceiptHistory: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $receiptID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for a Receipt
my $historyRecords = ::Object::HistoryRecords->new(); # HistoryRecords | 

eval { 
    my $result = $api_instance->createReceiptHistory(xeroTenantId => $xeroTenantId, receiptID => $receiptID, historyRecords => $historyRecords);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createReceiptHistory: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_receipt_history():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    receiptID = '00000000-0000-0000-0000-000000000000'

    history_record = HistoryRecord(
        details = "Hello World")

    history_records = HistoryRecords( 
        history_records = [history_record])
    
    try:
        api_response = api_instance.create_receipt_history(xeroTenantId, receiptID, historyRecords)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createReceiptHistory: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let receiptID = 00000000-0000-0000-0000-000000000000; // UUID
    let historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords

    let mut context = AccountingApi::Context::default();
    let result = client.createReceiptHistory(xeroTenantId, receiptID, historyRecords, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID repeatingInvoiceID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        String fileName = "xero-dev.jpg";
        File input = new File("/path/to/local/xero-dev.jpg");
        java.nio.file.Path inputPath = input.toPath();
        byte[] body = FileUtils.readFileToByteArray(input);
        String mimeType = Files.probeContentType(inputPath);

        try {
            Attachments result = apiInstance.createRepeatingInvoiceAttachmentByFileName(accessToken, xeroTenantId, repeatingInvoiceID, fileName, body, mimeType);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createRepeatingInvoiceAttachmentByFileName");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID repeatingInvoiceID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for a Repeating Invoice
        String fileName = xero-dev.jpg; // String | The name of the file being attached to a Repeating Invoice
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 
        try {
            Attachments result = apiInstance.createRepeatingInvoiceAttachmentByFileName(xeroTenantId, repeatingInvoiceID, fileName, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createRepeatingInvoiceAttachmentByFileName");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *repeatingInvoiceID = 00000000-0000-0000-0000-000000000000; // Unique identifier for a Repeating Invoice (default to null)
String *fileName = xero-dev.jpg; // The name of the file being attached to a Repeating Invoice (default to null)
byte[] *body = BYTE_ARRAY_DATA_HERE; // 

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

// Creates an attachment from a specific repeating invoices by file name
[apiInstance createRepeatingInvoiceAttachmentByFileNameWith:xeroTenantId
    repeatingInvoiceID:repeatingInvoiceID
    fileName:fileName
    body:body
              completionHandler: ^(Attachments output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const repeatingInvoiceID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for a Repeating Invoice
const fileName = "xero-dev.jpg";  // {String} The name of the file being attached to a Repeating Invoice
const path = require("path");
const mime = require("mime-types");
const pathToUpload = path.resolve(__dirname, "../public/images/xero-dev.jpg"); // determine the path to your file
import * as fs from "fs";
const body = fs.createReadStream(pathToUpload); // {fs.ReadStream} read the file
const contentType = mime.lookup(fileName);

try {
  const response = await xero.accountingApi.createRepeatingInvoiceAttachmentByFileName(xeroTenantId, repeatingInvoiceID, fileName, body, {
    headers: {
      "Content-Type": contentType,
    }
  });
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var repeatingInvoiceID = new UUID(); // UUID | Unique identifier for a Repeating Invoice (default to null)
            var fileName = xero-dev.jpg;  // String | The name of the file being attached to a Repeating Invoice (default to null)
            var body = BYTE_ARRAY_DATA_HERE;  // byte[] | 

            try
            {
                // Creates an attachment from a specific repeating invoices by file name
                Attachments result = apiInstance.createRepeatingInvoiceAttachmentByFileName(xeroTenantId, repeatingInvoiceID, fileName, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createRepeatingInvoiceAttachmentByFileName: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$repeatingInvoiceID = "00000000-0000-0000-0000-000000000000";
$fileName = "xero-dev.jpg";

$handle = fopen($fileName, "r");
$body = fread($handle, filesize($fileName));
fclose($handle);

try {
  $result = $apiInstance->createRepeatingInvoiceAttachmentByFileName($xeroTenantId, $repeatingInvoiceID, $fileName, $body);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createRepeatingInvoiceAttachmentByFileName: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $repeatingInvoiceID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for a Repeating Invoice
my $fileName = xero-dev.jpg; # String | The name of the file being attached to a Repeating Invoice
my $body = ::Object::byte[]->new(); # byte[] | 

eval { 
    my $result = $api_instance->createRepeatingInvoiceAttachmentByFileName(xeroTenantId => $xeroTenantId, repeatingInvoiceID => $repeatingInvoiceID, fileName => $fileName, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createRepeatingInvoiceAttachmentByFileName: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_repeating_invoice_attachment_by_file_name():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    repeatingInvoiceID = '00000000-0000-0000-0000-000000000000'
    fileName = 'xero-dev.jpg'
    
        // TODO: BINARY CREATE 
    try:
        api_response = api_instance.create_repeating_invoice_attachment_by_file_name(xeroTenantId, repeatingInvoiceID, fileName, body)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createRepeatingInvoiceAttachmentByFileName: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let repeatingInvoiceID = 00000000-0000-0000-0000-000000000000; // UUID
    let fileName = xero-dev.jpg; // String
    let body = BYTE_ARRAY_DATA_HERE; // byte[]

    let mut context = AccountingApi::Context::default();
    let result = client.createRepeatingInvoiceAttachmentByFileName(xeroTenantId, repeatingInvoiceID, fileName, body, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID repeatingInvoiceID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

        try {
            HistoryRecords result = apiInstance.createRepeatingInvoiceHistory(accessToken, xeroTenantId, repeatingInvoiceID, historyRecords);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createRepeatingInvoiceHistory");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID repeatingInvoiceID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for a Repeating Invoice
        HistoryRecords historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords | 
        try {
            HistoryRecords result = apiInstance.createRepeatingInvoiceHistory(xeroTenantId, repeatingInvoiceID, historyRecords);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createRepeatingInvoiceHistory");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *repeatingInvoiceID = 00000000-0000-0000-0000-000000000000; // Unique identifier for a Repeating Invoice (default to null)
HistoryRecords *historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // 

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

// Creates a  history record for a specific repeating invoice
[apiInstance createRepeatingInvoiceHistoryWith:xeroTenantId
    repeatingInvoiceID:repeatingInvoiceID
    historyRecords:historyRecords
              completionHandler: ^(HistoryRecords output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);
const historyRecords: HistoryRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] };  // {HistoryRecords} 
const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const repeatingInvoiceID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for a Repeating Invoice


try {
  const response = await xero.accountingApi.createRepeatingInvoiceHistory(xeroTenantId, repeatingInvoiceID, historyRecords);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var repeatingInvoiceID = new UUID(); // UUID | Unique identifier for a Repeating Invoice (default to null)
            var historyRecords = new HistoryRecords(); // HistoryRecords | 

            try
            {
                // Creates a  history record for a specific repeating invoice
                HistoryRecords result = apiInstance.createRepeatingInvoiceHistory(xeroTenantId, repeatingInvoiceID, historyRecords);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createRepeatingInvoiceHistory: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$repeatingInvoiceID = "00000000-0000-0000-0000-000000000000";

$historyRecord = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecord;
$historyRecord->setDetails('Hello World');

$historyRecords = new XeroAPI\XeroPHP\Models\Accounting\HistoryRecords;
$arr_history_records = [];
array_push($arr_history_records, $historyRecord);
$historyRecords->setHistoryRecords($arr_history_records);

try {
  $result = $apiInstance->createRepeatingInvoiceHistory($xeroTenantId, $repeatingInvoiceID, $historyRecords);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createRepeatingInvoiceHistory: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $repeatingInvoiceID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for a Repeating Invoice
my $historyRecords = ::Object::HistoryRecords->new(); # HistoryRecords | 

eval { 
    my $result = $api_instance->createRepeatingInvoiceHistory(xeroTenantId => $xeroTenantId, repeatingInvoiceID => $repeatingInvoiceID, historyRecords => $historyRecords);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createRepeatingInvoiceHistory: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_repeating_invoice_history():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    repeatingInvoiceID = '00000000-0000-0000-0000-000000000000'

    history_record = HistoryRecord(
        details = "Hello World")

    history_records = HistoryRecords( 
        history_records = [history_record])
    
    try:
        api_response = api_instance.create_repeating_invoice_history(xeroTenantId, repeatingInvoiceID, historyRecords)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createRepeatingInvoiceHistory: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let repeatingInvoiceID = 00000000-0000-0000-0000-000000000000; // UUID
    let historyRecords = { "HistoryRecords": [ { "Details": "Hello World" } ] }; // HistoryRecords

    let mut context = AccountingApi::Context::default();
    let result = client.createRepeatingInvoiceHistory(xeroTenantId, repeatingInvoiceID, historyRecords, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        TaxComponent taxComponent = new TaxComponent();
        taxComponent.setName("State Tax");
        taxComponent.setRate(2.25);
        List<TaxComponent> taxComponent = new ArrayList<TaxComponent>();
        taxComponents.add(taxComponent);
        TaxRate taxRate = new TaxRate();
        taxRate.setName("CA State Tax");
        taxRate.setTaxComponents(taxComponents);
        TaxRates taxRates = new TaxRates();
        taxRates.addTaxRatesItem(taxRate);

        try {
            TaxRates result = apiInstance.createTaxRates(accessToken, xeroTenantId, taxRates);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createTaxRates");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        TaxRates taxRates = { "TaxRates": [ { "Name": "CA State Tax", "TaxComponents": [ { "Name": "State Tax", "Rate": 2.25 } ] } ] }; // TaxRates | 
        try {
            TaxRates result = apiInstance.createTaxRates(xeroTenantId, taxRates);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createTaxRates");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
TaxRates *taxRates = { "TaxRates": [ { "Name": "CA State Tax", "TaxComponents": [ { "Name": "State Tax", "Rate": 2.25 } ] } ] }; // 

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

// Creates one or more tax rates
[apiInstance createTaxRatesWith:xeroTenantId
    taxRates:taxRates
              completionHandler: ^(TaxRates output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const taxRates: TaxRates = { taxRates: [{ name: "CA State Tax", taxComponents: [{ name: "State Tax", rate: 2.25 }]}]}

try {
  const response = await xero.accountingApi.createTaxRates(xeroTenantId, taxRates);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var taxRates = new TaxRates(); // TaxRates | 

            try
            {
                // Creates one or more tax rates
                TaxRates result = apiInstance.createTaxRates(xeroTenantId, taxRates);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createTaxRates: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";

$taxComponent = new XeroAPI\XeroPHP\Models\Accounting\TaxComponent;
$taxComponent->setName('State Tax');
$taxComponent->setRate(2.25);
$taxComponent = [];
array_push($taxComponents, $taxComponent);

$taxRate = new XeroAPI\XeroPHP\Models\Accounting\TaxRate;
$taxRate->setName('CA State Tax');
$taxRate->setTaxComponents($taxComponents);

$taxRates = new XeroAPI\XeroPHP\Models\Accounting\TaxRates;
$arr_tax_rates = [];
array_push($arr_tax_rates, $taxRate);
$taxRates->setTaxRates($arr_tax_rates);

try {
  $result = $apiInstance->createTaxRates($xeroTenantId, $taxRates);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createTaxRates: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $taxRates = ::Object::TaxRates->new(); # TaxRates | 

eval { 
    my $result = $api_instance->createTaxRates(xeroTenantId => $xeroTenantId, taxRates => $taxRates);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createTaxRates: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_tax_rates():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'

    tax_component = TaxComponent(
        name = "State Tax",
        rate = 2.25)
    
    taxComponent = []    
    tax_components.append(tax_component)

    tax_rate = TaxRate(
        name = "CA State Tax",
        taxComponents = taxComponents,

    taxRates = TaxRates( 
        tax_rates = [tax_rate])
    
    try:
        api_response = api_instance.create_tax_rates(xeroTenantId, taxRates)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createTaxRates: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let taxRates = { "TaxRates": [ { "Name": "CA State Tax", "TaxComponents": [ { "Name": "State Tax", "Rate": 2.25 } ] } ] }; // TaxRates

    let mut context = AccountingApi::Context::default();
    let result = client.createTaxRates(xeroTenantId, taxRates, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        TrackingCategory trackingCategory = new TrackingCategory();
        trackingCategory.setName("Foobar");

        try {
            TrackingCategories result = apiInstance.createTrackingCategory(accessToken, xeroTenantId, trackingCategory);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createTrackingCategory");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        TrackingCategory trackingCategory = { name: "FooBar" }; // TrackingCategory | 
        try {
            TrackingCategories result = apiInstance.createTrackingCategory(xeroTenantId, trackingCategory);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createTrackingCategory");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
TrackingCategory *trackingCategory = { name: "FooBar" }; // 

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

// Create tracking categories
[apiInstance createTrackingCategoryWith:xeroTenantId
    trackingCategory:trackingCategory
              completionHandler: ^(TrackingCategories output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);
const trackingCategory: TrackingCategory = { name: "FooBar" };  // {TrackingCategory} 
const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant


try {
  const response = await xero.accountingApi.createTrackingCategory(xeroTenantId, trackingCategory);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var trackingCategory = new TrackingCategory(); // TrackingCategory | 

            try
            {
                // Create tracking categories
                TrackingCategories result = apiInstance.createTrackingCategory(xeroTenantId, trackingCategory);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createTrackingCategory: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";

$trackingCategory = new XeroAPI\XeroPHP\Models\Accounting\TrackingCategory;
$trackingCategory->setName('Foobar');

try {
  $result = $apiInstance->createTrackingCategory($xeroTenantId, $trackingCategory);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createTrackingCategory: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $trackingCategory = ::Object::TrackingCategory->new(); # TrackingCategory | 

eval { 
    my $result = $api_instance->createTrackingCategory(xeroTenantId => $xeroTenantId, trackingCategory => $trackingCategory);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createTrackingCategory: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_tracking_category():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'

    trackingCategory = TrackingCategory(
        name = "Foobar")
    
    try:
        api_response = api_instance.create_tracking_category(xeroTenantId, trackingCategory)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createTrackingCategory: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let trackingCategory = { name: "FooBar" }; // TrackingCategory

    let mut context = AccountingApi::Context::default();
    let result = client.createTrackingCategory(xeroTenantId, trackingCategory, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID trackingCategoryID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        TrackingOption trackingOption = new TrackingOption();
        trackingOption.setName("Foobar");

        try {
            TrackingOptions result = apiInstance.createTrackingOptions(accessToken, xeroTenantId, trackingCategoryID, trackingOption);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createTrackingOptions");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID trackingCategoryID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for a TrackingCategory
        TrackingOption trackingOption = { name: " Bar" }; // TrackingOption | 
        try {
            TrackingOptions result = apiInstance.createTrackingOptions(xeroTenantId, trackingCategoryID, trackingOption);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#createTrackingOptions");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *trackingCategoryID = 00000000-0000-0000-0000-000000000000; // Unique identifier for a TrackingCategory (default to null)
TrackingOption *trackingOption = { name: " Bar" }; // 

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

// Creates options for a specific tracking category
[apiInstance createTrackingOptionsWith:xeroTenantId
    trackingCategoryID:trackingCategoryID
    trackingOption:trackingOption
              completionHandler: ^(TrackingOptions output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);
const trackingOption: TrackingOption = { name: " Bar" };  // {TrackingOption} 
const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const trackingCategoryID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for a TrackingCategory


try {
  const response = await xero.accountingApi.createTrackingOptions(xeroTenantId, trackingCategoryID, trackingOption);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var trackingCategoryID = new UUID(); // UUID | Unique identifier for a TrackingCategory (default to null)
            var trackingOption = new TrackingOption(); // TrackingOption | 

            try
            {
                // Creates options for a specific tracking category
                TrackingOptions result = apiInstance.createTrackingOptions(xeroTenantId, trackingCategoryID, trackingOption);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.createTrackingOptions: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$trackingCategoryID = "00000000-0000-0000-0000-000000000000";

$trackingOption = new XeroAPI\XeroPHP\Models\Accounting\TrackingOption;
$trackingOption->setName('Foobar');

try {
  $result = $apiInstance->createTrackingOptions($xeroTenantId, $trackingCategoryID, $trackingOption);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->createTrackingOptions: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $trackingCategoryID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for a TrackingCategory
my $trackingOption = ::Object::TrackingOption->new(); # TrackingOption | 

eval { 
    my $result = $api_instance->createTrackingOptions(xeroTenantId => $xeroTenantId, trackingCategoryID => $trackingCategoryID, trackingOption => $trackingOption);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->createTrackingOptions: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_create_tracking_options():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    trackingCategoryID = '00000000-0000-0000-0000-000000000000'

    trackingOption = TrackingOption(
        name = "Foobar")
    
    try:
        api_response = api_instance.create_tracking_options(xeroTenantId, trackingCategoryID, trackingOption)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->createTrackingOptions: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let trackingCategoryID = 00000000-0000-0000-0000-000000000000; // UUID
    let trackingOption = { name: " Bar" }; // TrackingOption

    let mut context = AccountingApi::Context::default();
    let result = client.createTrackingOptions(xeroTenantId, trackingCategoryID, trackingOption, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID accountID = UUID.fromString("00000000-0000-0000-0000-000000000000");

        try {
            Accounts result = apiInstance.deleteAccount(accessToken, xeroTenantId, accountID);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#deleteAccount");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID accountID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for retrieving single object
        try {
            Accounts result = apiInstance.deleteAccount(xeroTenantId, accountID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#deleteAccount");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *accountID = 00000000-0000-0000-0000-000000000000; // Unique identifier for retrieving single object (default to null)

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

// Deletes a chart of accounts
[apiInstance deleteAccountWith:xeroTenantId
    accountID:accountID
              completionHandler: ^(Accounts output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const accountID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for retrieving single object

try {
  const response = await xero.accountingApi.deleteAccount(xeroTenantId, accountID);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var accountID = new UUID(); // UUID | Unique identifier for retrieving single object (default to null)

            try
            {
                // Deletes a chart of accounts
                Accounts result = apiInstance.deleteAccount(xeroTenantId, accountID);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.deleteAccount: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$accountID = "00000000-0000-0000-0000-000000000000";

try {
  $result = $apiInstance->deleteAccount($xeroTenantId, $accountID);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->deleteAccount: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $accountID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for retrieving single object

eval { 
    my $result = $api_instance->deleteAccount(xeroTenantId => $xeroTenantId, accountID => $accountID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->deleteAccount: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_delete_account():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    accountID = '00000000-0000-0000-0000-000000000000'
    
    try:
        api_response = api_instance.delete_account(xeroTenantId, accountID)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->deleteAccount: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let accountID = 00000000-0000-0000-0000-000000000000; // UUID

    let mut context = AccountingApi::Context::default();
    let result = client.deleteAccount(xeroTenantId, accountID, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID contactGroupID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID contactID = UUID.fromString("00000000-0000-0000-0000-000000000000");

        try {
             result = apiInstance.deleteContactGroupContact(accessToken, xeroTenantId, contactGroupID, contactID);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#deleteContactGroupContact");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID contactGroupID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for a Contact Group
        UUID contactID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for a Contact
        try {
            apiInstance.deleteContactGroupContact(xeroTenantId, contactGroupID, contactID);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#deleteContactGroupContact");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *contactGroupID = 00000000-0000-0000-0000-000000000000; // Unique identifier for a Contact Group (default to null)
UUID *contactID = 00000000-0000-0000-0000-000000000000; // Unique identifier for a Contact (default to null)

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

// Deletes a specific contact from a contact group using a unique contact Id
[apiInstance deleteContactGroupContactWith:xeroTenantId
    contactGroupID:contactGroupID
    contactID:contactID
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const contactGroupID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for a Contact Group
const contactID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for a Contact

try {
  const response = await xero.accountingApi.deleteContactGroupContact(xeroTenantId, contactGroupID, contactID);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var contactGroupID = new UUID(); // UUID | Unique identifier for a Contact Group (default to null)
            var contactID = new UUID(); // UUID | Unique identifier for a Contact (default to null)

            try
            {
                // Deletes a specific contact from a contact group using a unique contact Id
                apiInstance.deleteContactGroupContact(xeroTenantId, contactGroupID, contactID);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.deleteContactGroupContact: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$contactGroupID = "00000000-0000-0000-0000-000000000000";
$contactID = "00000000-0000-0000-0000-000000000000";

try {
  $apiInstance->deleteContactGroupContact($xeroTenantId, $contactGroupID, $contactID);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->deleteContactGroupContact: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $contactGroupID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for a Contact Group
my $contactID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for a Contact

eval { 
    $api_instance->deleteContactGroupContact(xeroTenantId => $xeroTenantId, contactGroupID => $contactGroupID, contactID => $contactID);
};
if ($@) {
    warn "Exception when calling AccountingApi->deleteContactGroupContact: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_delete_contact_group_contact():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    contactGroupID = '00000000-0000-0000-0000-000000000000'
    contactID = '00000000-0000-0000-0000-000000000000'
    
    try:
        api_instance.delete_contact_group_contact(xeroTenantId, contactGroupID, contactID)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->deleteContactGroupContact: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let contactGroupID = 00000000-0000-0000-0000-000000000000; // UUID
    let contactID = 00000000-0000-0000-0000-000000000000; // UUID

    let mut context = AccountingApi::Context::default();
    let result = client.deleteContactGroupContact(xeroTenantId, contactGroupID, contactID, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID contactGroupID = UUID.fromString("00000000-0000-0000-0000-000000000000");

        try {
             result = apiInstance.deleteContactGroupContacts(accessToken, xeroTenantId, contactGroupID);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#deleteContactGroupContacts");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID contactGroupID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for a Contact Group
        try {
            apiInstance.deleteContactGroupContacts(xeroTenantId, contactGroupID);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#deleteContactGroupContacts");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *contactGroupID = 00000000-0000-0000-0000-000000000000; // Unique identifier for a Contact Group (default to null)

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

// Deletes all contacts from a specific contact group
[apiInstance deleteContactGroupContactsWith:xeroTenantId
    contactGroupID:contactGroupID
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const contactGroupID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for a Contact Group

try {
  const response = await xero.accountingApi.deleteContactGroupContacts(xeroTenantId, contactGroupID);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var contactGroupID = new UUID(); // UUID | Unique identifier for a Contact Group (default to null)

            try
            {
                // Deletes all contacts from a specific contact group
                apiInstance.deleteContactGroupContacts(xeroTenantId, contactGroupID);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.deleteContactGroupContacts: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$contactGroupID = "00000000-0000-0000-0000-000000000000";

try {
  $apiInstance->deleteContactGroupContacts($xeroTenantId, $contactGroupID);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->deleteContactGroupContacts: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $contactGroupID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for a Contact Group

eval { 
    $api_instance->deleteContactGroupContacts(xeroTenantId => $xeroTenantId, contactGroupID => $contactGroupID);
};
if ($@) {
    warn "Exception when calling AccountingApi->deleteContactGroupContacts: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_delete_contact_group_contacts():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    contactGroupID = '00000000-0000-0000-0000-000000000000'
    
    try:
        api_instance.delete_contact_group_contacts(xeroTenantId, contactGroupID)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->deleteContactGroupContacts: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let contactGroupID = 00000000-0000-0000-0000-000000000000; // UUID

    let mut context = AccountingApi::Context::default();
    let result = client.deleteContactGroupContacts(xeroTenantId, contactGroupID, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID itemID = UUID.fromString("00000000-0000-0000-0000-000000000000");

        try {
             result = apiInstance.deleteItem(accessToken, xeroTenantId, itemID);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#deleteItem");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID itemID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for an Item
        try {
            apiInstance.deleteItem(xeroTenantId, itemID);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#deleteItem");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *itemID = 00000000-0000-0000-0000-000000000000; // Unique identifier for an Item (default to null)

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

// Deletes a specific item
[apiInstance deleteItemWith:xeroTenantId
    itemID:itemID
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const itemID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for an Item

try {
  const response = await xero.accountingApi.deleteItem(xeroTenantId, itemID);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var itemID = new UUID(); // UUID | Unique identifier for an Item (default to null)

            try
            {
                // Deletes a specific item
                apiInstance.deleteItem(xeroTenantId, itemID);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.deleteItem: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$itemID = "00000000-0000-0000-0000-000000000000";

try {
  $apiInstance->deleteItem($xeroTenantId, $itemID);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->deleteItem: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $itemID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for an Item

eval { 
    $api_instance->deleteItem(xeroTenantId => $xeroTenantId, itemID => $itemID);
};
if ($@) {
    warn "Exception when calling AccountingApi->deleteItem: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_delete_item():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    itemID = '00000000-0000-0000-0000-000000000000'
    
    try:
        api_instance.delete_item(xeroTenantId, itemID)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->deleteItem: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let itemID = 00000000-0000-0000-0000-000000000000; // UUID

    let mut context = AccountingApi::Context::default();
    let result = client.deleteItem(xeroTenantId, itemID, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID linkedTransactionID = UUID.fromString("00000000-0000-0000-0000-000000000000");

        try {
             result = apiInstance.deleteLinkedTransaction(accessToken, xeroTenantId, linkedTransactionID);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#deleteLinkedTransaction");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID linkedTransactionID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for a LinkedTransaction
        try {
            apiInstance.deleteLinkedTransaction(xeroTenantId, linkedTransactionID);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#deleteLinkedTransaction");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *linkedTransactionID = 00000000-0000-0000-0000-000000000000; // Unique identifier for a LinkedTransaction (default to null)

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

// Deletes a specific linked transactions (billable expenses)
[apiInstance deleteLinkedTransactionWith:xeroTenantId
    linkedTransactionID:linkedTransactionID
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const linkedTransactionID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for a LinkedTransaction

try {
  const response = await xero.accountingApi.deleteLinkedTransaction(xeroTenantId, linkedTransactionID);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var linkedTransactionID = new UUID(); // UUID | Unique identifier for a LinkedTransaction (default to null)

            try
            {
                // Deletes a specific linked transactions (billable expenses)
                apiInstance.deleteLinkedTransaction(xeroTenantId, linkedTransactionID);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.deleteLinkedTransaction: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$linkedTransactionID = "00000000-0000-0000-0000-000000000000";

try {
  $apiInstance->deleteLinkedTransaction($xeroTenantId, $linkedTransactionID);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->deleteLinkedTransaction: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $linkedTransactionID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for a LinkedTransaction

eval { 
    $api_instance->deleteLinkedTransaction(xeroTenantId => $xeroTenantId, linkedTransactionID => $linkedTransactionID);
};
if ($@) {
    warn "Exception when calling AccountingApi->deleteLinkedTransaction: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_delete_linked_transaction():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    linkedTransactionID = '00000000-0000-0000-0000-000000000000'
    
    try:
        api_instance.delete_linked_transaction(xeroTenantId, linkedTransactionID)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->deleteLinkedTransaction: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let linkedTransactionID = 00000000-0000-0000-0000-000000000000; // UUID

    let mut context = AccountingApi::Context::default();
    let result = client.deleteLinkedTransaction(xeroTenantId, linkedTransactionID, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID paymentID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        PaymentDelete paymentDelete = new PaymentDelete();
        paymentDelete.setStatus("DELETED");

        try {
            Payments result = apiInstance.deletePayment(accessToken, xeroTenantId, paymentID, paymentDelete);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#deletePayment");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID paymentID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for a Payment
        PaymentDelete paymentDelete = { "Payments":[ { "Status":"DELETED" } ] }; // PaymentDelete | 
        try {
            Payments result = apiInstance.deletePayment(xeroTenantId, paymentID, paymentDelete);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#deletePayment");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *paymentID = 00000000-0000-0000-0000-000000000000; // Unique identifier for a Payment (default to null)
PaymentDelete *paymentDelete = { "Payments":[ { "Status":"DELETED" } ] }; // 

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

// Updates a specific payment for invoices and credit notes
[apiInstance deletePaymentWith:xeroTenantId
    paymentID:paymentID
    paymentDelete:paymentDelete
              completionHandler: ^(Payments output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const paymentID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for a Payment
const paymentDelete: PaymentDelete = { status: "DELETED" }

try {
  const response = await xero.accountingApi.deletePayment(xeroTenantId, paymentID, paymentDelete);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var paymentID = new UUID(); // UUID | Unique identifier for a Payment (default to null)
            var paymentDelete = new PaymentDelete(); // PaymentDelete | 

            try
            {
                // Updates a specific payment for invoices and credit notes
                Payments result = apiInstance.deletePayment(xeroTenantId, paymentID, paymentDelete);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.deletePayment: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$paymentID = "00000000-0000-0000-0000-000000000000";

$paymentDelete = new XeroAPI\XeroPHP\Models\Accounting\PaymentDelete;
$paymentDelete->setStatus('DELETED');

try {
  $result = $apiInstance->deletePayment($xeroTenantId, $paymentID, $paymentDelete);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->deletePayment: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $paymentID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for a Payment
my $paymentDelete = ::Object::PaymentDelete->new(); # PaymentDelete | 

eval { 
    my $result = $api_instance->deletePayment(xeroTenantId => $xeroTenantId, paymentID => $paymentID, paymentDelete => $paymentDelete);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->deletePayment: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_delete_payment():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    paymentID = '00000000-0000-0000-0000-000000000000'

    paymentDelete = PaymentDelete(
        status = "DELETED")
    
    try:
        api_response = api_instance.delete_payment(xeroTenantId, paymentID, paymentDelete)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->deletePayment: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let paymentID = 00000000-0000-0000-0000-000000000000; // UUID
    let paymentDelete = { "Payments":[ { "Status":"DELETED" } ] }; // PaymentDelete

    let mut context = AccountingApi::Context::default();
    let result = client.deletePayment(xeroTenantId, paymentID, paymentDelete, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID trackingCategoryID = UUID.fromString("00000000-0000-0000-0000-000000000000");

        try {
            TrackingCategories result = apiInstance.deleteTrackingCategory(accessToken, xeroTenantId, trackingCategoryID);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#deleteTrackingCategory");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID trackingCategoryID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for a TrackingCategory
        try {
            TrackingCategories result = apiInstance.deleteTrackingCategory(xeroTenantId, trackingCategoryID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#deleteTrackingCategory");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *trackingCategoryID = 00000000-0000-0000-0000-000000000000; // Unique identifier for a TrackingCategory (default to null)

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

// Deletes a specific tracking category
[apiInstance deleteTrackingCategoryWith:xeroTenantId
    trackingCategoryID:trackingCategoryID
              completionHandler: ^(TrackingCategories output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const trackingCategoryID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for a TrackingCategory

try {
  const response = await xero.accountingApi.deleteTrackingCategory(xeroTenantId, trackingCategoryID);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var trackingCategoryID = new UUID(); // UUID | Unique identifier for a TrackingCategory (default to null)

            try
            {
                // Deletes a specific tracking category
                TrackingCategories result = apiInstance.deleteTrackingCategory(xeroTenantId, trackingCategoryID);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.deleteTrackingCategory: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$trackingCategoryID = "00000000-0000-0000-0000-000000000000";

try {
  $result = $apiInstance->deleteTrackingCategory($xeroTenantId, $trackingCategoryID);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->deleteTrackingCategory: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $trackingCategoryID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for a TrackingCategory

eval { 
    my $result = $api_instance->deleteTrackingCategory(xeroTenantId => $xeroTenantId, trackingCategoryID => $trackingCategoryID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->deleteTrackingCategory: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_delete_tracking_category():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    trackingCategoryID = '00000000-0000-0000-0000-000000000000'
    
    try:
        api_response = api_instance.delete_tracking_category(xeroTenantId, trackingCategoryID)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->deleteTrackingCategory: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let trackingCategoryID = 00000000-0000-0000-0000-000000000000; // UUID

    let mut context = AccountingApi::Context::default();
    let result = client.deleteTrackingCategory(xeroTenantId, trackingCategoryID, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID trackingCategoryID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID trackingOptionID = UUID.fromString("00000000-0000-0000-0000-000000000000");

        try {
            TrackingOptions result = apiInstance.deleteTrackingOptions(accessToken, xeroTenantId, trackingCategoryID, trackingOptionID);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#deleteTrackingOptions");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID trackingCategoryID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for a TrackingCategory
        UUID trackingOptionID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for a Tracking Option
        try {
            TrackingOptions result = apiInstance.deleteTrackingOptions(xeroTenantId, trackingCategoryID, trackingOptionID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#deleteTrackingOptions");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *trackingCategoryID = 00000000-0000-0000-0000-000000000000; // Unique identifier for a TrackingCategory (default to null)
UUID *trackingOptionID = 00000000-0000-0000-0000-000000000000; // Unique identifier for a Tracking Option (default to null)

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

// Deletes a specific option for a specific tracking category
[apiInstance deleteTrackingOptionsWith:xeroTenantId
    trackingCategoryID:trackingCategoryID
    trackingOptionID:trackingOptionID
              completionHandler: ^(TrackingOptions output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const trackingCategoryID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for a TrackingCategory
const trackingOptionID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for a Tracking Option

try {
  const response = await xero.accountingApi.deleteTrackingOptions(xeroTenantId, trackingCategoryID, trackingOptionID);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var trackingCategoryID = new UUID(); // UUID | Unique identifier for a TrackingCategory (default to null)
            var trackingOptionID = new UUID(); // UUID | Unique identifier for a Tracking Option (default to null)

            try
            {
                // Deletes a specific option for a specific tracking category
                TrackingOptions result = apiInstance.deleteTrackingOptions(xeroTenantId, trackingCategoryID, trackingOptionID);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.deleteTrackingOptions: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$trackingCategoryID = "00000000-0000-0000-0000-000000000000";
$trackingOptionID = "00000000-0000-0000-0000-000000000000";

try {
  $result = $apiInstance->deleteTrackingOptions($xeroTenantId, $trackingCategoryID, $trackingOptionID);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->deleteTrackingOptions: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $trackingCategoryID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for a TrackingCategory
my $trackingOptionID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for a Tracking Option

eval { 
    my $result = $api_instance->deleteTrackingOptions(xeroTenantId => $xeroTenantId, trackingCategoryID => $trackingCategoryID, trackingOptionID => $trackingOptionID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->deleteTrackingOptions: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_delete_tracking_options():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    trackingCategoryID = '00000000-0000-0000-0000-000000000000'
    trackingOptionID = '00000000-0000-0000-0000-000000000000'
    
    try:
        api_response = api_instance.delete_tracking_options(xeroTenantId, trackingCategoryID, trackingOptionID)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->deleteTrackingOptions: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let trackingCategoryID = 00000000-0000-0000-0000-000000000000; // UUID
    let trackingOptionID = 00000000-0000-0000-0000-000000000000; // UUID

    let mut context = AccountingApi::Context::default();
    let result = client.deleteTrackingOptions(xeroTenantId, trackingCategoryID, trackingOptionID, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID invoiceID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        RequestEmpty requestEmpty = new RequestEmpty();

        try {
             result = apiInstance.emailInvoice(accessToken, xeroTenantId, invoiceID, requestEmpty);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#emailInvoice");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID invoiceID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for an Invoice
        RequestEmpty requestEmpty = {}; // RequestEmpty | 
        try {
            apiInstance.emailInvoice(xeroTenantId, invoiceID, requestEmpty);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#emailInvoice");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *invoiceID = 00000000-0000-0000-0000-000000000000; // Unique identifier for an Invoice (default to null)
RequestEmpty *requestEmpty = {}; // 

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

// Sends a copy of a specific invoice to related contact via email
[apiInstance emailInvoiceWith:xeroTenantId
    invoiceID:invoiceID
    requestEmpty:requestEmpty
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);
const requestEmpty: RequestEmpty = {};  // {RequestEmpty} 
const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const invoiceID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for an Invoice


try {
  const response = await xero.accountingApi.emailInvoice(xeroTenantId, invoiceID, requestEmpty);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var invoiceID = new UUID(); // UUID | Unique identifier for an Invoice (default to null)
            var requestEmpty = new RequestEmpty(); // RequestEmpty | 

            try
            {
                // Sends a copy of a specific invoice to related contact via email
                apiInstance.emailInvoice(xeroTenantId, invoiceID, requestEmpty);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.emailInvoice: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$invoiceID = "00000000-0000-0000-0000-000000000000";

$requestEmpty = new XeroAPI\XeroPHP\Models\Accounting\RequestEmpty;

try {
  $apiInstance->emailInvoice($xeroTenantId, $invoiceID, $requestEmpty);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->emailInvoice: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $invoiceID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for an Invoice
my $requestEmpty = ::Object::RequestEmpty->new(); # RequestEmpty | 

eval { 
    $api_instance->emailInvoice(xeroTenantId => $xeroTenantId, invoiceID => $invoiceID, requestEmpty => $requestEmpty);
};
if ($@) {
    warn "Exception when calling AccountingApi->emailInvoice: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_email_invoice():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    invoiceID = '00000000-0000-0000-0000-000000000000'

    requestEmpty = RequestEmpty()
    
    try:
        api_instance.email_invoice(xeroTenantId, invoiceID, requestEmpty)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->emailInvoice: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let invoiceID = 00000000-0000-0000-0000-000000000000; // UUID
    let requestEmpty = {}; // RequestEmpty

    let mut context = AccountingApi::Context::default();
    let result = client.emailInvoice(xeroTenantId, invoiceID, requestEmpty, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID accountID = UUID.fromString("00000000-0000-0000-0000-000000000000");

        try {
            Accounts result = apiInstance.getAccount(accessToken, xeroTenantId, accountID);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#getAccount");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID accountID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for retrieving single object
        try {
            Accounts result = apiInstance.getAccount(xeroTenantId, accountID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#getAccount");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *accountID = 00000000-0000-0000-0000-000000000000; // Unique identifier for retrieving single object (default to null)

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

// Retrieves a single chart of accounts by using a unique account Id
[apiInstance getAccountWith:xeroTenantId
    accountID:accountID
              completionHandler: ^(Accounts output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const accountID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for retrieving single object

try {
  const response = await xero.accountingApi.getAccount(xeroTenantId, accountID);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var accountID = new UUID(); // UUID | Unique identifier for retrieving single object (default to null)

            try
            {
                // Retrieves a single chart of accounts by using a unique account Id
                Accounts result = apiInstance.getAccount(xeroTenantId, accountID);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.getAccount: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$accountID = "00000000-0000-0000-0000-000000000000";

try {
  $result = $apiInstance->getAccount($xeroTenantId, $accountID);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->getAccount: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $accountID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for retrieving single object

eval { 
    my $result = $api_instance->getAccount(xeroTenantId => $xeroTenantId, accountID => $accountID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->getAccount: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_get_account():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    accountID = '00000000-0000-0000-0000-000000000000'
    
    try:
        api_response = api_instance.get_account(xeroTenantId, accountID)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->getAccount: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let accountID = 00000000-0000-0000-0000-000000000000; // UUID

    let mut context = AccountingApi::Context::default();
    let result = client.getAccount(xeroTenantId, accountID, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID accountID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        String fileName = "xero-dev.jpg";
        String contentType = "image/jpg";

        try {
            ByteArrayInputStream result = apiInstance.getAccountAttachmentByFileName(accessToken, xeroTenantId, accountID, fileName, contentType);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#getAccountAttachmentByFileName");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID accountID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for Account object
        String fileName = xero-dev.jpg; // String | Name of the attachment
        String contentType = image/jpg; // String | The mime type of the attachment file you are retrieving i.e image/jpg, application/pdf
        try {
            File result = apiInstance.getAccountAttachmentByFileName(xeroTenantId, accountID, fileName, contentType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#getAccountAttachmentByFileName");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *accountID = 00000000-0000-0000-0000-000000000000; // Unique identifier for Account object (default to null)
String *fileName = xero-dev.jpg; // Name of the attachment (default to null)
String *contentType = image/jpg; // The mime type of the attachment file you are retrieving i.e image/jpg, application/pdf (default to null)

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

// Retrieves an attachment for a specific account by filename
[apiInstance getAccountAttachmentByFileNameWith:xeroTenantId
    accountID:accountID
    fileName:fileName
    contentType:contentType
              completionHandler: ^(File output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const accountID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for Account object
const fileName = "xero-dev.jpg";  // {String} Name of the attachment
const contentType = "image/jpg";  // {String} The mime type of the attachment file you are retrieving i.e image/jpg, application/pdf

try {
  const response = await xero.accountingApi.getAccountAttachmentByFileName(xeroTenantId, accountID, fileName, contentType);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var accountID = new UUID(); // UUID | Unique identifier for Account object (default to null)
            var fileName = xero-dev.jpg;  // String | Name of the attachment (default to null)
            var contentType = image/jpg;  // String | The mime type of the attachment file you are retrieving i.e image/jpg, application/pdf (default to null)

            try
            {
                // Retrieves an attachment for a specific account by filename
                File result = apiInstance.getAccountAttachmentByFileName(xeroTenantId, accountID, fileName, contentType);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.getAccountAttachmentByFileName: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$accountID = "00000000-0000-0000-0000-000000000000";
$fileName = "xero-dev.jpg";
$contentType = "image/jpg";

try {
  $result = $apiInstance->getAccountAttachmentByFileName($xeroTenantId, $accountID, $fileName, $contentType);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->getAccountAttachmentByFileName: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $accountID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for Account object
my $fileName = xero-dev.jpg; # String | Name of the attachment
my $contentType = image/jpg; # String | The mime type of the attachment file you are retrieving i.e image/jpg, application/pdf

eval { 
    my $result = $api_instance->getAccountAttachmentByFileName(xeroTenantId => $xeroTenantId, accountID => $accountID, fileName => $fileName, contentType => $contentType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->getAccountAttachmentByFileName: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_get_account_attachment_by_file_name():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    accountID = '00000000-0000-0000-0000-000000000000'
    fileName = 'xero-dev.jpg'
    contentType = 'image/jpg'
    
    try:
        api_response = api_instance.get_account_attachment_by_file_name(xeroTenantId, accountID, fileName, contentType)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->getAccountAttachmentByFileName: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let accountID = 00000000-0000-0000-0000-000000000000; // UUID
    let fileName = xero-dev.jpg; // String
    let contentType = image/jpg; // String

    let mut context = AccountingApi::Context::default();
    let result = client.getAccountAttachmentByFileName(xeroTenantId, accountID, fileName, contentType, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID accountID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID attachmentID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        String contentType = "image/jpg";

        try {
            ByteArrayInputStream result = apiInstance.getAccountAttachmentById(accessToken, xeroTenantId, accountID, attachmentID, contentType);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#getAccountAttachmentById");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID accountID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for Account object
        UUID attachmentID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for Attachment object
        String contentType = image/jpg; // String | The mime type of the attachment file you are retrieving i.e image/jpg, application/pdf
        try {
            File result = apiInstance.getAccountAttachmentById(xeroTenantId, accountID, attachmentID, contentType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#getAccountAttachmentById");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *accountID = 00000000-0000-0000-0000-000000000000; // Unique identifier for Account object (default to null)
UUID *attachmentID = 00000000-0000-0000-0000-000000000000; // Unique identifier for Attachment object (default to null)
String *contentType = image/jpg; // The mime type of the attachment file you are retrieving i.e image/jpg, application/pdf (default to null)

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

// Retrieves a specific attachment from a specific account using a unique attachment Id
[apiInstance getAccountAttachmentByIdWith:xeroTenantId
    accountID:accountID
    attachmentID:attachmentID
    contentType:contentType
              completionHandler: ^(File output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const accountID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for Account object
const attachmentID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for Attachment object
const contentType = "image/jpg";  // {String} The mime type of the attachment file you are retrieving i.e image/jpg, application/pdf

try {
  const response = await xero.accountingApi.getAccountAttachmentById(xeroTenantId, accountID, attachmentID, contentType);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var accountID = new UUID(); // UUID | Unique identifier for Account object (default to null)
            var attachmentID = new UUID(); // UUID | Unique identifier for Attachment object (default to null)
            var contentType = image/jpg;  // String | The mime type of the attachment file you are retrieving i.e image/jpg, application/pdf (default to null)

            try
            {
                // Retrieves a specific attachment from a specific account using a unique attachment Id
                File result = apiInstance.getAccountAttachmentById(xeroTenantId, accountID, attachmentID, contentType);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.getAccountAttachmentById: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$accountID = "00000000-0000-0000-0000-000000000000";
$attachmentID = "00000000-0000-0000-0000-000000000000";
$contentType = "image/jpg";

try {
  $result = $apiInstance->getAccountAttachmentById($xeroTenantId, $accountID, $attachmentID, $contentType);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->getAccountAttachmentById: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $accountID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for Account object
my $attachmentID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for Attachment object
my $contentType = image/jpg; # String | The mime type of the attachment file you are retrieving i.e image/jpg, application/pdf

eval { 
    my $result = $api_instance->getAccountAttachmentById(xeroTenantId => $xeroTenantId, accountID => $accountID, attachmentID => $attachmentID, contentType => $contentType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->getAccountAttachmentById: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_get_account_attachment_by_id():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    accountID = '00000000-0000-0000-0000-000000000000'
    attachmentID = '00000000-0000-0000-0000-000000000000'
    contentType = 'image/jpg'
    
    try:
        api_response = api_instance.get_account_attachment_by_id(xeroTenantId, accountID, attachmentID, contentType)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->getAccountAttachmentById: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let accountID = 00000000-0000-0000-0000-000000000000; // UUID
    let attachmentID = 00000000-0000-0000-0000-000000000000; // UUID
    let contentType = image/jpg; // String

    let mut context = AccountingApi::Context::default();
    let result = client.getAccountAttachmentById(xeroTenantId, accountID, attachmentID, contentType, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID accountID = UUID.fromString("00000000-0000-0000-0000-000000000000");

        try {
            Attachments result = apiInstance.getAccountAttachments(accessToken, xeroTenantId, accountID);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#getAccountAttachments");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID accountID = 00000000-0000-0000-0000-000000000000; // UUID | Unique identifier for Account object
        try {
            Attachments result = apiInstance.getAccountAttachments(xeroTenantId, accountID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#getAccountAttachments");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *accountID = 00000000-0000-0000-0000-000000000000; // Unique identifier for Account object (default to null)

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

// Retrieves attachments for a specific accounts by using a unique account Id
[apiInstance getAccountAttachmentsWith:xeroTenantId
    accountID:accountID
              completionHandler: ^(Attachments output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const accountID = "00000000-0000-0000-0000-000000000000";  // {UUID} Unique identifier for Account object

try {
  const response = await xero.accountingApi.getAccountAttachments(xeroTenantId, accountID);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var accountID = new UUID(); // UUID | Unique identifier for Account object (default to null)

            try
            {
                // Retrieves attachments for a specific accounts by using a unique account Id
                Attachments result = apiInstance.getAccountAttachments(xeroTenantId, accountID);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.getAccountAttachments: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$accountID = "00000000-0000-0000-0000-000000000000";

try {
  $result = $apiInstance->getAccountAttachments($xeroTenantId, $accountID);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->getAccountAttachments: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $accountID = 00000000-0000-0000-0000-000000000000; # UUID | Unique identifier for Account object

eval { 
    my $result = $api_instance->getAccountAttachments(xeroTenantId => $xeroTenantId, accountID => $accountID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->getAccountAttachments: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_get_account_attachments():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    accountID = '00000000-0000-0000-0000-000000000000'
    
    try:
        api_response = api_instance.get_account_attachments(xeroTenantId, accountID)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->getAccountAttachments: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let accountID = 00000000-0000-0000-0000-000000000000; // UUID

    let mut context = AccountingApi::Context::default();
    let result = client.getAccountAttachments(xeroTenantId, accountID, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        OffsetDateTime ifModifiedSince = OffsetDateTime.parse("2020-02-06T12:17:43.202-08:00");
        String where = "Status=="ACTIVE" AND Type=="BANK"";
        String order = "Name ASC";

        try {
            Accounts result = apiInstance.getAccounts(accessToken, xeroTenantId, ifModifiedSince, where, order);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#getAccounts");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        Date ifModifiedSince = 2020-02-06T12:17:43.202-08:00; // Date | Only records created or modified since this timestamp will be returned
        String where = Status=="ACTIVE" AND Type=="BANK"; // String | Filter by an any element
        String order = Name ASC; // String | Order by an any element
        try {
            Accounts result = apiInstance.getAccounts(xeroTenantId, ifModifiedSince, where, order);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#getAccounts");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
Date *ifModifiedSince = 2020-02-06T12:17:43.202-08:00; // Only records created or modified since this timestamp will be returned (optional) (default to null)
String *where = Status=="ACTIVE" AND Type=="BANK"; // Filter by an any element (optional) (default to null)
String *order = Name ASC; // Order by an any element (optional) (default to null)

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

// Retrieves the full chart of accounts
[apiInstance getAccountsWith:xeroTenantId
    ifModifiedSince:ifModifiedSince
    where:where
    order:order
              completionHandler: ^(Accounts output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant

const ifModifiedSince: Date = new Date("2020-02-06T12:17:43.202-08:00");
const where = 'Status=="ACTIVE" AND Type=="BANK"';  // {String} Filter by an any element

const order = 'Name ASC';  // {String} Order by an any element


try {
  const response = await xero.accountingApi.getAccounts(xeroTenantId, ifModifiedSince, where, order);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var ifModifiedSince = 2020-02-06T12:17:43.202-08:00;  // Date | Only records created or modified since this timestamp will be returned (optional)  (default to null)
            var where = Status=="ACTIVE" AND Type=="BANK";  // String | Filter by an any element (optional)  (default to null)
            var order = Name ASC;  // String | Order by an any element (optional)  (default to null)

            try
            {
                // Retrieves the full chart of accounts
                Accounts result = apiInstance.getAccounts(xeroTenantId, ifModifiedSince, where, order);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.getAccounts: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$ifModifiedSince = new DateTime("2020-02-06T12:17:43.202-08:00");
$where = "Status=="' . \XeroAPI\XeroPHP\Models\Accounting\Account::STATUS_ACTIVE . '"";
$order = "Name ASC";

try {
  $result = $apiInstance->getAccounts($xeroTenantId, $ifModifiedSince, $where, $order);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->getAccounts: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $ifModifiedSince = 2020-02-06T12:17:43.202-08:00; # Date | Only records created or modified since this timestamp will be returned
my $where = Status=="ACTIVE" AND Type=="BANK"; # String | Filter by an any element
my $order = Name ASC; # String | Order by an any element

eval { 
    my $result = $api_instance->getAccounts(xeroTenantId => $xeroTenantId, ifModifiedSince => $ifModifiedSince, where => $where, order => $order);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->getAccounts: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_get_accounts():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    ifModifiedSince = dateutil.parser.parse("2020-02-06T12:17:43.202-08:00")
    where = 'Status=="ACTIVE" AND Type=="BANK"'
    order = 'Name ASC'
    
    try:
        api_response = api_instance.get_accounts(xeroTenantId, ifModifiedSince, where, order)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->getAccounts: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let ifModifiedSince = 2020-02-06T12:17:43.202-08:00; // Date
    let where = Status=="ACTIVE" AND Type=="BANK"; // String
    let order = Name ASC; // String

    let mut context = AccountingApi::Context::default();
    let result = client.getAccounts(xeroTenantId, ifModifiedSince, where, order, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID bankTransactionID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        Integer unitdp = 4;

        try {
            BankTransactions result = apiInstance.getBankTransaction(accessToken, xeroTenantId, bankTransactionID, unitdp);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#getBankTransaction");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID bankTransactionID = 00000000-0000-0000-0000-000000000000; // UUID | Xero generated unique identifier for a bank transaction
        Integer unitdp = 4; // Integer | e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts
        try {
            BankTransactions result = apiInstance.getBankTransaction(xeroTenantId, bankTransactionID, unitdp);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#getBankTransaction");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *bankTransactionID = 00000000-0000-0000-0000-000000000000; // Xero generated unique identifier for a bank transaction (default to null)
Integer *unitdp = 4; // e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts (optional) (default to null)

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

// Retrieves a single spent or received money transaction by using a unique bank transaction Id
[apiInstance getBankTransactionWith:xeroTenantId
    bankTransactionID:bankTransactionID
    unitdp:unitdp
              completionHandler: ^(BankTransactions output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const bankTransactionID = "00000000-0000-0000-0000-000000000000";  // {UUID} Xero generated unique identifier for a bank transaction

const unitdp = 4;  // {Integer} e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts


try {
  const response = await xero.accountingApi.getBankTransaction(xeroTenantId, bankTransactionID,  unitdp);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var bankTransactionID = new UUID(); // UUID | Xero generated unique identifier for a bank transaction (default to null)
            var unitdp = 4;  // Integer | e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts (optional)  (default to null)

            try
            {
                // Retrieves a single spent or received money transaction by using a unique bank transaction Id
                BankTransactions result = apiInstance.getBankTransaction(xeroTenantId, bankTransactionID, unitdp);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.getBankTransaction: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$bankTransactionID = "00000000-0000-0000-0000-000000000000";
$unitdp = 4;

try {
  $result = $apiInstance->getBankTransaction($xeroTenantId, $bankTransactionID, $unitdp);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->getBankTransaction: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $bankTransactionID = 00000000-0000-0000-0000-000000000000; # UUID | Xero generated unique identifier for a bank transaction
my $unitdp = 4; # Integer | e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts

eval { 
    my $result = $api_instance->getBankTransaction(xeroTenantId => $xeroTenantId, bankTransactionID => $bankTransactionID, unitdp => $unitdp);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->getBankTransaction: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_get_bank_transaction():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    bankTransactionID = '00000000-0000-0000-0000-000000000000'
    
    try:
        api_response = api_instance.get_bank_transaction(xeroTenantId, bankTransactionID, unitdp)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->getBankTransaction: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let bankTransactionID = 00000000-0000-0000-0000-000000000000; // UUID
    let unitdp = 4; // Integer

    let mut context = AccountingApi::Context::default();
    let result = client.getBankTransaction(xeroTenantId, bankTransactionID, unitdp, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID bankTransactionID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        String fileName = "xero-dev.jpg";
        String contentType = "image/jpg";

        try {
            ByteArrayInputStream result = apiInstance.getBankTransactionAttachmentByFileName(accessToken, xeroTenantId, bankTransactionID, fileName, contentType);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#getBankTransactionAttachmentByFileName");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID bankTransactionID = 00000000-0000-0000-0000-000000000000; // UUID | Xero generated unique identifier for a bank transaction
        String fileName = xero-dev.jpg; // String | The name of the file being attached
        String contentType = image/jpg; // String | The mime type of the attachment file you are retrieving i.e image/jpg, application/pdf
        try {
            File result = apiInstance.getBankTransactionAttachmentByFileName(xeroTenantId, bankTransactionID, fileName, contentType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#getBankTransactionAttachmentByFileName");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *bankTransactionID = 00000000-0000-0000-0000-000000000000; // Xero generated unique identifier for a bank transaction (default to null)
String *fileName = xero-dev.jpg; // The name of the file being attached (default to null)
String *contentType = image/jpg; // The mime type of the attachment file you are retrieving i.e image/jpg, application/pdf (default to null)

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

// Retrieves a specific attachment from a specific bank transaction by filename
[apiInstance getBankTransactionAttachmentByFileNameWith:xeroTenantId
    bankTransactionID:bankTransactionID
    fileName:fileName
    contentType:contentType
              completionHandler: ^(File output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const bankTransactionID = "00000000-0000-0000-0000-000000000000";  // {UUID} Xero generated unique identifier for a bank transaction
const fileName = "xero-dev.jpg";  // {String} The name of the file being attached
const contentType = "image/jpg";  // {String} The mime type of the attachment file you are retrieving i.e image/jpg, application/pdf

try {
  const response = await xero.accountingApi.getBankTransactionAttachmentByFileName(xeroTenantId, bankTransactionID, fileName, contentType);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var bankTransactionID = new UUID(); // UUID | Xero generated unique identifier for a bank transaction (default to null)
            var fileName = xero-dev.jpg;  // String | The name of the file being attached (default to null)
            var contentType = image/jpg;  // String | The mime type of the attachment file you are retrieving i.e image/jpg, application/pdf (default to null)

            try
            {
                // Retrieves a specific attachment from a specific bank transaction by filename
                File result = apiInstance.getBankTransactionAttachmentByFileName(xeroTenantId, bankTransactionID, fileName, contentType);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.getBankTransactionAttachmentByFileName: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$bankTransactionID = "00000000-0000-0000-0000-000000000000";
$fileName = "xero-dev.jpg";
$contentType = "image/jpg";

try {
  $result = $apiInstance->getBankTransactionAttachmentByFileName($xeroTenantId, $bankTransactionID, $fileName, $contentType);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->getBankTransactionAttachmentByFileName: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $bankTransactionID = 00000000-0000-0000-0000-000000000000; # UUID | Xero generated unique identifier for a bank transaction
my $fileName = xero-dev.jpg; # String | The name of the file being attached
my $contentType = image/jpg; # String | The mime type of the attachment file you are retrieving i.e image/jpg, application/pdf

eval { 
    my $result = $api_instance->getBankTransactionAttachmentByFileName(xeroTenantId => $xeroTenantId, bankTransactionID => $bankTransactionID, fileName => $fileName, contentType => $contentType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->getBankTransactionAttachmentByFileName: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_get_bank_transaction_attachment_by_file_name():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    bankTransactionID = '00000000-0000-0000-0000-000000000000'
    fileName = 'xero-dev.jpg'
    contentType = 'image/jpg'
    
    try:
        api_response = api_instance.get_bank_transaction_attachment_by_file_name(xeroTenantId, bankTransactionID, fileName, contentType)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->getBankTransactionAttachmentByFileName: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let bankTransactionID = 00000000-0000-0000-0000-000000000000; // UUID
    let fileName = xero-dev.jpg; // String
    let contentType = image/jpg; // String

    let mut context = AccountingApi::Context::default();
    let result = client.getBankTransactionAttachmentByFileName(xeroTenantId, bankTransactionID, fileName, contentType, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID bankTransactionID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID attachmentID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        String contentType = "image/jpg";

        try {
            ByteArrayInputStream result = apiInstance.getBankTransactionAttachmentById(accessToken, xeroTenantId, bankTransactionID, attachmentID, contentType);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#getBankTransactionAttachmentById");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID bankTransactionID = 00000000-0000-0000-0000-000000000000; // UUID | Xero generated unique identifier for a bank transaction
        UUID attachmentID = 00000000-0000-0000-0000-000000000000; // UUID | Xero generated unique identifier for an attachment
        String contentType = image/jpg; // String | The mime type of the attachment file you are retrieving i.e image/jpg, application/pdf
        try {
            File result = apiInstance.getBankTransactionAttachmentById(xeroTenantId, bankTransactionID, attachmentID, contentType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#getBankTransactionAttachmentById");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *bankTransactionID = 00000000-0000-0000-0000-000000000000; // Xero generated unique identifier for a bank transaction (default to null)
UUID *attachmentID = 00000000-0000-0000-0000-000000000000; // Xero generated unique identifier for an attachment (default to null)
String *contentType = image/jpg; // The mime type of the attachment file you are retrieving i.e image/jpg, application/pdf (default to null)

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

// Retrieves specific attachments from a specific BankTransaction using a unique attachment Id
[apiInstance getBankTransactionAttachmentByIdWith:xeroTenantId
    bankTransactionID:bankTransactionID
    attachmentID:attachmentID
    contentType:contentType
              completionHandler: ^(File output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const bankTransactionID = "00000000-0000-0000-0000-000000000000";  // {UUID} Xero generated unique identifier for a bank transaction
const attachmentID = "00000000-0000-0000-0000-000000000000";  // {UUID} Xero generated unique identifier for an attachment
const contentType = "image/jpg";  // {String} The mime type of the attachment file you are retrieving i.e image/jpg, application/pdf

try {
  const response = await xero.accountingApi.getBankTransactionAttachmentById(xeroTenantId, bankTransactionID, attachmentID, contentType);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var bankTransactionID = new UUID(); // UUID | Xero generated unique identifier for a bank transaction (default to null)
            var attachmentID = new UUID(); // UUID | Xero generated unique identifier for an attachment (default to null)
            var contentType = image/jpg;  // String | The mime type of the attachment file you are retrieving i.e image/jpg, application/pdf (default to null)

            try
            {
                // Retrieves specific attachments from a specific BankTransaction using a unique attachment Id
                File result = apiInstance.getBankTransactionAttachmentById(xeroTenantId, bankTransactionID, attachmentID, contentType);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.getBankTransactionAttachmentById: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$bankTransactionID = "00000000-0000-0000-0000-000000000000";
$attachmentID = "00000000-0000-0000-0000-000000000000";
$contentType = "image/jpg";

try {
  $result = $apiInstance->getBankTransactionAttachmentById($xeroTenantId, $bankTransactionID, $attachmentID, $contentType);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->getBankTransactionAttachmentById: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $bankTransactionID = 00000000-0000-0000-0000-000000000000; # UUID | Xero generated unique identifier for a bank transaction
my $attachmentID = 00000000-0000-0000-0000-000000000000; # UUID | Xero generated unique identifier for an attachment
my $contentType = image/jpg; # String | The mime type of the attachment file you are retrieving i.e image/jpg, application/pdf

eval { 
    my $result = $api_instance->getBankTransactionAttachmentById(xeroTenantId => $xeroTenantId, bankTransactionID => $bankTransactionID, attachmentID => $attachmentID, contentType => $contentType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->getBankTransactionAttachmentById: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_get_bank_transaction_attachment_by_id():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    bankTransactionID = '00000000-0000-0000-0000-000000000000'
    attachmentID = '00000000-0000-0000-0000-000000000000'
    contentType = 'image/jpg'
    
    try:
        api_response = api_instance.get_bank_transaction_attachment_by_id(xeroTenantId, bankTransactionID, attachmentID, contentType)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->getBankTransactionAttachmentById: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let bankTransactionID = 00000000-0000-0000-0000-000000000000; // UUID
    let attachmentID = 00000000-0000-0000-0000-000000000000; // UUID
    let contentType = image/jpg; // String

    let mut context = AccountingApi::Context::default();
    let result = client.getBankTransactionAttachmentById(xeroTenantId, bankTransactionID, attachmentID, contentType, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID bankTransactionID = UUID.fromString("00000000-0000-0000-0000-000000000000");

        try {
            Attachments result = apiInstance.getBankTransactionAttachments(accessToken, xeroTenantId, bankTransactionID);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#getBankTransactionAttachments");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID bankTransactionID = 00000000-0000-0000-0000-000000000000; // UUID | Xero generated unique identifier for a bank transaction
        try {
            Attachments result = apiInstance.getBankTransactionAttachments(xeroTenantId, bankTransactionID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#getBankTransactionAttachments");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *bankTransactionID = 00000000-0000-0000-0000-000000000000; // Xero generated unique identifier for a bank transaction (default to null)

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

// Retrieves any attachments from a specific bank transactions
[apiInstance getBankTransactionAttachmentsWith:xeroTenantId
    bankTransactionID:bankTransactionID
              completionHandler: ^(Attachments output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const bankTransactionID = "00000000-0000-0000-0000-000000000000";  // {UUID} Xero generated unique identifier for a bank transaction

try {
  const response = await xero.accountingApi.getBankTransactionAttachments(xeroTenantId, bankTransactionID);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var bankTransactionID = new UUID(); // UUID | Xero generated unique identifier for a bank transaction (default to null)

            try
            {
                // Retrieves any attachments from a specific bank transactions
                Attachments result = apiInstance.getBankTransactionAttachments(xeroTenantId, bankTransactionID);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.getBankTransactionAttachments: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$bankTransactionID = "00000000-0000-0000-0000-000000000000";

try {
  $result = $apiInstance->getBankTransactionAttachments($xeroTenantId, $bankTransactionID);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->getBankTransactionAttachments: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $bankTransactionID = 00000000-0000-0000-0000-000000000000; # UUID | Xero generated unique identifier for a bank transaction

eval { 
    my $result = $api_instance->getBankTransactionAttachments(xeroTenantId => $xeroTenantId, bankTransactionID => $bankTransactionID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->getBankTransactionAttachments: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_get_bank_transaction_attachments():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    bankTransactionID = '00000000-0000-0000-0000-000000000000'
    
    try:
        api_response = api_instance.get_bank_transaction_attachments(xeroTenantId, bankTransactionID)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->getBankTransactionAttachments: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let bankTransactionID = 00000000-0000-0000-0000-000000000000; // UUID

    let mut context = AccountingApi::Context::default();
    let result = client.getBankTransactionAttachments(xeroTenantId, bankTransactionID, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        OffsetDateTime ifModifiedSince = OffsetDateTime.parse("2020-02-06T12:17:43.202-08:00");
        String where = "Status=="AUTHORISED"";
        String order = "Type ASC";
        Integer page = 1;
        Integer unitdp = 4;

        try {
            BankTransactions result = apiInstance.getBankTransactions(accessToken, xeroTenantId, ifModifiedSince, where, order, page, unitdp);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#getBankTransactions");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        Date ifModifiedSince = 2020-02-06T12:17:43.202-08:00; // Date | Only records created or modified since this timestamp will be returned
        String where = Status=="AUTHORISED"; // String | Filter by an any element
        String order = Type ASC; // String | Order by an any element
        Integer page = 1; // Integer | Up to 100 bank transactions will be returned in a single API call with line items details
        Integer unitdp = 4; // Integer | e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts
        try {
            BankTransactions result = apiInstance.getBankTransactions(xeroTenantId, ifModifiedSince, where, order, page, unitdp);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#getBankTransactions");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
Date *ifModifiedSince = 2020-02-06T12:17:43.202-08:00; // Only records created or modified since this timestamp will be returned (optional) (default to null)
String *where = Status=="AUTHORISED"; // Filter by an any element (optional) (default to null)
String *order = Type ASC; // Order by an any element (optional) (default to null)
Integer *page = 1; // Up to 100 bank transactions will be returned in a single API call with line items details (optional) (default to null)
Integer *unitdp = 4; // e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts (optional) (default to null)

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

// Retrieves any spent or received money transactions
[apiInstance getBankTransactionsWith:xeroTenantId
    ifModifiedSince:ifModifiedSince
    where:where
    order:order
    page:page
    unitdp:unitdp
              completionHandler: ^(BankTransactions output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant

const ifModifiedSince: Date = new Date("2020-02-06T12:17:43.202-08:00");
const where = 'Status=="AUTHORISED"';  // {String} Filter by an any element

const order = 'Type ASC';  // {String} Order by an any element

const page = 1;  // {Integer} Up to 100 bank transactions will be returned in a single API call with line items details

const unitdp = 4;  // {Integer} e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts


try {
  const response = await xero.accountingApi.getBankTransactions(xeroTenantId, ifModifiedSince, where, order, page, unitdp);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var ifModifiedSince = 2020-02-06T12:17:43.202-08:00;  // Date | Only records created or modified since this timestamp will be returned (optional)  (default to null)
            var where = Status=="AUTHORISED";  // String | Filter by an any element (optional)  (default to null)
            var order = Type ASC;  // String | Order by an any element (optional)  (default to null)
            var page = 1;  // Integer | Up to 100 bank transactions will be returned in a single API call with line items details (optional)  (default to null)
            var unitdp = 4;  // Integer | e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts (optional)  (default to null)

            try
            {
                // Retrieves any spent or received money transactions
                BankTransactions result = apiInstance.getBankTransactions(xeroTenantId, ifModifiedSince, where, order, page, unitdp);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.getBankTransactions: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$ifModifiedSince = new DateTime("2020-02-06T12:17:43.202-08:00");
$where = "Status=="' . XeroAPI\XeroPHP\Models\Accounting\BankTransaction::STATUS_AUTHORISED . '"";
$order = "Type ASC";
$page = 1;
$unitdp = 4;

try {
  $result = $apiInstance->getBankTransactions($xeroTenantId, $ifModifiedSince, $where, $order, $page, $unitdp);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->getBankTransactions: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $ifModifiedSince = 2020-02-06T12:17:43.202-08:00; # Date | Only records created or modified since this timestamp will be returned
my $where = Status=="AUTHORISED"; # String | Filter by an any element
my $order = Type ASC; # String | Order by an any element
my $page = 1; # Integer | Up to 100 bank transactions will be returned in a single API call with line items details
my $unitdp = 4; # Integer | e.g. unitdp=4 – (Unit Decimal Places) You can opt in to use four decimal places for unit amounts

eval { 
    my $result = $api_instance->getBankTransactions(xeroTenantId => $xeroTenantId, ifModifiedSince => $ifModifiedSince, where => $where, order => $order, page => $page, unitdp => $unitdp);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->getBankTransactions: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_get_bank_transactions():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    ifModifiedSince = dateutil.parser.parse("2020-02-06T12:17:43.202-08:00")
    where = 'Status=="AUTHORISED"'
    order = 'Type ASC'
    
    try:
        api_response = api_instance.get_bank_transactions(xeroTenantId, ifModifiedSince, where, order, page, unitdp)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->getBankTransactions: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let ifModifiedSince = 2020-02-06T12:17:43.202-08:00; // Date
    let where = Status=="AUTHORISED"; // String
    let order = Type ASC; // String
    let page = 1; // Integer
    let unitdp = 4; // Integer

    let mut context = AccountingApi::Context::default();
    let result = client.getBankTransactions(xeroTenantId, ifModifiedSince, where, order, page, unitdp, &context).wait();
    println!("{:?}", result);

}

import org.openapitools.client.api.*;
import org.openapitools.client.api.client.AccountingApi;
import org.openapitools.client.models.accounting.*;

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

public class AccountingApiExample {
    private AccountingApi apiInstance;
    
    public static void main(String[] args) {
        String accessToken = "YOUR_ACCESS_TOKEN";
        // Init AccountingApi client
        ApiClient defaultClient = new ApiClient();

        // Get Singleton - instance of accounting client
        apiInstance = AccountingApi.getInstance(defaultClient);	
        
        String xeroTenantId = "YOUR_XERO_TENANT_ID";
        UUID bankTransactionID = UUID.fromString("00000000-0000-0000-0000-000000000000");

        try {
            HistoryRecords result = apiInstance.getBankTransactionsHistory(accessToken, xeroTenantId, bankTransactionID);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#getBankTransactionsHistory");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.AccountingApi;

public class AccountingApiExample {

    public static void main(String[] args) {
        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID bankTransactionID = 00000000-0000-0000-0000-000000000000; // UUID | Xero generated unique identifier for a bank transaction
        try {
            HistoryRecords result = apiInstance.getBankTransactionsHistory(xeroTenantId, bankTransactionID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AccountingApi#getBankTransactionsHistory");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

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

String *xeroTenantId = YOUR_XERO_TENANT_ID; // Xero identifier for Tenant (default to null)
UUID *bankTransactionID = 00000000-0000-0000-0000-000000000000; // Xero generated unique identifier for a bank transaction (default to null)

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

// Retrieves history from a specific bank transaction using a unique bank transaction Id
[apiInstance getBankTransactionsHistoryWith:xeroTenantId
    bankTransactionID:bankTransactionID
              completionHandler: ^(HistoryRecords output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

const tokenSet: TokenSet =  {
  id_token: 'xxx',
  access_token: 'yyy',
  expires_at: 1582308862,
  token_type: 'Bearer',
  refresh_token: 'zzz',
  session_state: 'xxx'
}
await xero.setTokenSet(tokenSet);

const xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant
const bankTransactionID = "00000000-0000-0000-0000-000000000000";  // {UUID} Xero generated unique identifier for a bank transaction

try {
  const response = await xero.accountingApi.getBankTransactionsHistory(xeroTenantId, bankTransactionID);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  const error = JSON.stringify(err.response.body, null, 2)
  console.log(`Status Code: ${err.response.statusCode} => ${error}`);
}

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

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

            var apiInstance = new AccountingApi();
            var xeroTenantId = YOUR_XERO_TENANT_ID;  // String | Xero identifier for Tenant (default to null)
            var bankTransactionID = new UUID(); // UUID | Xero generated unique identifier for a bank transaction (default to null)

            try
            {
                // Retrieves history from a specific bank transaction using a unique bank transaction Id
                HistoryRecords result = apiInstance.getBankTransactionsHistory(xeroTenantId, bankTransactionID);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AccountingApi.getBankTransactionsHistory: " + e.Message );
            }
        }
    }
}

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

// Configure OAuth2 access token for authorization: OAuth2
$config = XeroAPI\XeroPHP\Configuration::getDefaultConfiguration()->setAccessToken( 'YOUR_ACCESS_TOKEN' );       

$apiInstance = new XeroAPI\XeroPHP\Api\AccountingApi(
    new GuzzleHttp\Client(),
    $config
);
$xeroTenantId = "YOUR_XERO_TENANT_ID";
$bankTransactionID = "00000000-0000-0000-0000-000000000000";

try {
  $result = $apiInstance->getBankTransactionsHistory($xeroTenantId, $bankTransactionID);
} catch (Exception $e) {
  echo 'Exception when calling AccountingApi->getBankTransactionsHistory: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use ::Configuration;
use ::AccountingApi;

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

my $api_instance = ::AccountingApi->new();
my $xeroTenantId = YOUR_XERO_TENANT_ID; # String | Xero identifier for Tenant
my $bankTransactionID = 00000000-0000-0000-0000-000000000000; # UUID | Xero generated unique identifier for a bank transaction

eval { 
    my $result = $api_instance->getBankTransactionsHistory(xeroTenantId => $xeroTenantId, bankTransactionID => $bankTransactionID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AccountingApi->getBankTransactionsHistory: $@\n";
}

# configure api_client for use with xero-python sdk client
api_client = ApiClient(
    Configuration(
        debug=false,
        oauth2_token=OAuth2Token(
            client_id="YOUR_CLIENT_ID", client_secret="YOUR_CLIENT_SECRET"
        ),
    ),
    pool_threads=1,
)

api_client.set_oauth2_token("YOUR_ACCESS_TOKEN")

def accounting_get_bank_transactions_history():
    api_instance = AccountingApi(api_client)
    xeroTenantId = 'YOUR_XERO_TENANT_ID'
    bankTransactionID = '00000000-0000-0000-0000-000000000000'
    
    try:
        api_response = api_instance.get_bank_transactions_history(xeroTenantId, bankTransactionID)
        print(api_response)
    except AccountingBadRequestException as e:
        print("Exception when calling AccountingApi->getBankTransactionsHistory: %s\n" % e)

extern crate AccountingApi;

pub fn main() {
    let xeroTenantId = YOUR_XERO_TENANT_ID; // String
    let bankTransactionID = 00000000-0000-0000-0000-000000000000; // UUID

    let mut context = AccountingApi::Context::default();
    let result = client.getBankTransactionsHistory(xeroTenantId, bankTransactionID, &context).wait();
    println!("{:?}", result);

}