@maesn/typescript-sdk 0.2.1

package/src/sdk/accounting.ts

@@ -0,0 +1,1185 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { accountingAddAccount } from "../funcs/accounting-add-account.js";
+import { accountingAddBankAccount } from "../funcs/accounting-add-bank-account.js";
+import { accountingAddBill } from "../funcs/accounting-add-bill.js";
+import { accountingAddBooking } from "../funcs/accounting-add-booking.js";
+import { accountingAddContact } from "../funcs/accounting-add-contact.js";
+import { accountingAddEventSubscription } from "../funcs/accounting-add-event-subscription.js";
+import { accountingAddExpense } from "../funcs/accounting-add-expense.js";
+import { accountingAddInvoiceLineItem } from "../funcs/accounting-add-invoice-line-item.js";
+import { accountingAddInvoice } from "../funcs/accounting-add-invoice.js";
+import { accountingAddJournalEntry } from "../funcs/accounting-add-journal-entry.js";
+import { accountingAddOffer } from "../funcs/accounting-add-offer.js";
+import { accountingAddPaymentTerm } from "../funcs/accounting-add-payment-term.js";
+import { accountingAddPayment } from "../funcs/accounting-add-payment.js";
+import { accountingAddProject } from "../funcs/accounting-add-project.js";
+import { accountingAddSalesOrder } from "../funcs/accounting-add-sales-order.js";
+import { accountingAddSupplier } from "../funcs/accounting-add-supplier.js";
+import { accountingAmendCustomer } from "../funcs/accounting-amend-customer.js";
+import { accountingAmendInvoice } from "../funcs/accounting-amend-invoice.js";
+import { accountingAmendSupplier } from "../funcs/accounting-amend-supplier.js";
+import { accountingBatchAddContacts } from "../funcs/accounting-batch-add-contacts.js";
+import { accountingCreateBookingProposal } from "../funcs/accounting-create-booking-proposal.js";
+import { accountingCreateContactsBulk } from "../funcs/accounting-create-contacts-bulk.js";
+import { accountingCreateCustomer } from "../funcs/accounting-create-customer.js";
+import { accountingCreateJournalEntryAttachments } from "../funcs/accounting-create-journal-entry-attachments.js";
+import { accountingCreatePassThrough } from "../funcs/accounting-create-pass-through.js";
+import { accountingCreateVendorCredit } from "../funcs/accounting-create-vendor-credit.js";
+import { accountingFetchBankAccount } from "../funcs/accounting-fetch-bank-account.js";
+import { accountingFetchBillDocument } from "../funcs/accounting-fetch-bill-document.js";
+import { accountingFetchBill } from "../funcs/accounting-fetch-bill.js";
+import { accountingFetchBills } from "../funcs/accounting-fetch-bills.js";
+import { accountingFetchBookingProposalDocument } from "../funcs/accounting-fetch-booking-proposal-document.js";
+import { accountingFetchContact } from "../funcs/accounting-fetch-contact.js";
+import { accountingFetchCreditNote } from "../funcs/accounting-fetch-credit-note.js";
+import { accountingFetchCustomer } from "../funcs/accounting-fetch-customer.js";
+import { accountingFetchCustomers } from "../funcs/accounting-fetch-customers.js";
+import { accountingFetchDocumentTypes } from "../funcs/accounting-fetch-document-types.js";
+import { accountingFetchExpense } from "../funcs/accounting-fetch-expense.js";
+import { accountingFetchExpenses } from "../funcs/accounting-fetch-expenses.js";
+import { accountingFetchInvoiceDocument } from "../funcs/accounting-fetch-invoice-document.js";
+import { accountingFetchInvoice } from "../funcs/accounting-fetch-invoice.js";
+import { accountingFetchItem } from "../funcs/accounting-fetch-item.js";
+import { accountingFetchJournalEntry } from "../funcs/accounting-fetch-journal-entry.js";
+import { accountingFetchJournals } from "../funcs/accounting-fetch-journals.js";
+import { accountingFetchOfferLineItems } from "../funcs/accounting-fetch-offer-line-items.js";
+import { accountingFetchOffer } from "../funcs/accounting-fetch-offer.js";
+import { accountingFetchOffers } from "../funcs/accounting-fetch-offers.js";
+import { accountingFetchPaymentTerm } from "../funcs/accounting-fetch-payment-term.js";
+import { accountingFetchPayment } from "../funcs/accounting-fetch-payment.js";
+import { accountingFetchProject } from "../funcs/accounting-fetch-project.js";
+import { accountingFetchPurchaseOrder } from "../funcs/accounting-fetch-purchase-order.js";
+import { accountingFetchSalesOrder } from "../funcs/accounting-fetch-sales-order.js";
+import { accountingFetchSupplier } from "../funcs/accounting-fetch-supplier.js";
+import { accountingFetchTaxRate } from "../funcs/accounting-fetch-tax-rate.js";
+import { accountingFetchTrialBalance } from "../funcs/accounting-fetch-trial-balance.js";
+import { accountingFetchUnits } from "../funcs/accounting-fetch-units.js";
+import { accountingGetAsyncTask } from "../funcs/accounting-get-async-task.js";
+import { accountingGetContacts } from "../funcs/accounting-get-contacts.js";
+import { accountingGetFiscalYears } from "../funcs/accounting-get-fiscal-years.js";
+import { accountingGetGoodsReceipts } from "../funcs/accounting-get-goods-receipts.js";
+import { accountingGetPaymentTerms } from "../funcs/accounting-get-payment-terms.js";
+import { accountingGetProfile } from "../funcs/accounting-get-profile.js";
+import { accountingGetProjects } from "../funcs/accounting-get-projects.js";
+import { accountingListBookingProposals } from "../funcs/accounting-list-booking-proposals.js";
+import { accountingListCreditNotes } from "../funcs/accounting-list-credit-notes.js";
+import { accountingListJournalEntries } from "../funcs/accounting-list-journal-entries.js";
+import { accountingListSalesOrderLineItems } from "../funcs/accounting-list-sales-order-line-items.js";
+import { accountingListSalesOrders } from "../funcs/accounting-list-sales-orders.js";
+import { accountingModifyBillLineItem } from "../funcs/accounting-modify-bill-line-item.js";
+import { accountingModifySupplier } from "../funcs/accounting-modify-supplier.js";
+import { accountingModifyVendorCredit } from "../funcs/accounting-modify-vendor-credit.js";
+import { accountingRecordTransaction } from "../funcs/accounting-record-transaction.js";
+import { accountingRemoveBill } from "../funcs/accounting-remove-bill.js";
+import { accountingRemoveEventSubscription } from "../funcs/accounting-remove-event-subscription.js";
+import { accountingRemovePayment } from "../funcs/accounting-remove-payment.js";
+import { accountingReplaceContact } from "../funcs/accounting-replace-contact.js";
+import { accountingRetrieveAccount } from "../funcs/accounting-retrieve-account.js";
+import { accountingRetrieveAccounts } from "../funcs/accounting-retrieve-accounts.js";
+import { accountingRetrieveBankAccounts } from "../funcs/accounting-retrieve-bank-accounts.js";
+import { accountingRetrieveBookingProposal } from "../funcs/accounting-retrieve-booking-proposal.js";
+import { accountingRetrieveDimensions } from "../funcs/accounting-retrieve-dimensions.js";
+import { accountingRetrieveGoodsReceiptLineItems } from "../funcs/accounting-retrieve-goods-receipt-line-items.js";
+import { accountingRetrieveGoodsReceipt } from "../funcs/accounting-retrieve-goods-receipt.js";
+import { accountingRetrieveInvoiceLineItem } from "../funcs/accounting-retrieve-invoice-line-item.js";
+import { accountingRetrieveInvoiceLineItems } from "../funcs/accounting-retrieve-invoice-line-items.js";
+import { accountingRetrieveInvoices } from "../funcs/accounting-retrieve-invoices.js";
+import { accountingRetrieveItems } from "../funcs/accounting-retrieve-items.js";
+import { accountingRetrieveOfferLineItem } from "../funcs/accounting-retrieve-offer-line-item.js";
+import { accountingRetrieveOpenItems } from "../funcs/accounting-retrieve-open-items.js";
+import { accountingRetrievePayments } from "../funcs/accounting-retrieve-payments.js";
+import { accountingRetrievePurchaseOrderLineItem } from "../funcs/accounting-retrieve-purchase-order-line-item.js";
+import { accountingRetrievePurchaseOrderLineItems } from "../funcs/accounting-retrieve-purchase-order-line-items.js";
+import { accountingRetrieveSuppliers } from "../funcs/accounting-retrieve-suppliers.js";
+import { accountingRetrieveTaxRates } from "../funcs/accounting-retrieve-tax-rates.js";
+import { accountingRetrieveVendorCredits } from "../funcs/accounting-retrieve-vendor-credits.js";
+import { accountingUpdateCustomer } from "../funcs/accounting-update-customer.js";
+import { accountingUploadFile } from "../funcs/accounting-upload-file.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+import { AccountingBills } from "./accounting-bills.js";
+import { AccountingJournalEntries } from "./accounting-journal-entries.js";
+import { Invoices } from "./invoices.js";
+import { V2 } from "./v2.js";
+
+export class Accounting extends ClientSDK {
+  private _invoices?: Invoices;
+  get invoices(): Invoices {
+    return (this._invoices ??= new Invoices(this._options));
+  }
+
+  private _journalEntries?: AccountingJournalEntries;
+  get journalEntries(): AccountingJournalEntries {
+    return (this._journalEntries ??= new AccountingJournalEntries(
+      this._options,
+    ));
+  }
+
+  private _bills?: AccountingBills;
+  get bills(): AccountingBills {
+    return (this._bills ??= new AccountingBills(this._options));
+  }
+
+  private _v2?: V2;
+  get v2(): V2 {
+    return (this._v2 ??= new V2(this._options));
+  }
+
+  async retrieveAccount(
+    request: operations.GetAccountRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetAccountResponse> {
+    return unwrapAsync(accountingRetrieveAccount(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async retrieveAccounts(
+    request?: operations.GetAccountsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetAccountsResponse> {
+    return unwrapAsync(accountingRetrieveAccounts(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async addAccount(
+    request: operations.CreateAccountRequest,
+    options?: RequestOptions,
+  ): Promise<operations.CreateAccountResponse> {
+    return unwrapAsync(accountingAddAccount(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async retrieveBankAccounts(
+    request?: operations.GetBankAccountsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetBankAccountsResponse> {
+    return unwrapAsync(accountingRetrieveBankAccounts(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async addBankAccount(
+    request: operations.CreateBankAccountRequest,
+    options?: RequestOptions,
+  ): Promise<operations.CreateBankAccountResponse> {
+    return unwrapAsync(accountingAddBankAccount(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchBankAccount(
+    request: operations.GetBankAccountRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetBankAccountResponse> {
+    return unwrapAsync(accountingFetchBankAccount(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async retrieveDimensions(
+    request?: operations.GetDimensionsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetDimensionsResponse> {
+    return unwrapAsync(accountingRetrieveDimensions(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async recordTransaction(
+    request: operations.CreateTransactionRequest,
+    options?: RequestOptions,
+  ): Promise<operations.CreateTransactionResponse> {
+    return unwrapAsync(accountingRecordTransaction(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchCustomers(
+    request?: operations.GetCustomersRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetCustomersResponse> {
+    return unwrapAsync(accountingFetchCustomers(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async createCustomer(
+    request: operations.CreateCustomerRequest,
+    options?: RequestOptions,
+  ): Promise<operations.CreateCustomerResponse> {
+    return unwrapAsync(accountingCreateCustomer(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchCustomer(
+    request: operations.GetCustomerRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetCustomerResponse> {
+    return unwrapAsync(accountingFetchCustomer(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async updateCustomer(
+    request: operations.UpdateCustomerRequest,
+    options?: RequestOptions,
+  ): Promise<operations.UpdateCustomerResponse> {
+    return unwrapAsync(accountingUpdateCustomer(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async amendCustomer(
+    request: operations.PatchCustomersRequest,
+    options?: RequestOptions,
+  ): Promise<operations.PatchCustomersResponse> {
+    return unwrapAsync(accountingAmendCustomer(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async retrieveSuppliers(
+    request?: operations.GetSuppliersRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetSuppliersResponse> {
+    return unwrapAsync(accountingRetrieveSuppliers(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async addSupplier(
+    request: operations.CreateSupplierRequest,
+    options?: RequestOptions,
+  ): Promise<operations.CreateSupplierResponse> {
+    return unwrapAsync(accountingAddSupplier(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchSupplier(
+    request: operations.GetSupplierRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetSupplierResponse> {
+    return unwrapAsync(accountingFetchSupplier(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async modifySupplier(
+    request: operations.UpdateSupplierRequest,
+    options?: RequestOptions,
+  ): Promise<operations.UpdateSupplierResponse> {
+    return unwrapAsync(accountingModifySupplier(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async amendSupplier(
+    request: operations.PatchSupplierRequest,
+    options?: RequestOptions,
+  ): Promise<operations.PatchSupplierResponse> {
+    return unwrapAsync(accountingAmendSupplier(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async getContacts(
+    request?: operations.GetContactsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetContactsResponse> {
+    return unwrapAsync(accountingGetContacts(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async addContact(
+    request: operations.CreateContactRequest,
+    options?: RequestOptions,
+  ): Promise<operations.CreateContactResponse> {
+    return unwrapAsync(accountingAddContact(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchContact(
+    request: operations.GetContactRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetContactResponse> {
+    return unwrapAsync(accountingFetchContact(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async replaceContact(
+    request: operations.PutContactRequest,
+    options?: RequestOptions,
+  ): Promise<operations.PutContactResponse> {
+    return unwrapAsync(accountingReplaceContact(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async createContactsBulk(
+    request: operations.CreateContactsRequest,
+    options?: RequestOptions,
+  ): Promise<operations.CreateContactsResponse> {
+    return unwrapAsync(accountingCreateContactsBulk(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async batchAddContacts(
+    request: operations.CreateContactsV1Request,
+    options?: RequestOptions,
+  ): Promise<operations.CreateContactsV1Response> {
+    return unwrapAsync(accountingBatchAddContacts(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async retrieveInvoices(
+    request?: operations.GetInvoicesRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetInvoicesResponse> {
+    return unwrapAsync(accountingRetrieveInvoices(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async addInvoice(
+    request: operations.CreateInvoiceRequest,
+    options?: RequestOptions,
+  ): Promise<operations.CreateInvoiceResponse> {
+    return unwrapAsync(accountingAddInvoice(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchInvoice(
+    request: operations.GetInvoiceRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetInvoiceResponse> {
+    return unwrapAsync(accountingFetchInvoice(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async amendInvoice(
+    request: operations.PatchInvoiceRequest,
+    options?: RequestOptions,
+  ): Promise<operations.PatchInvoiceResponse> {
+    return unwrapAsync(accountingAmendInvoice(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchInvoiceDocument(
+    request: operations.GetInvoiceDocumentRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetInvoiceDocumentResponse> {
+    return unwrapAsync(accountingFetchInvoiceDocument(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async uploadFile(
+    request: operations.PostFileRequest,
+    options?: RequestOptions,
+  ): Promise<operations.PostFileResponse> {
+    return unwrapAsync(accountingUploadFile(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchDocumentTypes(
+    request?: operations.GetDocumentTypesRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetDocumentTypesResponse> {
+    return unwrapAsync(accountingFetchDocumentTypes(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async getAsyncTask(
+    request: operations.GetAsyncTaskInfoRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetAsyncTaskInfoResponse> {
+    return unwrapAsync(accountingGetAsyncTask(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async retrieveItems(
+    request?: operations.GetItemsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetItemsResponse> {
+    return unwrapAsync(accountingRetrieveItems(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchItem(
+    request: operations.GetItemRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetItemResponse> {
+    return unwrapAsync(accountingFetchItem(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async retrieveInvoiceLineItems(
+    request: operations.GetLineItemsRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetLineItemsResponse> {
+    return unwrapAsync(accountingRetrieveInvoiceLineItems(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async addInvoiceLineItem(
+    request: operations.CreateLineItemRequest,
+    options?: RequestOptions,
+  ): Promise<operations.CreateLineItemResponse> {
+    return unwrapAsync(accountingAddInvoiceLineItem(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async retrieveInvoiceLineItem(
+    request: operations.GetLineItemRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetLineItemResponse> {
+    return unwrapAsync(accountingRetrieveInvoiceLineItem(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchJournals(
+    request?: operations.GetJournalsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetJournalsResponse> {
+    return unwrapAsync(accountingFetchJournals(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async listJournalEntries(
+    request?: operations.GetJournalEntriesRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetJournalEntriesResponse> {
+    return unwrapAsync(accountingListJournalEntries(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async addJournalEntry(
+    request: operations.CreateJournalEntryRequest,
+    options?: RequestOptions,
+  ): Promise<operations.CreateJournalEntryResponse> {
+    return unwrapAsync(accountingAddJournalEntry(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchJournalEntry(
+    request: operations.GetJournalEntryRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetJournalEntryResponse> {
+    return unwrapAsync(accountingFetchJournalEntry(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async createJournalEntryAttachments(
+    request: operations.CreateJournalEntryAttachmentsRequest,
+    options?: RequestOptions,
+  ): Promise<operations.CreateJournalEntryAttachmentsResponse> {
+    return unwrapAsync(accountingCreateJournalEntryAttachments(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchOffers(
+    request?: operations.GetOffersRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetOffersResponse> {
+    return unwrapAsync(accountingFetchOffers(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async addOffer(
+    request: operations.CreateOfferRequest,
+    options?: RequestOptions,
+  ): Promise<operations.CreateOfferResponse> {
+    return unwrapAsync(accountingAddOffer(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchOffer(
+    request: operations.GetOfferRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetOfferResponse> {
+    return unwrapAsync(accountingFetchOffer(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchOfferLineItems(
+    request: operations.GetOfferLineItemsRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetOfferLineItemsResponse> {
+    return unwrapAsync(accountingFetchOfferLineItems(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async retrieveOfferLineItem(
+    request: operations.GetOfferLineItemRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetOfferLineItemResponse> {
+    return unwrapAsync(accountingRetrieveOfferLineItem(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async addExpense(
+    request: operations.CreateExpenseRequest,
+    options?: RequestOptions,
+  ): Promise<operations.CreateExpenseResponse> {
+    return unwrapAsync(accountingAddExpense(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchExpenses(
+    request?: operations.GetExpensesRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetExpensesResponse> {
+    return unwrapAsync(accountingFetchExpenses(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchExpense(
+    request: operations.GetExpenseRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetExpenseResponse> {
+    return unwrapAsync(accountingFetchExpense(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async getProjects(
+    request?: operations.GetProjectsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetProjectsResponse> {
+    return unwrapAsync(accountingGetProjects(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async addProject(
+    request: operations.CreateProjectRequest,
+    options?: RequestOptions,
+  ): Promise<operations.CreateProjectResponse> {
+    return unwrapAsync(accountingAddProject(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchProject(
+    request: operations.GetProjectRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetProjectResponse> {
+    return unwrapAsync(accountingFetchProject(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async listSalesOrders(
+    request?: operations.GetSalesOrdersRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetSalesOrdersResponse> {
+    return unwrapAsync(accountingListSalesOrders(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async addSalesOrder(
+    request: operations.CreateSalesOrderRequest,
+    options?: RequestOptions,
+  ): Promise<operations.CreateSalesOrderResponse> {
+    return unwrapAsync(accountingAddSalesOrder(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchSalesOrder(
+    request: operations.GetSalesOrderRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetSalesOrderResponse> {
+    return unwrapAsync(accountingFetchSalesOrder(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async listSalesOrderLineItems(
+    request: operations.GetSalesOrderLinesRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetSalesOrderLinesResponse> {
+    return unwrapAsync(accountingListSalesOrderLineItems(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async getPaymentTerms(
+    request?: operations.GetPaymentTermsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetPaymentTermsResponse> {
+    return unwrapAsync(accountingGetPaymentTerms(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async addPaymentTerm(
+    request: operations.CreatePaymentTermRequest,
+    options?: RequestOptions,
+  ): Promise<operations.CreatePaymentTermResponse> {
+    return unwrapAsync(accountingAddPaymentTerm(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchPaymentTerm(
+    request: operations.GetPaymentTermRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetPaymentTermResponse> {
+    return unwrapAsync(accountingFetchPaymentTerm(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async retrieveTaxRates(
+    request?: operations.GetTaxRatesRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetTaxRatesResponse> {
+    return unwrapAsync(accountingRetrieveTaxRates(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchTaxRate(
+    request: operations.GetTaxRateRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetTaxRateResponse> {
+    return unwrapAsync(accountingFetchTaxRate(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async retrievePayments(
+    request?: operations.GetPaymentsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetPaymentsResponse> {
+    return unwrapAsync(accountingRetrievePayments(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async addPayment(
+    request: operations.CreatePaymentRequest,
+    options?: RequestOptions,
+  ): Promise<operations.CreatePaymentResponse> {
+    return unwrapAsync(accountingAddPayment(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchPayment(
+    request: operations.GetPaymentRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetPaymentResponse> {
+    return unwrapAsync(accountingFetchPayment(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async removePayment(
+    request: operations.DeletePaymentRequest,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(accountingRemovePayment(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async addEventSubscription(
+    request: operations.CreateEventSubscriptionsRequest,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(accountingAddEventSubscription(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async removeEventSubscription(
+    request: operations.DeleteEventSubscriptionsRequest,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(accountingRemoveEventSubscription(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async getProfile(
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(accountingGetProfile(
+      this,
+      options,
+    ));
+  }
+
+  async createPassThrough(
+    request: operations.CreatePassThroughRequestRequest,
+    options?: RequestOptions,
+  ): Promise<operations.CreatePassThroughRequestResponse> {
+    return unwrapAsync(accountingCreatePassThrough(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchBills(
+    request?: operations.GetBillsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetBillsResponse> {
+    return unwrapAsync(accountingFetchBills(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async addBill(
+    request: operations.CreateBillRequest,
+    options?: RequestOptions,
+  ): Promise<operations.CreateBillResponse> {
+    return unwrapAsync(accountingAddBill(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchBill(
+    request: operations.GetBillRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetBillResponse> {
+    return unwrapAsync(accountingFetchBill(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async removeBill(
+    request: operations.DeleteBillRequest,
+    options?: RequestOptions,
+  ): Promise<void> {
+    return unwrapAsync(accountingRemoveBill(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchBillDocument(
+    request: operations.GetBillDocumentRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetBillDocumentResponse> {
+    return unwrapAsync(accountingFetchBillDocument(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async createBookingProposal(
+    request: operations.CreateBookingProposalRequest,
+    options?: RequestOptions,
+  ): Promise<operations.CreateBookingProposalResponse> {
+    return unwrapAsync(accountingCreateBookingProposal(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async listBookingProposals(
+    request?: operations.GetBookingProposalsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetBookingProposalsResponse> {
+    return unwrapAsync(accountingListBookingProposals(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async retrieveBookingProposal(
+    request: operations.GetBookingProposalRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetBookingProposalResponse> {
+    return unwrapAsync(accountingRetrieveBookingProposal(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchBookingProposalDocument(
+    request: operations.GetBookingProposalDocumentRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetBookingProposalDocumentResponse> {
+    return unwrapAsync(accountingFetchBookingProposalDocument(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async addBooking(
+    request: operations.CreateBookingsRequest,
+    options?: RequestOptions,
+  ): Promise<operations.CreateBookingsResponse> {
+    return unwrapAsync(accountingAddBooking(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async retrieveVendorCredits(
+    request?: operations.GetVendorCreditsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetVendorCreditsResponse> {
+    return unwrapAsync(accountingRetrieveVendorCredits(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async createVendorCredit(
+    request: operations.CreateVendorCreditRequest,
+    options?: RequestOptions,
+  ): Promise<operations.CreateVendorCreditResponse> {
+    return unwrapAsync(accountingCreateVendorCredit(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async modifyVendorCredit(
+    request: operations.UpdateVendorCreditRequest,
+    options?: RequestOptions,
+  ): Promise<operations.UpdateVendorCreditResponse> {
+    return unwrapAsync(accountingModifyVendorCredit(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async modifyBillLineItem(
+    request: operations.UpdateBillLineItemRequest,
+    options?: RequestOptions,
+  ): Promise<operations.UpdateBillLineItemResponse> {
+    return unwrapAsync(accountingModifyBillLineItem(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchPurchaseOrder(
+    request: operations.GetPurchaseOrderRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetPurchaseOrderResponse> {
+    return unwrapAsync(accountingFetchPurchaseOrder(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async retrievePurchaseOrderLineItems(
+    request: operations.GetPurchaseOrderLineItemsRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetPurchaseOrderLineItemsResponse> {
+    return unwrapAsync(accountingRetrievePurchaseOrderLineItems(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async retrievePurchaseOrderLineItem(
+    request: operations.GetPurchaseOrderLineItemRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetPurchaseOrderLineItemResponse> {
+    return unwrapAsync(accountingRetrievePurchaseOrderLineItem(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async getGoodsReceipts(
+    request?: operations.GetGoodsReceiptsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetGoodsReceiptsResponse> {
+    return unwrapAsync(accountingGetGoodsReceipts(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async retrieveGoodsReceipt(
+    request: operations.GetGoodsReceiptRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetGoodsReceiptResponse> {
+    return unwrapAsync(accountingRetrieveGoodsReceipt(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async retrieveGoodsReceiptLineItems(
+    request: operations.GetGoodsReceiptLineItemsRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetGoodsReceiptLineItemsResponse> {
+    return unwrapAsync(accountingRetrieveGoodsReceiptLineItems(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchUnits(
+    request?: operations.GetUnitsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetUnitsResponse> {
+    return unwrapAsync(accountingFetchUnits(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async retrieveOpenItems(
+    request?: operations.GetOpenItemsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetOpenItemsResponse> {
+    return unwrapAsync(accountingRetrieveOpenItems(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchTrialBalance(
+    request?: operations.GetTrialBalanceRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetTrialBalanceResponse> {
+    return unwrapAsync(accountingFetchTrialBalance(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async listCreditNotes(
+    request?: operations.GetCreditNotesRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetCreditNotesResponse> {
+    return unwrapAsync(accountingListCreditNotes(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async fetchCreditNote(
+    request: operations.GetCreditNoteRequest,
+    options?: RequestOptions,
+  ): Promise<operations.GetCreditNoteResponse> {
+    return unwrapAsync(accountingFetchCreditNote(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  async getFiscalYears(
+    request?: operations.GetFiscalYearsRequest | undefined,
+    options?: RequestOptions,
+  ): Promise<operations.GetFiscalYearsResponse> {
+    return unwrapAsync(accountingGetFiscalYears(
+      this,
+      request,
+      options,
+    ));
+  }
+}