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

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        Account account = { code: "123456", name: "Foobar", type: AccountType.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();
        }
    }
}

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: AccountType.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: AccountType.EXPENSE, description: "Hello World" }; // 

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

// Allows you to create 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" };  // {Account} 
try {
  const response: any = await xero.accountingApi.createAccount(xeroTenantId, account);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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
            {
                // Allows you to create 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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
    $account = new XeroAPI\XeroPHP\Models\Accounting\Account;
    $account->setCode("987654321");
    $account->setName("FooBar");
    $account->setType("EXPENSE");
    $account->setDescription("Hello World");
    $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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
account = { code: "123456", name: "Foobar", type: AccountType.EXPENSE, description: "Hello World" } # Account | 

try: 
    # Allows you to create a new chart of accounts
    api_response = api_instance.create_account(xeroTenantId, account)
    pprint(api_response)
except ApiException 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: AccountType.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.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountingApi;

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID accountID = 00000000-0000-0000-000-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();
        }
    }
}

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-000-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-000-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];

// Allows you to create Attachment on 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-000-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

// You'll need to add the import below to read 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: any = await xero.accountingApi.createAccountAttachmentByFileName(xeroTenantId, accountID, fileName, body, {
    headers: {
      "Content-Type": contentType,
    }
  });
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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
            {
                // Allows you to create Attachment on 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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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-000-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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
accountID = 00000000-0000-0000-000-000000000000 # UUID | Unique identifier for Account object (default to null)
fileName = xero-dev.jpg # String | Name of the attachment (default to null)
body = BYTE_ARRAY_DATA_HERE # byte[] | 

try: 
    # Allows you to create Attachment on Account
    api_response = api_instance.create_account_attachment_by_file_name(xeroTenantId, accountID, fileName, body)
    pprint(api_response)
except ApiException 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-000-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.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountingApi;

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID bankTransactionID = 00000000-0000-0000-000-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();
        }
    }
}

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-000-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-000-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];

// Allows you to createa an Attachment on BankTransaction 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-000-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

// You'll need to add the import below to read 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: any = await xero.accountingApi.createBankTransactionAttachmentByFileName(xeroTenantId, bankTransactionID, fileName, body, {
    headers: {
      "Content-Type": contentType,
    }
  });
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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
            {
                // Allows you to createa an Attachment on BankTransaction 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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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-000-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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
bankTransactionID = 00000000-0000-0000-000-000000000000 # UUID | Xero generated unique identifier for a bank transaction (default to null)
fileName = xero-dev.jpg # String | The name of the file being attached (default to null)
body = BYTE_ARRAY_DATA_HERE # byte[] | 

try: 
    # Allows you to createa an Attachment on BankTransaction by Filename
    api_response = api_instance.create_bank_transaction_attachment_by_file_name(xeroTenantId, bankTransactionID, fileName, body)
    pprint(api_response)
except ApiException 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-000-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.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountingApi;

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID bankTransactionID = 00000000-0000-0000-000-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();
        }
    }
}

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-000-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-000-000000000000; // Xero generated unique identifier for a bank transaction (default to null)
HistoryRecords *historyRecords = { historyRecords:[ { details :"Hello World" } ] }; // 

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

// Allows you to create history record for a 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 xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant 
const bankTransactionID = "00000000-0000-0000-000-000000000000";  // {UUID} Xero generated unique identifier for a bank transaction 
const historyRecords:HistoryRecords = { historyRecords:[ { details :"Hello World" } ] };  // {HistoryRecords} 
try {
  const response: any = await xero.accountingApi.createBankTransactionHistoryRecord(xeroTenantId, bankTransactionID, historyRecords);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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
            {
                // Allows you to create history record for a 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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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-000-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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
bankTransactionID = 00000000-0000-0000-000-000000000000 # UUID | Xero generated unique identifier for a bank transaction (default to null)
historyRecords = { historyRecords:[ { details :"Hello World" } ] } # HistoryRecords | 

try: 
    # Allows you to create history record for a bank transactions
    api_response = api_instance.create_bank_transaction_history_record(xeroTenantId, bankTransactionID, historyRecords)
    pprint(api_response)
except ApiException 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-000-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.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountingApi;

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

public class AccountingApiExample {

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

        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-000-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 obejcts 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();
        }
    }
}

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-000-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 obejcts 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-000-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 obejcts 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];

// Allows you to create one or more spend or receive 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 bankTransactions:BankTransactions = { bankTransactions:[ { type: BankTransaction.TypeEnum.SPEND, contact: { contactID:"00000000-0000-0000-000-000000000000" }, lineItems:[ { description:"Foobar", quantity: 1.0, unitAmount:20.0, accountCode:"000" } ], bankAccount:{ code:"000" } } ] };  // {BankTransactions} 
const summarizeErrors =  true;  // {Boolean} If false return 200 OK and mix of successfully created obejcts 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

try {
  const response: any = await xero.accountingApi.createBankTransactions(xeroTenantId, bankTransactions,  summarizeErrors, unitdp);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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 obejcts 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
            {
                // Allows you to create one or more spend or receive 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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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 obejcts 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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
bankTransactions = { bankTransactions:[ { type: BankTransaction.TypeEnum.SPEND, contact: { contactID:"00000000-0000-0000-000-000000000000" }, lineItems:[ { description:"Foobar", quantity: 1.0, unitAmount:20.0, accountCode:"000" } ], bankAccount:{ code:"000" } } ] } # BankTransactions | 
summarizeErrors = true # Boolean | If false return 200 OK and mix of successfully created obejcts and any with validation errors (optional) (default to false)
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: 
    # Allows you to create one or more spend or receive money transaction
    api_response = api_instance.create_bank_transactions(xeroTenantId, bankTransactions, summarizeErrors=summarizeErrors, unitdp=unitdp)
    pprint(api_response)
except ApiException 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-000-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.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountingApi;

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        BankTransfers bankTransfers = { bankTransfers:[ { fromBankAccount: { code:"000", accountID:"00000000-0000-0000-000-000000000000"}, toBankAccount:{ code:"001", accountID:"00000000-0000-0000-000-000000000000"}, 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();
        }
    }
}

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:"000", accountID:"00000000-0000-0000-000-000000000000"}, toBankAccount:{ code:"001", accountID:"00000000-0000-0000-000-000000000000"}, 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:"000", accountID:"00000000-0000-0000-000-000000000000"}, toBankAccount:{ code:"001", accountID:"00000000-0000-0000-000-000000000000"}, amount:"50.00" } ] }; // 

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

// Allows you to create a bank transfers
[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-000-000000000000"}, toBankAccount:{ code:"001", accountID:"00000000-0000-0000-000-000000000000"}, amount:"50.00" } ] };  // {BankTransfers} 
try {
  const response: any = await xero.accountingApi.createBankTransfer(xeroTenantId, bankTransfers);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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
            {
                // Allows you to create a bank transfers
                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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
bankTransfers = { bankTransfers:[ { fromBankAccount: { code:"000", accountID:"00000000-0000-0000-000-000000000000"}, toBankAccount:{ code:"001", accountID:"00000000-0000-0000-000-000000000000"}, amount:"50.00" } ] } # BankTransfers | 

try: 
    # Allows you to create a bank transfers
    api_response = api_instance.create_bank_transfer(xeroTenantId, bankTransfers)
    pprint(api_response)
except ApiException 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:"000", accountID:"00000000-0000-0000-000-000000000000"}, toBankAccount:{ code:"001", accountID:"00000000-0000-0000-000-000000000000"}, amount:"50.00" } ] }; // BankTransfers

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

}

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

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID bankTransferID = 00000000-0000-0000-000-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();
        }
    }
}

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-000-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-000-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-000-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

// You'll need to add the import below to read 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: any = await xero.accountingApi.createBankTransferAttachmentByFileName(xeroTenantId, bankTransferID, fileName, body, {
    headers: {
      "Content-Type": contentType,
    }
  });
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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-000-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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
bankTransferID = 00000000-0000-0000-000-000000000000 # UUID | Xero generated unique identifier for a bank transfer (default to null)
fileName = xero-dev.jpg # String | The name of the file being attached to a Bank Transfer (default to null)
body = BYTE_ARRAY_DATA_HERE # byte[] | 

try: 
    # 
    api_response = api_instance.create_bank_transfer_attachment_by_file_name(xeroTenantId, bankTransferID, fileName, body)
    pprint(api_response)
except ApiException 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-000-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.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountingApi;

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID bankTransferID = 00000000-0000-0000-000-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();
        }
    }
}

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-000-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-000-000000000000; // Xero generated unique identifier for a bank transfer (default to null)
HistoryRecords *historyRecords = { historyRecords:[ { details :"Hello World" } ] }; // 

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

// 
[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 xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant 
const bankTransferID = "00000000-0000-0000-000-000000000000";  // {UUID} Xero generated unique identifier for a bank transfer 
const historyRecords:HistoryRecords = { historyRecords:[ { details :"Hello World" } ] };  // {HistoryRecords} 
try {
  const response: any = await xero.accountingApi.createBankTransferHistoryRecord(xeroTenantId, bankTransferID, historyRecords);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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
            {
                // 
                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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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-000-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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
bankTransferID = 00000000-0000-0000-000-000000000000 # UUID | Xero generated unique identifier for a bank transfer (default to null)
historyRecords = { historyRecords:[ { details :"Hello World" } ] } # HistoryRecords | 

try: 
    # 
    api_response = api_instance.create_bank_transfer_history_record(xeroTenantId, bankTransferID, historyRecords)
    pprint(api_response)
except ApiException 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-000-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.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountingApi;

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        BatchPayments batchPayments = { batchPayments: [ { account: { accountID: "00000000-0000-0000-000-000000000000" }, reference: "ref", date: "2018-08-01", payments: [ { account: { code: "001" }, date: "2019-12-31", amount: 500, invoice: { invoiceID: "00000000-0000-0000-000-000000000000", lineItems: [], contact: {}, type: Invoice.TypeEnum.ACCPAY } } ] } ] }; // BatchPayments | 
        Boolean summarizeErrors = true; // Boolean | If false return 200 OK and mix of successfully created obejcts 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();
        }
    }
}

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-000-000000000000" }, reference: "ref", date: "2018-08-01", payments: [ { account: { code: "001" }, date: "2019-12-31", amount: 500, invoice: { invoiceID: "00000000-0000-0000-000-000000000000", lineItems: [], contact: {}, type: Invoice.TypeEnum.ACCPAY } } ] } ] }; // BatchPayments | 
        Boolean summarizeErrors = true; // Boolean | If false return 200 OK and mix of successfully created obejcts 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-000-000000000000" }, reference: "ref", date: "2018-08-01", payments: [ { account: { code: "001" }, date: "2019-12-31", amount: 500, invoice: { invoiceID: "00000000-0000-0000-000-000000000000", lineItems: [], contact: {}, type: Invoice.TypeEnum.ACCPAY } } ] } ] }; // 
Boolean *summarizeErrors = true; // If false return 200 OK and mix of successfully created obejcts and any with validation errors (optional) (default to false)

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

// Create one or many BatchPayments 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 batchPayments:BatchPayments = { batchPayments: [ { account: { accountID: "00000000-0000-0000-000-000000000000" }, reference: "ref", date: "2018-08-01", payments: [ { account: { code: "001" }, date: "2019-12-31", amount: 500, invoice: { invoiceID: "00000000-0000-0000-000-000000000000", lineItems: [], contact: {}, type: Invoice.TypeEnum.ACCPAY } } ] } ] };  // {BatchPayments} 
const summarizeErrors =  true;  // {Boolean} If false return 200 OK and mix of successfully created obejcts and any with validation errors

try {
  const response: any = await xero.accountingApi.createBatchPayment(xeroTenantId, batchPayments,  summarizeErrors);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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 obejcts and any with validation errors (optional)  (default to false)

            try
            {
                // Create one or many BatchPayments 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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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 obejcts 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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
batchPayments = { batchPayments: [ { account: { accountID: "00000000-0000-0000-000-000000000000" }, reference: "ref", date: "2018-08-01", payments: [ { account: { code: "001" }, date: "2019-12-31", amount: 500, invoice: { invoiceID: "00000000-0000-0000-000-000000000000", lineItems: [], contact: {}, type: Invoice.TypeEnum.ACCPAY } } ] } ] } # BatchPayments | 
summarizeErrors = true # Boolean | If false return 200 OK and mix of successfully created obejcts and any with validation errors (optional) (default to false)

try: 
    # Create one or many BatchPayments for invoices
    api_response = api_instance.create_batch_payment(xeroTenantId, batchPayments, summarizeErrors=summarizeErrors)
    pprint(api_response)
except ApiException 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-000-000000000000" }, reference: "ref", date: "2018-08-01", payments: [ { account: { code: "001" }, date: "2019-12-31", amount: 500, invoice: { invoiceID: "00000000-0000-0000-000-000000000000", lineItems: [], contact: {}, type: Invoice.TypeEnum.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.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountingApi;

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID batchPaymentID = 00000000-0000-0000-000-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();
        }
    }
}

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-000-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-000-000000000000; // Unique identifier for BatchPayment (default to null)
HistoryRecords *historyRecords = { historyRecords:[ { details :"Hello World" } ] }; // 

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

// Allows you to create a history record for a 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 xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant 
const batchPaymentID = "00000000-0000-0000-000-000000000000";  // {UUID} Unique identifier for BatchPayment 
const historyRecords:HistoryRecords = { historyRecords:[ { details :"Hello World" } ] };  // {HistoryRecords} 
try {
  const response: any = await xero.accountingApi.createBatchPaymentHistoryRecord(xeroTenantId, batchPaymentID, historyRecords);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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
            {
                // Allows you to create a history record for a 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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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-000-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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
batchPaymentID = 00000000-0000-0000-000-000000000000 # UUID | Unique identifier for BatchPayment (default to null)
historyRecords = { historyRecords:[ { details :"Hello World" } ] } # HistoryRecords | 

try: 
    # Allows you to create a history record for a Batch Payment
    api_response = api_instance.create_batch_payment_history_record(xeroTenantId, batchPaymentID, historyRecords)
    pprint(api_response)
except ApiException 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-000-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.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountingApi;

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID brandingThemeID = 00000000-0000-0000-000-000000000000; // UUID | Unique identifier for a Branding Theme
        PaymentService paymentService = { paymentServiceID:"dede7858-14e3-4a46-bf95-4d4cc491e645", 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();
        }
    }
}

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-000-000000000000; // UUID | Unique identifier for a Branding Theme
        PaymentService paymentService = { paymentServiceID:"dede7858-14e3-4a46-bf95-4d4cc491e645", 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-000-000000000000; // Unique identifier for a Branding Theme (default to null)
PaymentService *paymentService = { paymentServiceID:"dede7858-14e3-4a46-bf95-4d4cc491e645", paymentServiceName:"ACME Payments", paymentServiceUrl:"https://www.payupnow.com/", payNowText:"Pay Now" }; // 

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

// Allow for the creation of new custom payment service for specified 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-000-000000000000";  // {UUID} Unique identifier for a Branding Theme 
const paymentService:PaymentService = { paymentServiceID:"dede7858-14e3-4a46-bf95-4d4cc491e645", paymentServiceName:"ACME Payments", paymentServiceUrl:"https://www.payupnow.com/", payNowText:"Pay Now" };  // {PaymentService} 
try {
  const response: any = await xero.accountingApi.createBrandingThemePaymentServices(xeroTenantId, brandingThemeID, paymentService);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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
            {
                // Allow for the creation of new custom payment service for specified 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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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-000-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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
brandingThemeID = 00000000-0000-0000-000-000000000000 # UUID | Unique identifier for a Branding Theme (default to null)
paymentService = { paymentServiceID:"dede7858-14e3-4a46-bf95-4d4cc491e645", paymentServiceName:"ACME Payments", paymentServiceUrl:"https://www.payupnow.com/", payNowText:"Pay Now" } # PaymentService | 

try: 
    # Allow for the creation of new custom payment service for specified Branding Theme
    api_response = api_instance.create_branding_theme_payment_services(xeroTenantId, brandingThemeID, paymentService)
    pprint(api_response)
except ApiException 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-000-000000000000; // UUID
    let paymentService = { paymentServiceID:"dede7858-14e3-4a46-bf95-4d4cc491e645", 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.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountingApi;

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID contactID = 00000000-0000-0000-000-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();
        }
    }
}

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-000-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-000-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-000-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

// You'll need to add the import below to read 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: any = await xero.accountingApi.createContactAttachmentByFileName(xeroTenantId, contactID, fileName, body, {
    headers: {
      "Content-Type": contentType,
    }
  });
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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-000-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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
contactID = 00000000-0000-0000-000-000000000000 # UUID | Unique identifier for a Contact (default to null)
fileName = xero-dev.jpg # String | Name for the file you are attaching (default to null)
body = BYTE_ARRAY_DATA_HERE # byte[] | 

try: 
    # 
    api_response = api_instance.create_contact_attachment_by_file_name(xeroTenantId, contactID, fileName, body)
    pprint(api_response)
except ApiException 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-000-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.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountingApi;

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

public class AccountingApiExample {

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

        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();
        }
    }
}

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];

// Allows you to create 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" } ] };  // {ContactGroups} 
try {
  const response: any = await xero.accountingApi.createContactGroup(xeroTenantId, contactGroups);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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
            {
                // Allows you to create 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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
contactGroups = { contactGroups:[ { name:"VIPs" } ] } # ContactGroups | 

try: 
    # Allows you to create a contact group
    api_response = api_instance.create_contact_group(xeroTenantId, contactGroups)
    pprint(api_response)
except ApiException 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.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountingApi;

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID contactGroupID = 00000000-0000-0000-000-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();
        }
    }
}

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-000-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-000-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];

// Allows you to add Contacts to a Contract 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-000-000000000000";  // {UUID} Unique identifier for a Contact Group 
const contacts:Contacts = { contacts:[ { contactID:"a3675fc4-f8dd-4f03-ba5b-f1870566bcd7" }, { contactID:"4e1753b9-018a-4775-b6aa-1bc7871cfee3" } ] };  // {Contacts} 
try {
  const response: any = await xero.accountingApi.createContactGroupContacts(xeroTenantId, contactGroupID, contacts);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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
            {
                // Allows you to add Contacts to a Contract 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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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-000-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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
contactGroupID = 00000000-0000-0000-000-000000000000 # UUID | Unique identifier for a Contact Group (default to null)
contacts = { contacts:[ { contactID:"a3675fc4-f8dd-4f03-ba5b-f1870566bcd7" }, { contactID:"4e1753b9-018a-4775-b6aa-1bc7871cfee3" } ] } # Contacts | 

try: 
    # Allows you to add Contacts to a Contract Group
    api_response = api_instance.create_contact_group_contacts(xeroTenantId, contactGroupID, contacts)
    pprint(api_response)
except ApiException 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-000-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.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountingApi;

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID contactID = 00000000-0000-0000-000-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();
        }
    }
}

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-000-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-000-000000000000; // Unique identifier for a Contact (default to null)
HistoryRecords *historyRecords = { historyRecords:[ { details :"Hello World" } ] }; // 

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

// Allows you to retrieve a history records of an 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 xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant 
const contactID = "00000000-0000-0000-000-000000000000";  // {UUID} Unique identifier for a Contact 
const historyRecords:HistoryRecords = { historyRecords:[ { details :"Hello World" } ] };  // {HistoryRecords} 
try {
  const response: any = await xero.accountingApi.createContactHistory(xeroTenantId, contactID, historyRecords);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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
            {
                // Allows you to retrieve a history records of an 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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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-000-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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
contactID = 00000000-0000-0000-000-000000000000 # UUID | Unique identifier for a Contact (default to null)
historyRecords = { historyRecords:[ { details :"Hello World" } ] } # HistoryRecords | 

try: 
    # Allows you to retrieve a history records of an Contact
    api_response = api_instance.create_contact_history(xeroTenantId, contactID, historyRecords)
    pprint(api_response)
except ApiException 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-000-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.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountingApi;

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        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 } } } ] }; // Contacts | 
        Boolean summarizeErrors = true; // Boolean | If false return 200 OK and mix of successfully created obejcts 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();
        }
    }
}

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 = {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 } } } ] }; // Contacts | 
        Boolean summarizeErrors = true; // Boolean | If false return 200 OK and mix of successfully created obejcts 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 = {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 } } } ] }; // 
Boolean *summarizeErrors = true; // If false return 200 OK and mix of successfully created obejcts and any with validation errors (optional) (default to false)

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

// Allows you to create a 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 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 } } } ] };  // {Contacts} 
const summarizeErrors =  true;  // {Boolean} If false return 200 OK and mix of successfully created obejcts and any with validation errors

try {
  const response: any = await xero.accountingApi.createContacts(xeroTenantId, contacts,  summarizeErrors);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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 obejcts and any with validation errors (optional)  (default to false)

            try
            {
                // Allows you to create a 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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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 obejcts 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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
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 } } } ] } # Contacts | 
summarizeErrors = true # Boolean | If false return 200 OK and mix of successfully created obejcts and any with validation errors (optional) (default to false)

try: 
    # Allows you to create a multiple contacts (bulk) in a Xero organisation
    api_response = api_instance.create_contacts(xeroTenantId, contacts, summarizeErrors=summarizeErrors)
    pprint(api_response)
except ApiException 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 = {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 } } } ] }; // 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.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountingApi;

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID creditNoteID = 00000000-0000-0000-000-000000000000; // UUID | Unique identifier for a Credit Note
        Allocations allocations = { allocations:[ { amount:1.0, date:"2019-03-05", invoice:{ invoiceID:"c45720a1-ade3-4a38-a064-d15489be6841", lineItems:[], type: Invoice.TypeEnum.ACCPAY, contact:{} } } ] }; // Allocations | 
        try {
            Allocations result = apiInstance.createCreditNoteAllocation(xeroTenantId, creditNoteID, allocations);
            System.out.println(result);
        } catch (ApiException 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-000-000000000000; // UUID | Unique identifier for a Credit Note
        Allocations allocations = { allocations:[ { amount:1.0, date:"2019-03-05", invoice:{ invoiceID:"c45720a1-ade3-4a38-a064-d15489be6841", lineItems:[], type: Invoice.TypeEnum.ACCPAY, contact:{} } } ] }; // Allocations | 
        try {
            Allocations result = apiInstance.createCreditNoteAllocation(xeroTenantId, creditNoteID, allocations);
            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-000-000000000000; // Unique identifier for a Credit Note (default to null)
Allocations *allocations = { allocations:[ { amount:1.0, date:"2019-03-05", invoice:{ invoiceID:"c45720a1-ade3-4a38-a064-d15489be6841", lineItems:[], type: Invoice.TypeEnum.ACCPAY, contact:{} } } ] }; // 

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

// Allows you to create Allocation on CreditNote
[apiInstance createCreditNoteAllocationWith:xeroTenantId
    creditNoteID:creditNoteID
    allocations:allocations
              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-000-000000000000";  // {UUID} Unique identifier for a Credit Note 
const allocations:Allocations = { allocations:[ { amount:1.0, date:"2019-03-05", invoice:{ invoiceID:"c45720a1-ade3-4a38-a064-d15489be6841", lineItems:[], type: Invoice.TypeEnum.ACCPAY, contact:{} } } ] };  // {Allocations} 
try {
  const response: any = await xero.accountingApi.createCreditNoteAllocation(xeroTenantId, creditNoteID, allocations);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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 | 

            try
            {
                // Allows you to create Allocation on CreditNote
                Allocations result = apiInstance.createCreditNoteAllocation(xeroTenantId, creditNoteID, allocations);
                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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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-000-000000000000; # UUID | Unique identifier for a Credit Note
my $allocations = ::Object::Allocations->new(); # Allocations | 

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

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
creditNoteID = 00000000-0000-0000-000-000000000000 # UUID | Unique identifier for a Credit Note (default to null)
allocations = { allocations:[ { amount:1.0, date:"2019-03-05", invoice:{ invoiceID:"c45720a1-ade3-4a38-a064-d15489be6841", lineItems:[], type: Invoice.TypeEnum.ACCPAY, contact:{} } } ] } # Allocations | 

try: 
    # Allows you to create Allocation on CreditNote
    api_response = api_instance.create_credit_note_allocation(xeroTenantId, creditNoteID, allocations)
    pprint(api_response)
except ApiException 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-000-000000000000; // UUID
    let allocations = { allocations:[ { amount:1.0, date:"2019-03-05", invoice:{ invoiceID:"c45720a1-ade3-4a38-a064-d15489be6841", lineItems:[], type: Invoice.TypeEnum.ACCPAY, contact:{} } } ] }; // Allocations

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

}

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

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID creditNoteID = 00000000-0000-0000-000-000000000000; // UUID | Unique identifier for a Credit Note
        String fileName = xero-dev.jpg; // String | Name of the file you are attaching to Credit Note
        Boolean includeOnline = true; // Boolean | Set an attachment to be included with the invoice when viewed online (through Xero)
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 
        try {
            Attachments result = apiInstance.createCreditNoteAttachmentByFileName(xeroTenantId, creditNoteID, fileName, includeOnline, body);
            System.out.println(result);
        } catch (ApiException 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-000-000000000000; // UUID | Unique identifier for a Credit Note
        String fileName = xero-dev.jpg; // String | Name of the file you are attaching to Credit Note
        Boolean includeOnline = true; // Boolean | Set an attachment to be included with the invoice when viewed online (through Xero)
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 
        try {
            Attachments result = apiInstance.createCreditNoteAttachmentByFileName(xeroTenantId, creditNoteID, fileName, includeOnline, body);
            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-000-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)
Boolean *includeOnline = true; // Set an attachment to be included with the invoice when viewed online (through Xero) (default to null)
byte[] *body = BYTE_ARRAY_DATA_HERE; // 

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

// Allows you to create Attachments on CreditNote by file name
[apiInstance createCreditNoteAttachmentByFileNameWith:xeroTenantId
    creditNoteID:creditNoteID
    fileName:fileName
    includeOnline:includeOnline
    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 creditNoteID = "00000000-0000-0000-000-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 includeOnline = true;  // {Boolean} Set an attachment to be included with the invoice when viewed online (through Xero) 
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

// You'll need to add the import below to read 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: any = await xero.accountingApi.createCreditNoteAttachmentByFileName(xeroTenantId, creditNoteID, fileName, includeOnline, body, {
    headers: {
      "Content-Type": contentType,
    }
  });
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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 includeOnline = true;  // Boolean | Set an attachment to be included with the invoice when viewed online (through Xero) (default to null)
            var body = BYTE_ARRAY_DATA_HERE;  // byte[] | 

            try
            {
                // Allows you to create Attachments on CreditNote by file name
                Attachments result = apiInstance.createCreditNoteAttachmentByFileName(xeroTenantId, creditNoteID, fileName, includeOnline, body);
                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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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-000-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 $includeOnline = true; # Boolean | Set an attachment to be included with the invoice when viewed online (through Xero)
my $body = ::Object::byte[]->new(); # byte[] | 

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

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
creditNoteID = 00000000-0000-0000-000-000000000000 # UUID | Unique identifier for a Credit Note (default to null)
fileName = xero-dev.jpg # String | Name of the file you are attaching to Credit Note (default to null)
includeOnline = true # Boolean | Set an attachment to be included with the invoice when viewed online (through Xero) (default to null)
body = BYTE_ARRAY_DATA_HERE # byte[] | 

try: 
    # Allows you to create Attachments on CreditNote by file name
    api_response = api_instance.create_credit_note_attachment_by_file_name(xeroTenantId, creditNoteID, fileName, includeOnline, body)
    pprint(api_response)
except ApiException 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-000-000000000000; // UUID
    let fileName = xero-dev.jpg; // String
    let includeOnline = true; // Boolean
    let body = BYTE_ARRAY_DATA_HERE; // byte[]

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

}

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

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID creditNoteID = 00000000-0000-0000-000-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();
        }
    }
}

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-000-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-000-000000000000; // Unique identifier for a Credit Note (default to null)
HistoryRecords *historyRecords = { historyRecords:[ { details :"Hello World" } ] }; // 

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

// Allows you to retrieve a history records of an CreditNote
[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 xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant 
const creditNoteID = "00000000-0000-0000-000-000000000000";  // {UUID} Unique identifier for a Credit Note 
const historyRecords:HistoryRecords = { historyRecords:[ { details :"Hello World" } ] };  // {HistoryRecords} 
try {
  const response: any = await xero.accountingApi.createCreditNoteHistory(xeroTenantId, creditNoteID, historyRecords);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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
            {
                // Allows you to retrieve a history records of an CreditNote
                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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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-000-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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
creditNoteID = 00000000-0000-0000-000-000000000000 # UUID | Unique identifier for a Credit Note (default to null)
historyRecords = { historyRecords:[ { details :"Hello World" } ] } # HistoryRecords | 

try: 
    # Allows you to retrieve a history records of an CreditNote
    api_response = api_instance.create_credit_note_history(xeroTenantId, creditNoteID, historyRecords)
    pprint(api_response)
except ApiException 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-000-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.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountingApi;

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        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" } ] } ] }; // CreditNotes | 
        Boolean summarizeErrors = true; // Boolean | If false return 200 OK and mix of successfully created obejcts 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();
        }
    }
}

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: 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" } ] } ] }; // CreditNotes | 
        Boolean summarizeErrors = true; // Boolean | If false return 200 OK and mix of successfully created obejcts 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: 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" } ] } ] }; // 
Boolean *summarizeErrors = true; // If false return 200 OK and mix of successfully created obejcts 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];

// Allows you to create a 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 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" } ] } ] };  // {CreditNotes} 
const summarizeErrors =  true;  // {Boolean} If false return 200 OK and mix of successfully created obejcts 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

try {
  const response: any = await xero.accountingApi.createCreditNotes(xeroTenantId, creditNotes,  summarizeErrors, unitdp);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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 obejcts 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
            {
                // Allows you to create a 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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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 obejcts 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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
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" } ] } ] } # CreditNotes | 
summarizeErrors = true # Boolean | If false return 200 OK and mix of successfully created obejcts and any with validation errors (optional) (default to false)
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: 
    # Allows you to create a credit note
    api_response = api_instance.create_credit_notes(xeroTenantId, creditNotes, summarizeErrors=summarizeErrors, unitdp=unitdp)
    pprint(api_response)
except ApiException 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: 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" } ] } ] }; // 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.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountingApi;

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        Currency currency = { code: CurrencyCode.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();
        }
    }
}

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: CurrencyCode.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: CurrencyCode.USD, description:"United States Dollar" }; // 

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

// 
[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" };  // {Currency} 
try {
  const response: any = await xero.accountingApi.createCurrency(xeroTenantId, currency);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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
            {
                // 
                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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
currency = { code: CurrencyCode.USD, description:"United States Dollar" } # Currency | 

try: 
    # 
    api_response = api_instance.create_currency(xeroTenantId, currency)
    pprint(api_response)
except ApiException 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: CurrencyCode.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.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountingApi;

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

public class AccountingApiExample {

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

        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 obejcts 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();
        }
    }
}

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 obejcts 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 obejcts and any with validation errors (optional) (default to false)

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

// Allows you to create 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 employees:Employees = { employees:[ { firstName:"Nick", lastName:"Fury", externalLink:{ url:"http://twitter.com/#!/search/Nick+Fury" } } ] };  // {Employees} 
const summarizeErrors =  true;  // {Boolean} If false return 200 OK and mix of successfully created obejcts and any with validation errors

try {
  const response: any = await xero.accountingApi.createEmployees(xeroTenantId, employees,  summarizeErrors);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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 obejcts and any with validation errors (optional)  (default to false)

            try
            {
                // Allows you to create 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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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 obejcts 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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
employees = { employees:[ { firstName:"Nick", lastName:"Fury", externalLink:{ url:"http://twitter.com/#!/search/Nick+Fury" } } ] } # Employees | 
summarizeErrors = true # Boolean | If false return 200 OK and mix of successfully created obejcts and any with validation errors (optional) (default to false)

try: 
    # Allows you to create new employees used in Xero payrun
    api_response = api_instance.create_employees(xeroTenantId, employees, summarizeErrors=summarizeErrors)
    pprint(api_response)
except ApiException 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.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountingApi;

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID expenseClaimID = 00000000-0000-0000-000-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();
        }
    }
}

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-000-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-000-000000000000; // Unique identifier for a ExpenseClaim (default to null)
HistoryRecords *historyRecords = { historyRecords:[ { details :"Hello World" } ] }; // 

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

// Allows you to create a history records of an ExpenseClaim
[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 xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant 
const expenseClaimID = "00000000-0000-0000-000-000000000000";  // {UUID} Unique identifier for a ExpenseClaim 
const historyRecords:HistoryRecords = { historyRecords:[ { details :"Hello World" } ] };  // {HistoryRecords} 
try {
  const response: any = await xero.accountingApi.createExpenseClaimHistory(xeroTenantId, expenseClaimID, historyRecords);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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
            {
                // Allows you to create a history records of an ExpenseClaim
                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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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-000-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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
expenseClaimID = 00000000-0000-0000-000-000000000000 # UUID | Unique identifier for a ExpenseClaim (default to null)
historyRecords = { historyRecords:[ { details :"Hello World" } ] } # HistoryRecords | 

try: 
    # Allows you to create a history records of an ExpenseClaim
    api_response = api_instance.create_expense_claim_history(xeroTenantId, expenseClaimID, historyRecords)
    pprint(api_response)
except ApiException 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-000-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.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountingApi;

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        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" } ] } ] }; // 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();
        }
    }
}

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: ExpenseClaim.StatusEnum.SUBMITTED, user:{ userID:"d1164823-0ac1-41ad-987b-b4e30fe0b273" }, receipts:[ { receiptID:"dc1c7f6d-0a4c-402f-acac-551d62ce5816", lineItems:[], contact: {}, user: {}, date: "2018-01-01" } ] } ] }; // 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: ExpenseClaim.StatusEnum.SUBMITTED, user:{ userID:"d1164823-0ac1-41ad-987b-b4e30fe0b273" }, receipts:[ { receiptID:"dc1c7f6d-0a4c-402f-acac-551d62ce5816", lineItems:[], contact: {}, user: {}, date: "2018-01-01" } ] } ] }; // 

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

// Allows you to retrieve 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" } ] } ] };  // {ExpenseClaims} 
try {
  const response: any = await xero.accountingApi.createExpenseClaims(xeroTenantId, expenseClaims);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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
            {
                // Allows you to retrieve 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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
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" } ] } ] } # ExpenseClaims | 

try: 
    # Allows you to retrieve expense claims
    api_response = api_instance.create_expense_claims(xeroTenantId, expenseClaims)
    pprint(api_response)
except ApiException 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: ExpenseClaim.StatusEnum.SUBMITTED, user:{ userID:"d1164823-0ac1-41ad-987b-b4e30fe0b273" }, receipts:[ { receiptID:"dc1c7f6d-0a4c-402f-acac-551d62ce5816", lineItems:[], contact: {}, user: {}, date: "2018-01-01" } ] } ] }; // ExpenseClaims

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

}

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

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID invoiceID = 00000000-0000-0000-000-000000000000; // UUID | Unique identifier for an Invoice
        String fileName = xero-dev.jpg; // String | Name of the file you are attaching
        Boolean includeOnline = true; // Boolean | Set an attachment to be included with the invoice when viewed online (through Xero)
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 
        try {
            Attachments result = apiInstance.createInvoiceAttachmentByFileName(xeroTenantId, invoiceID, fileName, includeOnline, body);
            System.out.println(result);
        } catch (ApiException 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-000-000000000000; // UUID | Unique identifier for an Invoice
        String fileName = xero-dev.jpg; // String | Name of the file you are attaching
        Boolean includeOnline = true; // Boolean | Set an attachment to be included with the invoice when viewed online (through Xero)
        byte[] body = BYTE_ARRAY_DATA_HERE; // byte[] | 
        try {
            Attachments result = apiInstance.createInvoiceAttachmentByFileName(xeroTenantId, invoiceID, fileName, includeOnline, body);
            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-000-000000000000; // Unique identifier for an Invoice (default to null)
String *fileName = xero-dev.jpg; // Name of the file you are attaching (default to null)
Boolean *includeOnline = true; // Set an attachment to be included with the invoice when viewed online (through Xero) (default to null)
byte[] *body = BYTE_ARRAY_DATA_HERE; // 

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

// Allows you to create an Attachment on invoices or purchase bills by it's filename
[apiInstance createInvoiceAttachmentByFileNameWith:xeroTenantId
    invoiceID:invoiceID
    fileName:fileName
    includeOnline:includeOnline
    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 invoiceID = "00000000-0000-0000-000-000000000000";  // {UUID} Unique identifier for an Invoice 
const fileName = "xero-dev.jpg";  // {String} Name of the file you are attaching 
const includeOnline = true;  // {Boolean} Set an attachment to be included with the invoice when viewed online (through Xero) 
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

// You'll need to add the import below to read 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: any = await xero.accountingApi.createInvoiceAttachmentByFileName(xeroTenantId, invoiceID, fileName, includeOnline, body, {
    headers: {
      "Content-Type": contentType,
    }
  });
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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 includeOnline = true;  // Boolean | Set an attachment to be included with the invoice when viewed online (through Xero) (default to null)
            var body = BYTE_ARRAY_DATA_HERE;  // byte[] | 

            try
            {
                // Allows you to create an Attachment on invoices or purchase bills by it's filename
                Attachments result = apiInstance.createInvoiceAttachmentByFileName(xeroTenantId, invoiceID, fileName, includeOnline, body);
                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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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-000-000000000000; # UUID | Unique identifier for an Invoice
my $fileName = xero-dev.jpg; # String | Name of the file you are attaching
my $includeOnline = true; # Boolean | Set an attachment to be included with the invoice when viewed online (through Xero)
my $body = ::Object::byte[]->new(); # byte[] | 

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

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
invoiceID = 00000000-0000-0000-000-000000000000 # UUID | Unique identifier for an Invoice (default to null)
fileName = xero-dev.jpg # String | Name of the file you are attaching (default to null)
includeOnline = true # Boolean | Set an attachment to be included with the invoice when viewed online (through Xero) (default to null)
body = BYTE_ARRAY_DATA_HERE # byte[] | 

try: 
    # Allows you to create an Attachment on invoices or purchase bills by it's filename
    api_response = api_instance.create_invoice_attachment_by_file_name(xeroTenantId, invoiceID, fileName, includeOnline, body)
    pprint(api_response)
except ApiException 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-000-000000000000; // UUID
    let fileName = xero-dev.jpg; // String
    let includeOnline = true; // Boolean
    let body = BYTE_ARRAY_DATA_HERE; // byte[]

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

}

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

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID invoiceID = 00000000-0000-0000-000-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();
        }
    }
}

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-000-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-000-000000000000; // Unique identifier for an Invoice (default to null)
HistoryRecords *historyRecords = { historyRecords:[ { details :"Hello World" } ] }; // 

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

// Allows you to retrieve a history records of an 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 xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant 
const invoiceID = "00000000-0000-0000-000-000000000000";  // {UUID} Unique identifier for an Invoice 
const historyRecords:HistoryRecords = { historyRecords:[ { details :"Hello World" } ] };  // {HistoryRecords} 
try {
  const response: any = await xero.accountingApi.createInvoiceHistory(xeroTenantId, invoiceID, historyRecords);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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
            {
                // Allows you to retrieve a history records of an 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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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-000-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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
invoiceID = 00000000-0000-0000-000-000000000000 # UUID | Unique identifier for an Invoice (default to null)
historyRecords = { historyRecords:[ { details :"Hello World" } ] } # HistoryRecords | 

try: 
    # Allows you to retrieve a history records of an invoice
    api_response = api_instance.create_invoice_history(xeroTenantId, invoiceID, historyRecords)
    pprint(api_response)
except ApiException 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-000-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.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountingApi;

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        Invoices invoices = { invoices:[ { type: Invoice.TypeEnum.ACCREC, contact:{ contactID:"00000000-0000-0000-000-000000000000" }, lineItems:[ { description:"Acme Tires", quantity:2.0, unitAmount:20.0, accountCode:"000", taxType:"NONE", lineAmount:40.0 } ], date:"2019-03-11", dueDate:"2018-12-10", reference:"Website Design", status: Invoice.StatusEnum.DRAFT } ] }; // Invoices | 
        Boolean summarizeErrors = true; // Boolean | If false return 200 OK and mix of successfully created obejcts 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();
        }
    }
}

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: Invoice.TypeEnum.ACCREC, contact:{ contactID:"00000000-0000-0000-000-000000000000" }, lineItems:[ { description:"Acme Tires", quantity:2.0, unitAmount:20.0, accountCode:"000", taxType:"NONE", lineAmount:40.0 } ], date:"2019-03-11", dueDate:"2018-12-10", reference:"Website Design", status: Invoice.StatusEnum.DRAFT } ] }; // Invoices | 
        Boolean summarizeErrors = true; // Boolean | If false return 200 OK and mix of successfully created obejcts 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: Invoice.TypeEnum.ACCREC, contact:{ contactID:"00000000-0000-0000-000-000000000000" }, lineItems:[ { description:"Acme Tires", quantity:2.0, unitAmount:20.0, accountCode:"000", taxType:"NONE", lineAmount:40.0 } ], date:"2019-03-11", dueDate:"2018-12-10", reference:"Website Design", status: Invoice.StatusEnum.DRAFT } ] }; // 
Boolean *summarizeErrors = true; // If false return 200 OK and mix of successfully created obejcts 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];

// Allows you to create 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 invoices:Invoices = { invoices:[ { type: Invoice.TypeEnum.ACCREC, contact:{ contactID:"00000000-0000-0000-000-000000000000" }, lineItems:[ { description:"Acme Tires", quantity:2.0, unitAmount:20.0, accountCode:"000", taxType:"NONE", lineAmount:40.0 } ], date:"2019-03-11", dueDate:"2018-12-10", reference:"Website Design", status: Invoice.StatusEnum.DRAFT } ] };  // {Invoices} 
const summarizeErrors =  true;  // {Boolean} If false return 200 OK and mix of successfully created obejcts 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

try {
  const response: any = await xero.accountingApi.createInvoices(xeroTenantId, invoices,  summarizeErrors, unitdp);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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 obejcts 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
            {
                // Allows you to create 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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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 obejcts 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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
invoices = { invoices:[ { type: Invoice.TypeEnum.ACCREC, contact:{ contactID:"00000000-0000-0000-000-000000000000" }, lineItems:[ { description:"Acme Tires", quantity:2.0, unitAmount:20.0, accountCode:"000", taxType:"NONE", lineAmount:40.0 } ], date:"2019-03-11", dueDate:"2018-12-10", reference:"Website Design", status: Invoice.StatusEnum.DRAFT } ] } # Invoices | 
summarizeErrors = true # Boolean | If false return 200 OK and mix of successfully created obejcts and any with validation errors (optional) (default to false)
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: 
    # Allows you to create one or more sales invoices or purchase bills
    api_response = api_instance.create_invoices(xeroTenantId, invoices, summarizeErrors=summarizeErrors, unitdp=unitdp)
    pprint(api_response)
except ApiException 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: Invoice.TypeEnum.ACCREC, contact:{ contactID:"00000000-0000-0000-000-000000000000" }, lineItems:[ { description:"Acme Tires", quantity:2.0, unitAmount:20.0, accountCode:"000", taxType:"NONE", lineAmount:40.0 } ], date:"2019-03-11", dueDate:"2018-12-10", reference:"Website Design", status: Invoice.StatusEnum.DRAFT } ] }; // 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.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountingApi;

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID itemID = 00000000-0000-0000-000-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();
        }
    }
}

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-000-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-000-000000000000; // Unique identifier for an Item (default to null)
HistoryRecords *historyRecords = { historyRecords:[ { details :"Hello World" } ] }; // 

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

// Allows you to create a history record for items
[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 xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant 
const itemID = "00000000-0000-0000-000-000000000000";  // {UUID} Unique identifier for an Item 
const historyRecords:HistoryRecords = { historyRecords:[ { details :"Hello World" } ] };  // {HistoryRecords} 
try {
  const response: any = await xero.accountingApi.createItemHistory(xeroTenantId, itemID, historyRecords);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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
            {
                // Allows you to create a history record for items
                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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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-000-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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
itemID = 00000000-0000-0000-000-000000000000 # UUID | Unique identifier for an Item (default to null)
historyRecords = { historyRecords:[ { details :"Hello World" } ] } # HistoryRecords | 

try: 
    # Allows you to create a history record for items
    api_response = api_instance.create_item_history(xeroTenantId, itemID, historyRecords)
    pprint(api_response)
except ApiException 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-000-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.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountingApi;

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        Items items = { items:[ { code:"abcXYZ123", name:"HelloWorld11", description:"Foobar", inventoryAssetAccountCode:"140", purchaseDetails: {cOGSAccountCode:"500"} } ] }; // Items | 
        Boolean summarizeErrors = true; // Boolean | If false return 200 OK and mix of successfully created obejcts 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();
        }
    }
}

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:"abcXYZ123", name:"HelloWorld11", description:"Foobar", inventoryAssetAccountCode:"140", purchaseDetails: {cOGSAccountCode:"500"} } ] }; // Items | 
        Boolean summarizeErrors = true; // Boolean | If false return 200 OK and mix of successfully created obejcts 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:"abcXYZ123", name:"HelloWorld11", description:"Foobar", inventoryAssetAccountCode:"140", purchaseDetails: {cOGSAccountCode:"500"} } ] }; // 
Boolean *summarizeErrors = true; // If false return 200 OK and mix of successfully created obejcts 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];

// Allows you to create 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 items:Items = { items:[ { code:"abcXYZ123", name:"HelloWorld11", description:"Foobar", inventoryAssetAccountCode:"140", purchaseDetails: {cOGSAccountCode:"500"} } ] };  // {Items} 
const summarizeErrors =  true;  // {Boolean} If false return 200 OK and mix of successfully created obejcts 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

try {
  const response: any = await xero.accountingApi.createItems(xeroTenantId, items,  summarizeErrors, unitdp);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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 obejcts 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
            {
                // Allows you to create 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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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 obejcts 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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
items = { items:[ { code:"abcXYZ123", name:"HelloWorld11", description:"Foobar", inventoryAssetAccountCode:"140", purchaseDetails: {cOGSAccountCode:"500"} } ] } # Items | 
summarizeErrors = true # Boolean | If false return 200 OK and mix of successfully created obejcts and any with validation errors (optional) (default to false)
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: 
    # Allows you to create one or more items
    api_response = api_instance.create_items(xeroTenantId, items, summarizeErrors=summarizeErrors, unitdp=unitdp)
    pprint(api_response)
except ApiException 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:"abcXYZ123", name:"HelloWorld11", 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.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountingApi;

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        LinkedTransaction linkedTransaction = { sourceTransactionID:"00000000-0000-0000-000-000000000000", sourceLineItemID:"00000000-0000-0000-000-000000000000"}; // 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();
        }
    }
}

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 = { sourceTransactionID:"00000000-0000-0000-000-000000000000", sourceLineItemID:"00000000-0000-0000-000-000000000000"}; // 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 = { sourceTransactionID:"00000000-0000-0000-000-000000000000", sourceLineItemID:"00000000-0000-0000-000-000000000000"}; // 

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

// Allows you to create 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-000-000000000000", sourceLineItemID:"00000000-0000-0000-000-000000000000"};  // {LinkedTransaction} 
try {
  const response: any = await xero.accountingApi.createLinkedTransaction(xeroTenantId, linkedTransaction);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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
            {
                // Allows you to create 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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
linkedTransaction = { sourceTransactionID:"00000000-0000-0000-000-000000000000", sourceLineItemID:"00000000-0000-0000-000-000000000000"} # LinkedTransaction | 

try: 
    # Allows you to create linked transactions (billable expenses)
    api_response = api_instance.create_linked_transaction(xeroTenantId, linkedTransaction)
    pprint(api_response)
except ApiException 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 = { sourceTransactionID:"00000000-0000-0000-000-000000000000", sourceLineItemID:"00000000-0000-0000-000-000000000000"}; // LinkedTransaction

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

}

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

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID manualJournalID = 00000000-0000-0000-000-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();
        }
    }
}

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-000-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-000-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];

// Allows you to create a specified Attachment on ManualJournal 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-000-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

// You'll need to add the import below to read 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: any = await xero.accountingApi.createManualJournalAttachmentByFileName(xeroTenantId, manualJournalID, fileName, body, {
    headers: {
      "Content-Type": contentType,
    }
  });
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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
            {
                // Allows you to create a specified Attachment on ManualJournal 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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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-000-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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
manualJournalID = 00000000-0000-0000-000-000000000000 # UUID | Unique identifier for a ManualJournal (default to null)
fileName = xero-dev.jpg # String | The name of the file being attached to a ManualJournal (default to null)
body = BYTE_ARRAY_DATA_HERE # byte[] | 

try: 
    # Allows you to create a specified Attachment on ManualJournal by file name
    api_response = api_instance.create_manual_journal_attachment_by_file_name(xeroTenantId, manualJournalID, fileName, body)
    pprint(api_response)
except ApiException 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-000-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.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountingApi;

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        ManualJournals manualJournals = { manualJournals:[ { narration:"Foo bar", journalLines:[ { lineAmount:100.0, accountCode:"400", description:"Hello there" }, { lineAmount:-100.0, accountCode:"400", description:"Goodbye", tracking:[ { name:"Simpsons", option:"Bart" } ] } ], date:"2019-03-14" } ] }; // ManualJournals | 
        Boolean summarizeErrors = true; // Boolean | If false return 200 OK and mix of successfully created obejcts 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();
        }
    }
}

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:"Foo bar", journalLines:[ { lineAmount:100.0, accountCode:"400", description:"Hello there" }, { lineAmount:-100.0, accountCode:"400", description:"Goodbye", tracking:[ { name:"Simpsons", option:"Bart" } ] } ], date:"2019-03-14" } ] }; // ManualJournals | 
        Boolean summarizeErrors = true; // Boolean | If false return 200 OK and mix of successfully created obejcts 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:"Foo bar", journalLines:[ { lineAmount:100.0, accountCode:"400", description:"Hello there" }, { lineAmount:-100.0, accountCode:"400", description:"Goodbye", tracking:[ { name:"Simpsons", option:"Bart" } ] } ], date:"2019-03-14" } ] }; // 
Boolean *summarizeErrors = true; // If false return 200 OK and mix of successfully created obejcts and any with validation errors (optional) (default to false)

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

// Allows you to create 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 manualJournals:ManualJournals = { manualJournals:[ { narration:"Foo bar", journalLines:[ { lineAmount:100.0, accountCode:"400", description:"Hello there" }, { lineAmount:-100.0, accountCode:"400", description:"Goodbye", tracking:[ { name:"Simpsons", option:"Bart" } ] } ], date:"2019-03-14" } ] };  // {ManualJournals} 
const summarizeErrors =  true;  // {Boolean} If false return 200 OK and mix of successfully created obejcts and any with validation errors

try {
  const response: any = await xero.accountingApi.createManualJournals(xeroTenantId, manualJournals,  summarizeErrors);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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 obejcts and any with validation errors (optional)  (default to false)

            try
            {
                // Allows you to create 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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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 obejcts 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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
manualJournals = { manualJournals:[ { narration:"Foo bar", journalLines:[ { lineAmount:100.0, accountCode:"400", description:"Hello there" }, { lineAmount:-100.0, accountCode:"400", description:"Goodbye", tracking:[ { name:"Simpsons", option:"Bart" } ] } ], date:"2019-03-14" } ] } # ManualJournals | 
summarizeErrors = true # Boolean | If false return 200 OK and mix of successfully created obejcts and any with validation errors (optional) (default to false)

try: 
    # Allows you to create one or more manual journals
    api_response = api_instance.create_manual_journals(xeroTenantId, manualJournals, summarizeErrors=summarizeErrors)
    pprint(api_response)
except ApiException 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:"Foo bar", journalLines:[ { lineAmount:100.0, accountCode:"400", description:"Hello there" }, { lineAmount:-100.0, accountCode:"400", description:"Goodbye", tracking:[ { name:"Simpsons", option:"Bart" } ] } ], 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.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountingApi;

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID overpaymentID = 00000000-0000-0000-000-000000000000; // UUID | Unique identifier for a Overpayment
        Allocations allocations = { allocations:[ { invoice:{ invoiceID:"00000000-0000-0000-000-000000000000", lineItems:[], contact: {}, type: Invoice.TypeEnum.ACCPAY }, amount:1.0, date:"2019-03-12" } ] }; // Allocations | 
        Boolean summarizeErrors = true; // Boolean | If false return 200 OK and mix of successfully created obejcts 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();
        }
    }
}

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-000-000000000000; // UUID | Unique identifier for a Overpayment
        Allocations allocations = { allocations:[ { invoice:{ invoiceID:"00000000-0000-0000-000-000000000000", lineItems:[], contact: {}, type: Invoice.TypeEnum.ACCPAY }, amount:1.0, date:"2019-03-12" } ] }; // Allocations | 
        Boolean summarizeErrors = true; // Boolean | If false return 200 OK and mix of successfully created obejcts 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-000-000000000000; // Unique identifier for a Overpayment (default to null)
Allocations *allocations = { allocations:[ { invoice:{ invoiceID:"00000000-0000-0000-000-000000000000", lineItems:[], contact: {}, type: Invoice.TypeEnum.ACCPAY }, amount:1.0, date:"2019-03-12" } ] }; // 
Boolean *summarizeErrors = true; // If false return 200 OK and mix of successfully created obejcts and any with validation errors (optional) (default to false)

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

// Allows you to create a single allocation for an 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-000-000000000000";  // {UUID} Unique identifier for a Overpayment 
const allocations:Allocations = { allocations:[ { invoice:{ invoiceID:"00000000-0000-0000-000-000000000000", lineItems:[], contact: {}, type: Invoice.TypeEnum.ACCPAY }, amount:1.0, date:"2019-03-12" } ] };  // {Allocations} 
const summarizeErrors =  true;  // {Boolean} If false return 200 OK and mix of successfully created obejcts and any with validation errors

try {
  const response: any = await xero.accountingApi.createOverpaymentAllocations(xeroTenantId, overpaymentID, allocations,  summarizeErrors);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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 obejcts and any with validation errors (optional)  (default to false)

            try
            {
                // Allows you to create a single allocation for an 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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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-000-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 obejcts 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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
overpaymentID = 00000000-0000-0000-000-000000000000 # UUID | Unique identifier for a Overpayment (default to null)
allocations = { allocations:[ { invoice:{ invoiceID:"00000000-0000-0000-000-000000000000", lineItems:[], contact: {}, type: Invoice.TypeEnum.ACCPAY }, amount:1.0, date:"2019-03-12" } ] } # Allocations | 
summarizeErrors = true # Boolean | If false return 200 OK and mix of successfully created obejcts and any with validation errors (optional) (default to false)

try: 
    # Allows you to create a single allocation for an overpayment
    api_response = api_instance.create_overpayment_allocations(xeroTenantId, overpaymentID, allocations, summarizeErrors=summarizeErrors)
    pprint(api_response)
except ApiException 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-000-000000000000; // UUID
    let allocations = { allocations:[ { invoice:{ invoiceID:"00000000-0000-0000-000-000000000000", lineItems:[], contact: {}, type: Invoice.TypeEnum.ACCPAY }, amount:1.0, 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.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountingApi;

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        UUID overpaymentID = 00000000-0000-0000-000-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();
        }
    }
}

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-000-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-000-000000000000; // Unique identifier for a Overpayment (default to null)
HistoryRecords *historyRecords = { historyRecords:[ { details :"Hello World" } ] }; // 

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

// Allows you to create history records of an 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 xeroTenantId = "YOUR_XERO_TENANT_ID";  // {String} Xero identifier for Tenant 
const overpaymentID = "00000000-0000-0000-000-000000000000";  // {UUID} Unique identifier for a Overpayment 
const historyRecords:HistoryRecords = { historyRecords:[ { details :"Hello World" } ] };  // {HistoryRecords} 
try {
  const response: any = await xero.accountingApi.createOverpaymentHistory(xeroTenantId, overpaymentID, historyRecords);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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
            {
                // Allows you to create history records of an 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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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-000-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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
overpaymentID = 00000000-0000-0000-000-000000000000 # UUID | Unique identifier for a Overpayment (default to null)
historyRecords = { historyRecords:[ { details :"Hello World" } ] } # HistoryRecords | 

try: 
    # Allows you to create history records of an Overpayment
    api_response = api_instance.create_overpayment_history(xeroTenantId, overpaymentID, historyRecords)
    pprint(api_response)
except ApiException 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-000-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.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AccountingApi;

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

public class AccountingApiExample {

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

        AccountingApi apiInstance = new AccountingApi();
        String xeroTenantId = YOUR_XERO_TENANT_ID; // String | Xero identifier for Tenant
        Payment payment = { invoice:{ invoiceID:"00000000-0000-0000-000-000000000000", lineItems:[], contact: {}, type: Invoice.TypeEnum.ACCPAY }, account:{ code:"970" }, date:"2019-03-12", amount:1.0 }; // 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();
        }
    }
}

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 = { invoice:{ invoiceID:"00000000-0000-0000-000-000000000000", lineItems:[], contact: {}, type: Invoice.TypeEnum.ACCPAY }, account:{ code:"970" }, date:"2019-03-12", amount:1.0 }; // 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 = { invoice:{ invoiceID:"00000000-0000-0000-000-000000000000", lineItems:[], contact: {}, type: Invoice.TypeEnum.ACCPAY }, account:{ code:"970" }, date:"2019-03-12", amount:1.0 }; // 

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

// Allows you to create a single payment for invoices 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-000-000000000000", lineItems:[], contact: {}, type: Invoice.TypeEnum.ACCPAY }, account:{ code:"970" }, date:"2019-03-12", amount:1.0 };  // {Payment} 
try {
  const response: any = await xero.accountingApi.createPayment(xeroTenantId, payment);
  console.log(response.body || response.response.statusCode)
} catch (err) {
  console.log(`There was an ERROR! \n Status Code: ${err.response.statusCode}.`);
  console.log(`ERROR: \n ${JSON.stringify(err.response.body, null, 2)}`);
}

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
            {
                // Allows you to create a single payment for invoices 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' );	
$config->setHost("https://api.xero.com/api.xro/2.0");        

$xeroTenantId =  'YOUR_XERO_TENANT_ID'; // String | Xero identifier for Tenant

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

try { 
} 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";
}

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

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

# create an instance of the API class
api_instance = .AccountingApi()
xeroTenantId = YOUR_XERO_TENANT_ID # String | Xero identifier for Tenant (default to null)
payment = { invoice:{ invoiceID:"00000000-0000-0000-000-000000000000", lineItems:[], contact: {}, type: Invoice.TypeEnum.ACCPAY }, account:{ code:"970" }, date:"2019-03-12", amount:1.0 } # Payment | 

try: 
    # Allows you to create a single payment for invoices or credit notes
    api_response = api_instance.create_payment(xeroTenantId, payment)
    pprint(api_response)
except ApiException 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 = { invoice:{ invoiceID:"00000000-0000-0000-000-000000000000", lineItems:[], contact: {}, type: Invoice.TypeEnum.ACCPAY }, account:{ code:"970" }, date:"2019-03-12", amount:1.0 }; // Payment

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

}