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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        String idempotencyKey = 'KEY_VALUE';
        
        Account account = new Account();
        account.setCode("123456");
        account.setName("FooBar");
        account.setType(com.xero.models.accounting.AccountType.EXPENSE);
        account.setDescription("Hello World");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID bankTransactionID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID bankTransactionID = '00000000-0000-0000-0000-000000000000';
        String idempotencyKey = 'KEY_VALUE';
        
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        Boolean summarizeErrors = true;
        Integer unitdp = 4;
        String idempotencyKey = 'KEY_VALUE';
        
        Contact contact = new Contact();
        contact.setContactID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        
        LineItem lineItem = new LineItem();
        lineItem.setDescription("Foobar");
        lineItem.setQuantity(1.0);
        lineItem.setUnitAmount(20.0);
        lineItem.setAccountCode("000");

        List<LineItem> lineItems = new ArrayList<LineItem>();
        lineItems.add(lineItem);
        
        Account bankAccount = new Account();
        bankAccount.setAccountID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        
        BankTransaction bankTransaction = new BankTransaction();
        bankTransaction.setType(com.xero.models.accounting.BankTransaction.TypeEnum.RECEIVE);
        bankTransaction.setContact(contact);
        bankTransaction.setLineItems(lineItems);
        bankTransaction.setBankAccount(bankAccount);
        
        BankTransactions bankTransactions = new BankTransactions();
        bankTransactions.addBankTransactionsItem(bankTransaction);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        String idempotencyKey = 'KEY_VALUE';
        
        Account fromBankAccount = new Account();
        fromBankAccount.setAccountID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        
        Account toBankAccount = new Account();
        toBankAccount.setAccountID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        
        BankTransfer bankTransfer = new BankTransfer();
        bankTransfer.setFromBankAccount(fromBankAccount);
        bankTransfer.setToBankAccount(toBankAccount);
        bankTransfer.setAmount(1.0);
        
        BankTransfers bankTransfers = new BankTransfers();
        bankTransfers.addBankTransfersItem(bankTransfer);

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

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

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

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

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

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID bankTransferID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID bankTransferID = '00000000-0000-0000-0000-000000000000';
        String idempotencyKey = 'KEY_VALUE';
        
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        Boolean summarizeErrors = true;
        String idempotencyKey = 'KEY_VALUE';
        LocalDate currDate = LocalDate.now();
        
        Account paymentAccount = new Account();
        paymentAccount.setAccountID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        
        Account bankAccount = new Account();
        bankAccount.setAccountID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        
        Invoice invoice = new Invoice();
        invoice.setInvoiceID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        
        Payment payment = new Payment();
        payment.setAccount(bankAccount);
        payment.setDate(currDate);
        payment.setAmount(1.0);
        payment.setInvoice(invoice);

        List<Payment> payments = new ArrayList<Payment>();
        payments.add(payment);
        
        BatchPayment batchPayment = new BatchPayment();
        batchPayment.setAccount(paymentAccount);
        batchPayment.setReference("hello foobar");
        batchPayment.setDate(currDate);
        batchPayment.setPayments(payments);
        
        BatchPayments batchPayments = new BatchPayments();
        batchPayments.addBatchPaymentsItem(batchPayment);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID batchPaymentID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID batchPaymentID = '00000000-0000-0000-0000-000000000000';
        String idempotencyKey = 'KEY_VALUE';
        
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID brandingThemeID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID brandingThemeID = '00000000-0000-0000-0000-000000000000';
        String idempotencyKey = 'KEY_VALUE';
        
        PaymentService paymentService = new PaymentService();
        paymentService.setPaymentServiceID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        paymentService.setPaymentServiceName("ACME Payments");
        paymentService.setPaymentServiceUrl("https://www.payupnow.com/");
        paymentService.setPayNowText("Pay Now");
        
        PaymentServices paymentServices = new PaymentServices();
        paymentServices.addPaymentServicesItem(paymentService);

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

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

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

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

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

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        String idempotencyKey = 'KEY_VALUE';
        
        ContactGroup contactGroup = new ContactGroup();
        contactGroup.setName("VIPs");
        
        ContactGroups contactGroups = new ContactGroups();
        contactGroups.addContactGroupsItem(contactGroup);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID contactGroupID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID contactGroupID = '00000000-0000-0000-0000-000000000000';
        String idempotencyKey = 'KEY_VALUE';
        
        Contact contact = new Contact();
        contact.setContactID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        
        Contacts contacts = new Contacts();
        contacts.addContactsItem(contact);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID contactID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID contactID = '00000000-0000-0000-0000-000000000000';
        String idempotencyKey = 'KEY_VALUE';
        
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        Boolean summarizeErrors = true;
        String idempotencyKey = 'KEY_VALUE';
        
        Phone phone = new Phone();
        phone.setPhoneNumber("555-1212");
        phone.setPhoneType(com.xero.models.accounting.Phone.PhoneTypeEnum.MOBILE);

        List<Phone> phones = new ArrayList<Phone>();
        phones.add(phone);
        
        Contact contact = new Contact();
        contact.setName("Bruce Banner");
        contact.setEmailAddress("hulk@avengers.com");
        contact.setPhones(phones);
        
        Contacts contacts = new Contacts();
        contacts.addContactsItem(contact);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID creditNoteID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID creditNoteID = '00000000-0000-0000-0000-000000000000';
        Boolean summarizeErrors = true;
        String idempotencyKey = 'KEY_VALUE';
        LocalDate currDate = LocalDate.now();
        
        Invoice invoice = new Invoice();
        invoice.setInvoiceID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        
        Allocation allocation = new Allocation();
        allocation.setAmount(1.0);
        allocation.setDate(currDate);
        allocation.setInvoice(invoice);
        
        Allocations allocations = new Allocations();
        allocations.addAllocationsItem(allocation);

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

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

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

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

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

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID creditNoteID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID creditNoteID = '00000000-0000-0000-0000-000000000000';
        String idempotencyKey = 'KEY_VALUE';
        
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        Boolean summarizeErrors = true;
        Integer unitdp = 4;
        String idempotencyKey = 'KEY_VALUE';
        LocalDate currDate = LocalDate.now();
        
        Contact contact = new Contact();
        contact.setContactID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        
        LineItem lineItem = new LineItem();
        lineItem.setDescription("Foobar");
        lineItem.setQuantity(1.0);
        lineItem.setUnitAmount(20.0);
        lineItem.setAccountCode("000");

        List<LineItem> lineItems = new ArrayList<LineItem>();
        lineItems.add(lineItem);
        
        CreditNote creditNote = new CreditNote();
        creditNote.setType(com.xero.models.accounting.CreditNote.TypeEnum.ACCPAYCREDIT);
        creditNote.setContact(contact);
        creditNote.setDate(currDate);
        creditNote.setLineItems(lineItems);
        
        CreditNotes creditNotes = new CreditNotes();
        creditNotes.addCreditNotesItem(creditNote);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        String idempotencyKey = 'KEY_VALUE';
        
        Currency currency = new Currency();
        currency.setCode(com.xero.models.accounting.CurrencyCode.USD);
        currency.setDescription("United States Dollar");

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        Boolean summarizeErrors = true;
        String idempotencyKey = 'KEY_VALUE';
        
        Employee employee = new Employee();
        employee.setFirstName("Nick");
        employee.setLastName("Fury");
        
        Employees employees = new Employees();
        employees.addEmployeesItem(employee);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID expenseClaimID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID expenseClaimID = '00000000-0000-0000-0000-000000000000';
        String idempotencyKey = 'KEY_VALUE';
        
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        String idempotencyKey = 'KEY_VALUE';
        LocalDate currDate = LocalDate.now();
        
        User user = new User();
        user.setUserID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        
        Receipt receipt = new Receipt();
        receipt.setReceiptID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        receipt.setDate(currDate);

        List<Receipt> receipts = new ArrayList<Receipt>();
        receipts.add(receipt);
        
        ExpenseClaim expenseClaim = new ExpenseClaim();
        expenseClaim.setStatus(com.xero.models.accounting.ExpenseClaim.StatusEnum.SUBMITTED);
        expenseClaim.setUser(user);
        expenseClaim.setReceipts(receipts);
        
        ExpenseClaims expenseClaims = new ExpenseClaims();
        expenseClaims.addExpenseClaimsItem(expenseClaim);

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

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

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

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

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

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID invoiceID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID invoiceID = '00000000-0000-0000-0000-000000000000';
        String idempotencyKey = 'KEY_VALUE';
        
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        Boolean summarizeErrors = true;
        Integer unitdp = 4;
        String idempotencyKey = 'KEY_VALUE';
        LocalDate dateValue = LocalDate.of(2020, Month.OCTOBER, 10);
        LocalDate dueDateValue = LocalDate.of(2020, Month.OCTOBER, 28);
        
        Contact contact = new Contact();
        contact.setContactID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        
        LineItemTracking lineItemTracking = new LineItemTracking();
        lineItemTracking.setTrackingCategoryID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        lineItemTracking.setTrackingOptionID(UUID.fromString("00000000-0000-0000-0000-000000000000"));

        List<LineItemTracking> lineItemTrackings = new ArrayList<LineItemTracking>();
        lineItemTrackings.add(lineItemTracking);
        
        LineItem lineItem = new LineItem();
        lineItem.setDescription("Foobar");
        lineItem.setQuantity(1.0);
        lineItem.setUnitAmount(20.0);
        lineItem.setAccountCode("000");
        lineItem.setTracking(lineItemTrackings);

        List<LineItem> lineItems = new ArrayList<LineItem>();
        lineItems.add(lineItem);
        
        Invoice invoice = new Invoice();
        invoice.setType(com.xero.models.accounting.Invoice.TypeEnum.ACCREC);
        invoice.setContact(contact);
        invoice.setDate(dateValue);
        invoice.setDueDate(dueDateValue);
        invoice.setLineItems(lineItems);
        invoice.setReference("Website Design");
        invoice.setStatus(com.xero.models.accounting.Invoice.StatusEnum.DRAFT);
        
        Invoices invoices = new Invoices();
        invoices.addInvoicesItem(invoice);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID itemID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID itemID = '00000000-0000-0000-0000-000000000000';
        String idempotencyKey = 'KEY_VALUE';
        
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        Boolean summarizeErrors = true;
        Integer unitdp = 4;
        String idempotencyKey = 'KEY_VALUE';
        
        Purchase purchaseDetails = new Purchase();
        purchaseDetails.setCoGSAccountCode("500");
        
        Item item = new Item();
        item.setCode("abcXYZ123");
        item.setName("HelloWorld");
        item.setDescription("Foobar");
        item.setInventoryAssetAccountCode("140");
        item.setPurchaseDetails(purchaseDetails);
        
        Items items = new Items();
        items.addItemsItem(item);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        String idempotencyKey = 'KEY_VALUE';
        
        LinkedTransaction linkedTransaction = new LinkedTransaction();
        linkedTransaction.setSourceTransactionID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        linkedTransaction.setSourceLineItemID(UUID.fromString("00000000-0000-0000-0000-000000000000"));

        try {
            LinkedTransactions result = apiInstance.createLinkedTransaction(accessToken, xeroTenantId, linkedTransaction, idempotencyKey);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createLinkedTransaction");
            e.printStackTrace();
        }
    }
}

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

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

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

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

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID manualJournalID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID manualJournalID = '00000000-0000-0000-0000-000000000000';
        String idempotencyKey = 'KEY_VALUE';
        
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        Boolean summarizeErrors = true;
        String idempotencyKey = 'KEY_VALUE';
        LocalDate dateValue = LocalDate.of(2020, Month.OCTOBER, 10);

        List<ManualJournalLine> manualJournalLines = new ArrayList<ManualJournalLine>();
        
        ManualJournalLine credit = new ManualJournalLine();
        credit.setLineAmount(-100.0);
        credit.setAccountCode("400");
        credit.setDescription("Hello there");
        manualJournalLines.add(credit);
        
        ManualJournalLine debit = new ManualJournalLine();
        debit.setLineAmount(100.0);
        debit.setAccountCode("120");
        debit.setDescription("Hello there");
        manualJournalLines.add(debit);
        
        ManualJournal manualJournal = new ManualJournal();
        manualJournal.setNarration("Foobar");
        manualJournal.setDate(dateValue);
        manualJournal.setJournalLines(manualJournalLines);
        
        ManualJournals manualJournals = new ManualJournals();
        manualJournals.addManualJournalsItem(manualJournal);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID overpaymentID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID overpaymentID = '00000000-0000-0000-0000-000000000000';
        Boolean summarizeErrors = true;
        String idempotencyKey = 'KEY_VALUE';
        LocalDate currDate = LocalDate.now();
        
        Invoice invoice = new Invoice();
        invoice.setInvoiceID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        
        Allocation allocation = new Allocation();
        allocation.setAmount(1.0);
        allocation.setDate(currDate);
        allocation.setInvoice(invoice);
        
        Allocations allocations = new Allocations();
        allocations.addAllocationsItem(allocation);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID overpaymentID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID overpaymentID = '00000000-0000-0000-0000-000000000000';
        String idempotencyKey = 'KEY_VALUE';
        
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        String idempotencyKey = 'KEY_VALUE';
        LocalDate dateValue = LocalDate.of(2020, Month.OCTOBER, 10);
        
        Invoice invoice = new Invoice();
        invoice.setInvoiceID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        
        Account account = new Account();
        account.setAccountID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        
        Payment payment = new Payment();
        payment.setInvoice(invoice);
        payment.setAccount(account);
        payment.setAmount(1.0);
        payment.setDate(dateValue);
        
        Payments payments = new Payments();
        payments.addPaymentsItem(payment);

        try {
            Payments result = apiInstance.createPayment(accessToken, xeroTenantId, payment, idempotencyKey);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createPayment");
            e.printStackTrace();
        }
    }
}

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID paymentID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID paymentID = '00000000-0000-0000-0000-000000000000';
        String idempotencyKey = 'KEY_VALUE';
        
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        String idempotencyKey = 'KEY_VALUE';
        
        PaymentService paymentService = new PaymentService();
        paymentService.setPaymentServiceName("ACME Payments");
        paymentService.setPaymentServiceUrl("https://www.payupnow.com/");
        paymentService.setPayNowText("Pay Now");
        
        PaymentServices paymentServices = new PaymentServices();
        paymentServices.addPaymentServicesItem(paymentService);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        Boolean summarizeErrors = true;
        String idempotencyKey = 'KEY_VALUE';
        LocalDate dateValue = LocalDate.of(2020, Month.OCTOBER, 10);
        
        Invoice invoice = new Invoice();
        invoice.setInvoiceID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        
        Account account = new Account();
        account.setAccountID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        
        Payment payment = new Payment();
        payment.setInvoice(invoice);
        payment.setAccount(account);
        payment.setAmount(1.0);
        payment.setDate(dateValue);
        
        Payments payments = new Payments();
        payments.addPaymentsItem(payment);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID prepaymentID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID prepaymentID = '00000000-0000-0000-0000-000000000000';
        Boolean summarizeErrors = true;
        String idempotencyKey = 'KEY_VALUE';
        LocalDate currDate = LocalDate.now();
        
        Invoice invoice = new Invoice();
        invoice.setInvoiceID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        
        Allocation allocation = new Allocation();
        allocation.setInvoice(invoice);
        allocation.setAmount(1.0);
        allocation.setDate(currDate);
        
        Allocations allocations = new Allocations();
        allocations.addAllocationsItem(allocation);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID prepaymentID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID prepaymentID = '00000000-0000-0000-0000-000000000000';
        String idempotencyKey = 'KEY_VALUE';
        
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

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

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

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

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

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

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID purchaseOrderID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID purchaseOrderID = '00000000-0000-0000-0000-000000000000';
        String idempotencyKey = 'KEY_VALUE';
        
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        Boolean summarizeErrors = true;
        String idempotencyKey = 'KEY_VALUE';
        LocalDate dateValue = LocalDate.of(2020, Month.OCTOBER, 10);
        
        Contact contact = new Contact();
        contact.setContactID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        
        LineItem lineItem = new LineItem();
        lineItem.setDescription("Foobar");
        lineItem.setQuantity(1.0);
        lineItem.setUnitAmount(20.0);
        lineItem.setAccountCode("000");

        List<LineItem> lineItems = new ArrayList<LineItem>();
        lineItems.add(lineItem);
        
        PurchaseOrder purchaseOrder = new PurchaseOrder();
        purchaseOrder.setContact(contact);
        purchaseOrder.setLineItems(lineItems);
        purchaseOrder.setDate(dateValue);
        
        PurchaseOrders purchaseOrders = new PurchaseOrders();
        purchaseOrders.addPurchaseOrdersItem(purchaseOrder);

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

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

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

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

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

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID quoteID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID quoteID = '00000000-0000-0000-0000-000000000000';
        String idempotencyKey = 'KEY_VALUE';
        
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        Boolean summarizeErrors = true;
        String idempotencyKey = 'KEY_VALUE';
        LocalDate dateValue = LocalDate.of(2020, Month.OCTOBER, 10);
        
        Contact contact = new Contact();
        contact.setContactID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        
        LineItem lineItem = new LineItem();
        lineItem.setDescription("Foobar");
        lineItem.setQuantity(1.0);
        lineItem.setUnitAmount(20.0);
        lineItem.setAccountCode("000");

        List<LineItem> lineItems = new ArrayList<LineItem>();
        lineItems.add(lineItem);
        
        Quote quote = new Quote();
        quote.setContact(contact);
        quote.setLineItems(lineItems);
        quote.setDate(dateValue);
        
        Quotes quotes = new Quotes();
        quotes.addQuotesItem(quote);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        Integer unitdp = 4;
        String idempotencyKey = 'KEY_VALUE';
        
        Contact contact = new Contact();
        contact.setContactID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        
        User user = new User();
        user.setUserID(UUID.fromString("00000000-0000-0000-0000-000000000000"));
        
        LineItem lineItem = new LineItem();
        lineItem.setDescription("Foobar");
        lineItem.setQuantity(1.0);
        lineItem.setUnitAmount(20.0);
        lineItem.setAccountCode("000");

        List<LineItem> lineItems = new ArrayList<LineItem>();
        lineItems.add(lineItem);
        
        Receipt receipt = new Receipt();
        receipt.setContact(contact);
        receipt.setUser(user);
        receipt.setLineItems(lineItems);
        receipt.setLineAmountTypes(com.xero.models.accounting.LineAmountTypes.INCLUSIVE);
        receipt.setStatus(com.xero.models.accounting.Receipt.StatusEnum.DRAFT);
        
        Receipts receipts = new Receipts();
        receipts.addReceiptsItem(receipt);

        try {
            Receipts result = apiInstance.createReceipt(accessToken, xeroTenantId, receipts, unitdp, idempotencyKey);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createReceipt");
            e.printStackTrace();
        }
    }
}

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

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

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

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

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID receiptID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID receiptID = '00000000-0000-0000-0000-000000000000';
        String idempotencyKey = 'KEY_VALUE';
        
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

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

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

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

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

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

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID repeatingInvoiceID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID repeatingInvoiceID = '00000000-0000-0000-0000-000000000000';
        String idempotencyKey = 'KEY_VALUE';
        
        HistoryRecord historyRecord = new HistoryRecord();
        historyRecord.setDetails("Hello World");
        
        HistoryRecords historyRecords = new HistoryRecords();
        historyRecords.addHistoryRecordsItem(historyRecord);

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        Boolean summarizeErrors = true;
        String idempotencyKey = 'KEY_VALUE';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        String idempotencyKey = 'KEY_VALUE';
        
        TaxComponent taxComponent = new TaxComponent();
        taxComponent.setName("State Tax");
        taxComponent.setRate(2.25);

        List<TaxComponent> taxComponent = new ArrayList<TaxComponent>();
        taxComponents.add(taxComponent);
        
        TaxRate taxRate = new TaxRate();
        taxRate.setName("CA State Tax");
        taxRate.setTaxComponents(taxComponents);
        
        TaxRates taxRates = new TaxRates();
        taxRates.addTaxRatesItem(taxRate);

        try {
            TaxRates result = apiInstance.createTaxRates(accessToken, xeroTenantId, taxRates, idempotencyKey);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createTaxRates");
            e.printStackTrace();
        }
    }
}

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        String idempotencyKey = 'KEY_VALUE';
        
        TrackingCategory trackingCategory = new TrackingCategory();
        trackingCategory.setName("Foobar");

        try {
            TrackingCategories result = apiInstance.createTrackingCategory(accessToken, xeroTenantId, trackingCategory, idempotencyKey);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createTrackingCategory");
            e.printStackTrace();
        }
    }
}

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID trackingCategoryID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID trackingCategoryID = '00000000-0000-0000-0000-000000000000';
        String idempotencyKey = 'KEY_VALUE';
        
        TrackingOption trackingOption = new TrackingOption();
        trackingOption.setName("Foobar");

        try {
            TrackingOptions result = apiInstance.createTrackingOptions(accessToken, xeroTenantId, trackingCategoryID, trackingOption, idempotencyKey);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#createTrackingOptions");
            e.printStackTrace();
        }
    }
}

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID accountID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID accountID = '00000000-0000-0000-0000-000000000000';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        String idempotencyKey = 'KEY_VALUE';
        
        BatchPaymentDelete batchPaymentDelete = new BatchPaymentDelete();
        batchPaymentDelete.setStatus("DELETED");
        batchPaymentDelete.setBatchPaymentID(UUID.fromString("00000000-0000-0000-0000-000000000000"));

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID batchPaymentID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID batchPaymentID = '00000000-0000-0000-0000-000000000000';
        String idempotencyKey = 'KEY_VALUE';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID contactGroupID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID contactGroupID = '00000000-0000-0000-0000-000000000000';
        UUID contactID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID contactID = '00000000-0000-0000-0000-000000000000';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID contactGroupID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID contactGroupID = '00000000-0000-0000-0000-000000000000';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID creditNoteID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID creditNoteID = '00000000-0000-0000-0000-000000000000';
        UUID allocationID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID allocationID = '00000000-0000-0000-0000-000000000000';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID itemID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID itemID = '00000000-0000-0000-0000-000000000000';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID linkedTransactionID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID linkedTransactionID = '00000000-0000-0000-0000-000000000000';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID overpaymentID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID overpaymentID = '00000000-0000-0000-0000-000000000000';
        UUID allocationID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID allocationID = '00000000-0000-0000-0000-000000000000';

        try {
            Allocation result = apiInstance.deleteOverpaymentAllocations(accessToken, xeroTenantId, overpaymentID, allocationID);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#deleteOverpaymentAllocations");
            e.printStackTrace();
        }
    }
}

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID paymentID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID paymentID = '00000000-0000-0000-0000-000000000000';
        String idempotencyKey = 'KEY_VALUE';
        
        PaymentDelete paymentDelete = new PaymentDelete();
        paymentDelete.setStatus("DELETED");

        try {
            Payments result = apiInstance.deletePayment(accessToken, xeroTenantId, paymentID, paymentDelete, idempotencyKey);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#deletePayment");
            e.printStackTrace();
        }
    }
}

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID prepaymentID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID prepaymentID = '00000000-0000-0000-0000-000000000000';
        UUID allocationID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID allocationID = '00000000-0000-0000-0000-000000000000';

        try {
            Allocation result = apiInstance.deletePrepaymentAllocations(accessToken, xeroTenantId, prepaymentID, allocationID);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#deletePrepaymentAllocations");
            e.printStackTrace();
        }
    }
}

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID trackingCategoryID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID trackingCategoryID = '00000000-0000-0000-0000-000000000000';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID trackingCategoryID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID trackingCategoryID = '00000000-0000-0000-0000-000000000000';
        UUID trackingOptionID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID trackingOptionID = '00000000-0000-0000-0000-000000000000';

        try {
            TrackingOptions result = apiInstance.deleteTrackingOptions(accessToken, xeroTenantId, trackingCategoryID, trackingOptionID);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#deleteTrackingOptions");
            e.printStackTrace();
        }
    }
}

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID invoiceID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID invoiceID = '00000000-0000-0000-0000-000000000000';
        String idempotencyKey = 'KEY_VALUE';
        
        RequestEmpty requestEmpty = new RequestEmpty();

        try {
             result = apiInstance.emailInvoice(accessToken, xeroTenantId, invoiceID, requestEmpty, idempotencyKey);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#emailInvoice");
            e.printStackTrace();
        }
    }
}

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID accountID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID accountID = '00000000-0000-0000-0000-000000000000';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID accountID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID accountID = '00000000-0000-0000-0000-000000000000';
        String fileName = 'xero-dev.jpg';
        String contentType = 'image/jpg';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID accountID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID accountID = '00000000-0000-0000-0000-000000000000';
        UUID attachmentID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID attachmentID = '00000000-0000-0000-0000-000000000000';
        String contentType = 'image/jpg';

        try {
            ByteArrayInputStream result = apiInstance.getAccountAttachmentById(accessToken, xeroTenantId, accountID, attachmentID, contentType);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#getAccountAttachmentById");
            e.printStackTrace();
        }
    }
}

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID accountID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID accountID = '00000000-0000-0000-0000-000000000000';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';

        OffsetDateTime ifModifiedSince = OffsetDateTime.parse("2020-02-06T12:17:43.202-08:00");
        String where = 'Status=="ACTIVE" AND Type=="BANK"';
        String order = 'Name ASC';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID bankTransactionID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID bankTransactionID = '00000000-0000-0000-0000-000000000000';
        Integer unitdp = 4;

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID bankTransactionID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID bankTransactionID = '00000000-0000-0000-0000-000000000000';
        String fileName = 'xero-dev.jpg';
        String contentType = 'image/jpg';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID bankTransactionID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID bankTransactionID = '00000000-0000-0000-0000-000000000000';
        UUID attachmentID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID attachmentID = '00000000-0000-0000-0000-000000000000';
        String contentType = 'image/jpg';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID bankTransactionID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID bankTransactionID = '00000000-0000-0000-0000-000000000000';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';

        OffsetDateTime ifModifiedSince = OffsetDateTime.parse("2020-02-06T12:17:43.202-08:00");
        String where = 'Status=="AUTHORISED"';
        String order = 'Type ASC';
        Integer page = 1;
        Integer unitdp = 4;
        Integer pageSize = 100;

        try {
            BankTransactions result = apiInstance.getBankTransactions(accessToken, xeroTenantId, ifModifiedSince, where, order, page, unitdp, pageSize);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#getBankTransactions");
            e.printStackTrace();
        }
    }
}

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID bankTransactionID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID bankTransactionID = '00000000-0000-0000-0000-000000000000';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID bankTransferID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID bankTransferID = '00000000-0000-0000-0000-000000000000';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID bankTransferID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID bankTransferID = '00000000-0000-0000-0000-000000000000';
        String fileName = 'xero-dev.jpg';
        String contentType = 'image/jpg';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID bankTransferID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID bankTransferID = '00000000-0000-0000-0000-000000000000';
        UUID attachmentID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID attachmentID = '00000000-0000-0000-0000-000000000000';
        String contentType = 'image/jpg';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID bankTransferID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID bankTransferID = '00000000-0000-0000-0000-000000000000';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID bankTransferID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID bankTransferID = '00000000-0000-0000-0000-000000000000';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';

        OffsetDateTime ifModifiedSince = OffsetDateTime.parse("2020-02-06T12:17:43.202-08:00");
        String where = 'HasAttachments==true';
        String order = 'Amount ASC';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID batchPaymentID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID batchPaymentID = '00000000-0000-0000-0000-000000000000';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID batchPaymentID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID batchPaymentID = '00000000-0000-0000-0000-000000000000';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';

        OffsetDateTime ifModifiedSince = OffsetDateTime.parse("2020-02-06T12:17:43.202-08:00");
        String where = 'Status=="AUTHORISED"';
        String order = 'Date ASC';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID brandingThemeID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID brandingThemeID = '00000000-0000-0000-0000-000000000000';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID brandingThemeID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID brandingThemeID = '00000000-0000-0000-0000-000000000000';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';

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

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID budgetID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID budgetID = '00000000-0000-0000-0000-000000000000';
        date dateTo = 2019-10-31;
        date dateFrom = 2019-10-31;

        try {
            Budgets result = apiInstance.getBudget(accessToken, xeroTenantId, budgetID, dateTo, dateFrom);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#getBudget");
            e.printStackTrace();
        }
    }
}

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        array[UUID] iDs = "00000000-0000-0000-0000-000000000000";
        date dateTo = 2019-10-31;
        date dateFrom = 2019-10-31;

        try {
            Budgets result = apiInstance.getBudgets(accessToken, xeroTenantId, iDs, dateTo, dateFrom);
            System.out.println(result);
        } catch (XeroException e) {
            System.err.println("Exception when calling AccountingApi#getBudgets");
            e.printStackTrace();
        }
    }
}

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

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

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

        apiInstance = AccountingApi.getInstance(defaultClient);
        String xeroTenantId = 'YOUR_XERO_TENANT_ID';
        UUID contactID = UUID.fromString("00000000-0000-0000-0000-000000000000");
        UUID contactID = '00000000-0000-0000-0000-000000000000';

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