@maesn/typescript-sdk 0.2.1 → 0.2.3

package/src/sdk/accounting.ts

@@ -2,103 +2,104 @@
  * 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 { accountingCreateAccount } from "../funcs/accounting-create-account.js";
+import { accountingCreateBankAccount } from "../funcs/accounting-create-bank-account.js";
+import { accountingCreateBill } from "../funcs/accounting-create-bill.js";
 import { accountingCreateBookingProposal } from "../funcs/accounting-create-booking-proposal.js";
-import { accountingCreateContactsBulk } from "../funcs/accounting-create-contacts-bulk.js";
+import { accountingCreateBookings } from "../funcs/accounting-create-bookings.js";
+import { accountingCreateContact } from "../funcs/accounting-create-contact.js";
+import { accountingCreateContactsV1 } from "../funcs/accounting-create-contacts-v1.js";
+import { accountingCreateContacts } from "../funcs/accounting-create-contacts.js";
 import { accountingCreateCustomer } from "../funcs/accounting-create-customer.js";
+import { accountingCreateEventSubscriptions } from "../funcs/accounting-create-event-subscriptions.js";
+import { accountingCreateExpense } from "../funcs/accounting-create-expense.js";
+import { accountingCreateInvoice } from "../funcs/accounting-create-invoice.js";
 import { accountingCreateJournalEntryAttachments } from "../funcs/accounting-create-journal-entry-attachments.js";
-import { accountingCreatePassThrough } from "../funcs/accounting-create-pass-through.js";
+import { accountingCreateJournalEntry } from "../funcs/accounting-create-journal-entry.js";
+import { accountingCreateLineItem } from "../funcs/accounting-create-line-item.js";
+import { accountingCreateOffer } from "../funcs/accounting-create-offer.js";
+import { accountingCreatePassThroughRequest } from "../funcs/accounting-create-pass-through-request.js";
+import { accountingCreatePaymentTerm } from "../funcs/accounting-create-payment-term.js";
+import { accountingCreatePayment } from "../funcs/accounting-create-payment.js";
+import { accountingCreateProject } from "../funcs/accounting-create-project.js";
+import { accountingCreateSalesOrder } from "../funcs/accounting-create-sales-order.js";
+import { accountingCreateSupplier } from "../funcs/accounting-create-supplier.js";
+import { accountingCreateTransaction } from "../funcs/accounting-create-transaction.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 { accountingDeleteBill } from "../funcs/accounting-delete-bill.js";
+import { accountingDeleteEventSubscriptions } from "../funcs/accounting-delete-event-subscriptions.js";
+import { accountingDeletePayment } from "../funcs/accounting-delete-payment.js";
+import { accountingGetAccount } from "../funcs/accounting-get-account.js";
+import { accountingGetAccounts } from "../funcs/accounting-get-accounts.js";
+import { accountingGetAsyncTaskInfo } from "../funcs/accounting-get-async-task-info.js";
+import { accountingGetBankAccount } from "../funcs/accounting-get-bank-account.js";
+import { accountingGetBankAccounts } from "../funcs/accounting-get-bank-accounts.js";
+import { accountingGetBillDocument } from "../funcs/accounting-get-bill-document.js";
+import { accountingGetBill } from "../funcs/accounting-get-bill.js";
+import { accountingGetBills } from "../funcs/accounting-get-bills.js";
+import { accountingGetBookingProposalDocument } from "../funcs/accounting-get-booking-proposal-document.js";
+import { accountingGetBookingProposal } from "../funcs/accounting-get-booking-proposal.js";
+import { accountingGetBookingProposals } from "../funcs/accounting-get-booking-proposals.js";
+import { accountingGetContact } from "../funcs/accounting-get-contact.js";
 import { accountingGetContacts } from "../funcs/accounting-get-contacts.js";
+import { accountingGetCreditNote } from "../funcs/accounting-get-credit-note.js";
+import { accountingGetCreditNotes } from "../funcs/accounting-get-credit-notes.js";
+import { accountingGetCustomer } from "../funcs/accounting-get-customer.js";
+import { accountingGetCustomers } from "../funcs/accounting-get-customers.js";
+import { accountingGetDimensions } from "../funcs/accounting-get-dimensions.js";
+import { accountingGetDocumentTypes } from "../funcs/accounting-get-document-types.js";
+import { accountingGetExpense } from "../funcs/accounting-get-expense.js";
+import { accountingGetExpenses } from "../funcs/accounting-get-expenses.js";
 import { accountingGetFiscalYears } from "../funcs/accounting-get-fiscal-years.js";
+import { accountingGetGoodsReceiptLineItems } from "../funcs/accounting-get-goods-receipt-line-items.js";
+import { accountingGetGoodsReceipt } from "../funcs/accounting-get-goods-receipt.js";
 import { accountingGetGoodsReceipts } from "../funcs/accounting-get-goods-receipts.js";
+import { accountingGetInvoiceDocument } from "../funcs/accounting-get-invoice-document.js";
+import { accountingGetInvoice } from "../funcs/accounting-get-invoice.js";
+import { accountingGetInvoices } from "../funcs/accounting-get-invoices.js";
+import { accountingGetItem } from "../funcs/accounting-get-item.js";
+import { accountingGetItems } from "../funcs/accounting-get-items.js";
+import { accountingGetJournalEntries } from "../funcs/accounting-get-journal-entries.js";
+import { accountingGetJournalEntry } from "../funcs/accounting-get-journal-entry.js";
+import { accountingGetJournals } from "../funcs/accounting-get-journals.js";
+import { accountingGetLineItem } from "../funcs/accounting-get-line-item.js";
+import { accountingGetLineItems } from "../funcs/accounting-get-line-items.js";
+import { accountingGetOfferLineItem } from "../funcs/accounting-get-offer-line-item.js";
+import { accountingGetOfferLineItems } from "../funcs/accounting-get-offer-line-items.js";
+import { accountingGetOffer } from "../funcs/accounting-get-offer.js";
+import { accountingGetOffers } from "../funcs/accounting-get-offers.js";
+import { accountingGetOpenItems } from "../funcs/accounting-get-open-items.js";
+import { accountingGetPaymentTerm } from "../funcs/accounting-get-payment-term.js";
 import { accountingGetPaymentTerms } from "../funcs/accounting-get-payment-terms.js";
+import { accountingGetPayment } from "../funcs/accounting-get-payment.js";
+import { accountingGetPayments } from "../funcs/accounting-get-payments.js";
 import { accountingGetProfile } from "../funcs/accounting-get-profile.js";
+import { accountingGetProject } from "../funcs/accounting-get-project.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 { accountingGetPurchaseOrderLineItem } from "../funcs/accounting-get-purchase-order-line-item.js";
+import { accountingGetPurchaseOrderLineItems } from "../funcs/accounting-get-purchase-order-line-items.js";
+import { accountingGetPurchaseOrder } from "../funcs/accounting-get-purchase-order.js";
+import { accountingGetSalesOrderLines } from "../funcs/accounting-get-sales-order-lines.js";
+import { accountingGetSalesOrder } from "../funcs/accounting-get-sales-order.js";
+import { accountingGetSalesOrders } from "../funcs/accounting-get-sales-orders.js";
+import { accountingGetSupplier } from "../funcs/accounting-get-supplier.js";
+import { accountingGetSuppliers } from "../funcs/accounting-get-suppliers.js";
+import { accountingGetTaxRate } from "../funcs/accounting-get-tax-rate.js";
+import { accountingGetTaxRates } from "../funcs/accounting-get-tax-rates.js";
+import { accountingGetTrialBalance } from "../funcs/accounting-get-trial-balance.js";
+import { accountingGetUnits } from "../funcs/accounting-get-units.js";
+import { accountingGetVendorCredits } from "../funcs/accounting-get-vendor-credits.js";
+import { accountingPatchCustomers } from "../funcs/accounting-patch-customers.js";
+import { accountingPatchInvoice } from "../funcs/accounting-patch-invoice.js";
+import { accountingPatchSupplier } from "../funcs/accounting-patch-supplier.js";
+import { accountingPostFile } from "../funcs/accounting-post-file.js";
+import { accountingPutContact } from "../funcs/accounting-put-contact.js";
+import { accountingUpdateBillLineItem } from "../funcs/accounting-update-bill-line-item.js";
 import { accountingUpdateCustomer } from "../funcs/accounting-update-customer.js";
-import { accountingUploadFile } from "../funcs/accounting-upload-file.js";
+import { accountingUpdateSupplier } from "../funcs/accounting-update-supplier.js";
+import { accountingUpdateVendorCredit } from "../funcs/accounting-update-vendor-credit.js";
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
 import * as operations from "../models/operations/index.js";
 import { unwrapAsync } from "../types/fp.js";
 import { AccountingBills } from "./accounting-bills.js";
@@ -129,99 +130,99 @@ export class Accounting extends ClientSDK {
     return (this._v2 ??= new V2(this._options));
   }
 
-  async retrieveAccount(
+  async getAccount(
     request: operations.GetAccountRequest,
     options?: RequestOptions,
   ): Promise<operations.GetAccountResponse> {
-    return unwrapAsync(accountingRetrieveAccount(
+    return unwrapAsync(accountingGetAccount(
       this,
       request,
       options,
     ));
   }
 
-  async retrieveAccounts(
+  async getAccounts(
     request?: operations.GetAccountsRequest | undefined,
     options?: RequestOptions,
   ): Promise<operations.GetAccountsResponse> {
-    return unwrapAsync(accountingRetrieveAccounts(
+    return unwrapAsync(accountingGetAccounts(
       this,
       request,
       options,
     ));
   }
 
-  async addAccount(
+  async createAccount(
     request: operations.CreateAccountRequest,
     options?: RequestOptions,
   ): Promise<operations.CreateAccountResponse> {
-    return unwrapAsync(accountingAddAccount(
+    return unwrapAsync(accountingCreateAccount(
       this,
       request,
       options,
     ));
   }
 
-  async retrieveBankAccounts(
+  async getBankAccounts(
     request?: operations.GetBankAccountsRequest | undefined,
     options?: RequestOptions,
   ): Promise<operations.GetBankAccountsResponse> {
-    return unwrapAsync(accountingRetrieveBankAccounts(
+    return unwrapAsync(accountingGetBankAccounts(
       this,
       request,
       options,
     ));
   }
 
-  async addBankAccount(
+  async createBankAccount(
     request: operations.CreateBankAccountRequest,
     options?: RequestOptions,
   ): Promise<operations.CreateBankAccountResponse> {
-    return unwrapAsync(accountingAddBankAccount(
+    return unwrapAsync(accountingCreateBankAccount(
       this,
       request,
       options,
     ));
   }
 
-  async fetchBankAccount(
+  async getBankAccount(
     request: operations.GetBankAccountRequest,
     options?: RequestOptions,
   ): Promise<operations.GetBankAccountResponse> {
-    return unwrapAsync(accountingFetchBankAccount(
+    return unwrapAsync(accountingGetBankAccount(
       this,
       request,
       options,
     ));
   }
 
-  async retrieveDimensions(
+  async getDimensions(
     request?: operations.GetDimensionsRequest | undefined,
     options?: RequestOptions,
   ): Promise<operations.GetDimensionsResponse> {
-    return unwrapAsync(accountingRetrieveDimensions(
+    return unwrapAsync(accountingGetDimensions(
       this,
       request,
       options,
     ));
   }
 
-  async recordTransaction(
+  async createTransaction(
     request: operations.CreateTransactionRequest,
     options?: RequestOptions,
   ): Promise<operations.CreateTransactionResponse> {
-    return unwrapAsync(accountingRecordTransaction(
+    return unwrapAsync(accountingCreateTransaction(
       this,
       request,
       options,
     ));
   }
 
-  async fetchCustomers(
+  async getCustomers(
     request?: operations.GetCustomersRequest | undefined,
     options?: RequestOptions,
   ): Promise<operations.GetCustomersResponse> {
-    return unwrapAsync(accountingFetchCustomers(
+    return unwrapAsync(accountingGetCustomers(
       this,
       request,
       options,
@@ -239,11 +240,11 @@ export class Accounting extends ClientSDK {
     ));
   }
 
-  async fetchCustomer(
+  async getCustomer(
     request: operations.GetCustomerRequest,
     options?: RequestOptions,
   ): Promise<operations.GetCustomerResponse> {
-    return unwrapAsync(accountingFetchCustomer(
+    return unwrapAsync(accountingGetCustomer(
       this,
       request,
       options,
@@ -261,66 +262,66 @@ export class Accounting extends ClientSDK {
     ));
   }
 
-  async amendCustomer(
+  async patchCustomers(
     request: operations.PatchCustomersRequest,
     options?: RequestOptions,
   ): Promise<operations.PatchCustomersResponse> {
-    return unwrapAsync(accountingAmendCustomer(
+    return unwrapAsync(accountingPatchCustomers(
       this,
       request,
       options,
     ));
   }
 
-  async retrieveSuppliers(
+  async getSuppliers(
     request?: operations.GetSuppliersRequest | undefined,
     options?: RequestOptions,
   ): Promise<operations.GetSuppliersResponse> {
-    return unwrapAsync(accountingRetrieveSuppliers(
+    return unwrapAsync(accountingGetSuppliers(
       this,
       request,
       options,
     ));
   }
 
-  async addSupplier(
+  async createSupplier(
     request: operations.CreateSupplierRequest,
     options?: RequestOptions,
   ): Promise<operations.CreateSupplierResponse> {
-    return unwrapAsync(accountingAddSupplier(
+    return unwrapAsync(accountingCreateSupplier(
       this,
       request,
       options,
     ));
   }
 
-  async fetchSupplier(
+  async getSupplier(
     request: operations.GetSupplierRequest,
     options?: RequestOptions,
   ): Promise<operations.GetSupplierResponse> {
-    return unwrapAsync(accountingFetchSupplier(
+    return unwrapAsync(accountingGetSupplier(
       this,
       request,
       options,
     ));
   }
 
-  async modifySupplier(
+  async updateSupplier(
     request: operations.UpdateSupplierRequest,
     options?: RequestOptions,
   ): Promise<operations.UpdateSupplierResponse> {
-    return unwrapAsync(accountingModifySupplier(
+    return unwrapAsync(accountingUpdateSupplier(
       this,
       request,
       options,
     ));
   }
 
-  async amendSupplier(
+  async patchSupplier(
     request: operations.PatchSupplierRequest,
     options?: RequestOptions,
   ): Promise<operations.PatchSupplierResponse> {
-    return unwrapAsync(accountingAmendSupplier(
+    return unwrapAsync(accountingPatchSupplier(
       this,
       request,
       options,
@@ -338,242 +339,242 @@ export class Accounting extends ClientSDK {
     ));
   }
 
-  async addContact(
+  async createContact(
     request: operations.CreateContactRequest,
     options?: RequestOptions,
   ): Promise<operations.CreateContactResponse> {
-    return unwrapAsync(accountingAddContact(
+    return unwrapAsync(accountingCreateContact(
       this,
       request,
       options,
     ));
   }
 
-  async fetchContact(
+  async getContact(
     request: operations.GetContactRequest,
     options?: RequestOptions,
   ): Promise<operations.GetContactResponse> {
-    return unwrapAsync(accountingFetchContact(
+    return unwrapAsync(accountingGetContact(
       this,
       request,
       options,
     ));
   }
 
-  async replaceContact(
+  async putContact(
     request: operations.PutContactRequest,
     options?: RequestOptions,
   ): Promise<operations.PutContactResponse> {
-    return unwrapAsync(accountingReplaceContact(
+    return unwrapAsync(accountingPutContact(
       this,
       request,
       options,
     ));
   }
 
-  async createContactsBulk(
+  async createContacts(
     request: operations.CreateContactsRequest,
     options?: RequestOptions,
   ): Promise<operations.CreateContactsResponse> {
-    return unwrapAsync(accountingCreateContactsBulk(
+    return unwrapAsync(accountingCreateContacts(
       this,
       request,
       options,
     ));
   }
 
-  async batchAddContacts(
+  async createContactsV1(
     request: operations.CreateContactsV1Request,
     options?: RequestOptions,
   ): Promise<operations.CreateContactsV1Response> {
-    return unwrapAsync(accountingBatchAddContacts(
+    return unwrapAsync(accountingCreateContactsV1(
       this,
       request,
       options,
     ));
   }
 
-  async retrieveInvoices(
+  async getInvoices(
     request?: operations.GetInvoicesRequest | undefined,
     options?: RequestOptions,
   ): Promise<operations.GetInvoicesResponse> {
-    return unwrapAsync(accountingRetrieveInvoices(
+    return unwrapAsync(accountingGetInvoices(
       this,
       request,
       options,
     ));
   }
 
-  async addInvoice(
+  async createInvoice(
     request: operations.CreateInvoiceRequest,
     options?: RequestOptions,
   ): Promise<operations.CreateInvoiceResponse> {
-    return unwrapAsync(accountingAddInvoice(
+    return unwrapAsync(accountingCreateInvoice(
       this,
       request,
       options,
     ));
   }
 
-  async fetchInvoice(
+  async getInvoice(
     request: operations.GetInvoiceRequest,
     options?: RequestOptions,
   ): Promise<operations.GetInvoiceResponse> {
-    return unwrapAsync(accountingFetchInvoice(
+    return unwrapAsync(accountingGetInvoice(
       this,
       request,
       options,
     ));
   }
 
-  async amendInvoice(
+  async patchInvoice(
     request: operations.PatchInvoiceRequest,
     options?: RequestOptions,
   ): Promise<operations.PatchInvoiceResponse> {
-    return unwrapAsync(accountingAmendInvoice(
+    return unwrapAsync(accountingPatchInvoice(
       this,
       request,
       options,
     ));
   }
 
-  async fetchInvoiceDocument(
+  async getInvoiceDocument(
     request: operations.GetInvoiceDocumentRequest,
     options?: RequestOptions,
   ): Promise<operations.GetInvoiceDocumentResponse> {
-    return unwrapAsync(accountingFetchInvoiceDocument(
+    return unwrapAsync(accountingGetInvoiceDocument(
       this,
       request,
       options,
     ));
   }
 
-  async uploadFile(
+  async postFile(
     request: operations.PostFileRequest,
     options?: RequestOptions,
   ): Promise<operations.PostFileResponse> {
-    return unwrapAsync(accountingUploadFile(
+    return unwrapAsync(accountingPostFile(
       this,
       request,
       options,
     ));
   }
 
-  async fetchDocumentTypes(
+  async getDocumentTypes(
     request?: operations.GetDocumentTypesRequest | undefined,
     options?: RequestOptions,
   ): Promise<operations.GetDocumentTypesResponse> {
-    return unwrapAsync(accountingFetchDocumentTypes(
+    return unwrapAsync(accountingGetDocumentTypes(
       this,
       request,
       options,
     ));
   }
 
-  async getAsyncTask(
+  async getAsyncTaskInfo(
     request: operations.GetAsyncTaskInfoRequest,
     options?: RequestOptions,
   ): Promise<operations.GetAsyncTaskInfoResponse> {
-    return unwrapAsync(accountingGetAsyncTask(
+    return unwrapAsync(accountingGetAsyncTaskInfo(
       this,
       request,
       options,
     ));
   }
 
-  async retrieveItems(
+  async getItems(
     request?: operations.GetItemsRequest | undefined,
     options?: RequestOptions,
   ): Promise<operations.GetItemsResponse> {
-    return unwrapAsync(accountingRetrieveItems(
+    return unwrapAsync(accountingGetItems(
       this,
       request,
       options,
     ));
   }
 
-  async fetchItem(
+  async getItem(
     request: operations.GetItemRequest,
     options?: RequestOptions,
   ): Promise<operations.GetItemResponse> {
-    return unwrapAsync(accountingFetchItem(
+    return unwrapAsync(accountingGetItem(
       this,
       request,
       options,
     ));
   }
 
-  async retrieveInvoiceLineItems(
+  async getLineItems(
     request: operations.GetLineItemsRequest,
     options?: RequestOptions,
   ): Promise<operations.GetLineItemsResponse> {
-    return unwrapAsync(accountingRetrieveInvoiceLineItems(
+    return unwrapAsync(accountingGetLineItems(
       this,
       request,
       options,
     ));
   }
 
-  async addInvoiceLineItem(
+  async createLineItem(
     request: operations.CreateLineItemRequest,
     options?: RequestOptions,
   ): Promise<operations.CreateLineItemResponse> {
-    return unwrapAsync(accountingAddInvoiceLineItem(
+    return unwrapAsync(accountingCreateLineItem(
       this,
       request,
       options,
     ));
   }
 
-  async retrieveInvoiceLineItem(
+  async getLineItem(
     request: operations.GetLineItemRequest,
     options?: RequestOptions,
   ): Promise<operations.GetLineItemResponse> {
-    return unwrapAsync(accountingRetrieveInvoiceLineItem(
+    return unwrapAsync(accountingGetLineItem(
       this,
       request,
       options,
     ));
   }
 
-  async fetchJournals(
+  async getJournals(
     request?: operations.GetJournalsRequest | undefined,
     options?: RequestOptions,
   ): Promise<operations.GetJournalsResponse> {
-    return unwrapAsync(accountingFetchJournals(
+    return unwrapAsync(accountingGetJournals(
       this,
       request,
       options,
     ));
   }
 
-  async listJournalEntries(
+  async getJournalEntries(
     request?: operations.GetJournalEntriesRequest | undefined,
     options?: RequestOptions,
   ): Promise<operations.GetJournalEntriesResponse> {
-    return unwrapAsync(accountingListJournalEntries(
+    return unwrapAsync(accountingGetJournalEntries(
       this,
       request,
       options,
     ));
   }
 
-  async addJournalEntry(
+  async createJournalEntry(
     request: operations.CreateJournalEntryRequest,
     options?: RequestOptions,
   ): Promise<operations.CreateJournalEntryResponse> {
-    return unwrapAsync(accountingAddJournalEntry(
+    return unwrapAsync(accountingCreateJournalEntry(
       this,
       request,
       options,
     ));
   }
 
-  async fetchJournalEntry(
+  async getJournalEntry(
     request: operations.GetJournalEntryRequest,
     options?: RequestOptions,
   ): Promise<operations.GetJournalEntryResponse> {
-    return unwrapAsync(accountingFetchJournalEntry(
+    return unwrapAsync(accountingGetJournalEntry(
       this,
       request,
       options,
@@ -591,88 +592,88 @@ export class Accounting extends ClientSDK {
     ));
   }
 
-  async fetchOffers(
+  async getOffers(
     request?: operations.GetOffersRequest | undefined,
     options?: RequestOptions,
   ): Promise<operations.GetOffersResponse> {
-    return unwrapAsync(accountingFetchOffers(
+    return unwrapAsync(accountingGetOffers(
       this,
       request,
       options,
     ));
   }
 
-  async addOffer(
+  async createOffer(
     request: operations.CreateOfferRequest,
     options?: RequestOptions,
   ): Promise<operations.CreateOfferResponse> {
-    return unwrapAsync(accountingAddOffer(
+    return unwrapAsync(accountingCreateOffer(
       this,
       request,
       options,
     ));
   }
 
-  async fetchOffer(
+  async getOffer(
     request: operations.GetOfferRequest,
     options?: RequestOptions,
   ): Promise<operations.GetOfferResponse> {
-    return unwrapAsync(accountingFetchOffer(
+    return unwrapAsync(accountingGetOffer(
       this,
       request,
       options,
     ));
   }
 
-  async fetchOfferLineItems(
+  async getOfferLineItems(
     request: operations.GetOfferLineItemsRequest,
     options?: RequestOptions,
   ): Promise<operations.GetOfferLineItemsResponse> {
-    return unwrapAsync(accountingFetchOfferLineItems(
+    return unwrapAsync(accountingGetOfferLineItems(
       this,
       request,
       options,
     ));
   }
 
-  async retrieveOfferLineItem(
+  async getOfferLineItem(
     request: operations.GetOfferLineItemRequest,
     options?: RequestOptions,
   ): Promise<operations.GetOfferLineItemResponse> {
-    return unwrapAsync(accountingRetrieveOfferLineItem(
+    return unwrapAsync(accountingGetOfferLineItem(
       this,
       request,
       options,
     ));
   }
 
-  async addExpense(
+  async createExpense(
     request: operations.CreateExpenseRequest,
     options?: RequestOptions,
   ): Promise<operations.CreateExpenseResponse> {
-    return unwrapAsync(accountingAddExpense(
+    return unwrapAsync(accountingCreateExpense(
       this,
       request,
       options,
     ));
   }
 
-  async fetchExpenses(
+  async getExpenses(
     request?: operations.GetExpensesRequest | undefined,
     options?: RequestOptions,
   ): Promise<operations.GetExpensesResponse> {
-    return unwrapAsync(accountingFetchExpenses(
+    return unwrapAsync(accountingGetExpenses(
       this,
       request,
       options,
     ));
   }
 
-  async fetchExpense(
+  async getExpense(
     request: operations.GetExpenseRequest,
     options?: RequestOptions,
   ): Promise<operations.GetExpenseResponse> {
-    return unwrapAsync(accountingFetchExpense(
+    return unwrapAsync(accountingGetExpense(
       this,
       request,
       options,
@@ -690,66 +691,66 @@ export class Accounting extends ClientSDK {
     ));
   }
 
-  async addProject(
+  async createProject(
     request: operations.CreateProjectRequest,
     options?: RequestOptions,
   ): Promise<operations.CreateProjectResponse> {
-    return unwrapAsync(accountingAddProject(
+    return unwrapAsync(accountingCreateProject(
       this,
       request,
       options,
     ));
   }
 
-  async fetchProject(
+  async getProject(
     request: operations.GetProjectRequest,
     options?: RequestOptions,
   ): Promise<operations.GetProjectResponse> {
-    return unwrapAsync(accountingFetchProject(
+    return unwrapAsync(accountingGetProject(
       this,
       request,
       options,
     ));
   }
 
-  async listSalesOrders(
+  async getSalesOrders(
     request?: operations.GetSalesOrdersRequest | undefined,
     options?: RequestOptions,
   ): Promise<operations.GetSalesOrdersResponse> {
-    return unwrapAsync(accountingListSalesOrders(
+    return unwrapAsync(accountingGetSalesOrders(
       this,
       request,
       options,
     ));
   }
 
-  async addSalesOrder(
+  async createSalesOrder(
     request: operations.CreateSalesOrderRequest,
     options?: RequestOptions,
   ): Promise<operations.CreateSalesOrderResponse> {
-    return unwrapAsync(accountingAddSalesOrder(
+    return unwrapAsync(accountingCreateSalesOrder(
       this,
       request,
       options,
     ));
   }
 
-  async fetchSalesOrder(
+  async getSalesOrder(
     request: operations.GetSalesOrderRequest,
     options?: RequestOptions,
   ): Promise<operations.GetSalesOrderResponse> {
-    return unwrapAsync(accountingFetchSalesOrder(
+    return unwrapAsync(accountingGetSalesOrder(
       this,
       request,
       options,
     ));
   }
 
-  async listSalesOrderLineItems(
+  async getSalesOrderLines(
     request: operations.GetSalesOrderLinesRequest,
     options?: RequestOptions,
   ): Promise<operations.GetSalesOrderLinesResponse> {
-    return unwrapAsync(accountingListSalesOrderLineItems(
+    return unwrapAsync(accountingGetSalesOrderLines(
       this,
       request,
       options,
@@ -767,110 +768,110 @@ export class Accounting extends ClientSDK {
     ));
   }
 
-  async addPaymentTerm(
+  async createPaymentTerm(
     request: operations.CreatePaymentTermRequest,
     options?: RequestOptions,
   ): Promise<operations.CreatePaymentTermResponse> {
-    return unwrapAsync(accountingAddPaymentTerm(
+    return unwrapAsync(accountingCreatePaymentTerm(
       this,
       request,
       options,
     ));
   }
 
-  async fetchPaymentTerm(
+  async getPaymentTerm(
     request: operations.GetPaymentTermRequest,
     options?: RequestOptions,
   ): Promise<operations.GetPaymentTermResponse> {
-    return unwrapAsync(accountingFetchPaymentTerm(
+    return unwrapAsync(accountingGetPaymentTerm(
       this,
       request,
       options,
     ));
   }
 
-  async retrieveTaxRates(
+  async getTaxRates(
     request?: operations.GetTaxRatesRequest | undefined,
     options?: RequestOptions,
   ): Promise<operations.GetTaxRatesResponse> {
-    return unwrapAsync(accountingRetrieveTaxRates(
+    return unwrapAsync(accountingGetTaxRates(
       this,
       request,
       options,
     ));
   }
 
-  async fetchTaxRate(
+  async getTaxRate(
     request: operations.GetTaxRateRequest,
     options?: RequestOptions,
   ): Promise<operations.GetTaxRateResponse> {
-    return unwrapAsync(accountingFetchTaxRate(
+    return unwrapAsync(accountingGetTaxRate(
       this,
       request,
       options,
     ));
   }
 
-  async retrievePayments(
+  async getPayments(
     request?: operations.GetPaymentsRequest | undefined,
     options?: RequestOptions,
   ): Promise<operations.GetPaymentsResponse> {
-    return unwrapAsync(accountingRetrievePayments(
+    return unwrapAsync(accountingGetPayments(
       this,
       request,
       options,
     ));
   }
 
-  async addPayment(
+  async createPayment(
     request: operations.CreatePaymentRequest,
     options?: RequestOptions,
   ): Promise<operations.CreatePaymentResponse> {
-    return unwrapAsync(accountingAddPayment(
+    return unwrapAsync(accountingCreatePayment(
       this,
       request,
       options,
     ));
   }
 
-  async fetchPayment(
+  async getPayment(
     request: operations.GetPaymentRequest,
     options?: RequestOptions,
   ): Promise<operations.GetPaymentResponse> {
-    return unwrapAsync(accountingFetchPayment(
+    return unwrapAsync(accountingGetPayment(
       this,
       request,
       options,
     ));
   }
 
-  async removePayment(
+  async deletePayment(
     request: operations.DeletePaymentRequest,
     options?: RequestOptions,
-  ): Promise<void> {
-    return unwrapAsync(accountingRemovePayment(
+  ): Promise<operations.DeletePaymentResponse> {
+    return unwrapAsync(accountingDeletePayment(
       this,
       request,
       options,
     ));
   }
 
-  async addEventSubscription(
+  async createEventSubscriptions(
     request: operations.CreateEventSubscriptionsRequest,
     options?: RequestOptions,
-  ): Promise<void> {
-    return unwrapAsync(accountingAddEventSubscription(
+  ): Promise<models.BaseResponseDto> {
+    return unwrapAsync(accountingCreateEventSubscriptions(
       this,
       request,
       options,
     ));
   }
 
-  async removeEventSubscription(
+  async deleteEventSubscriptions(
     request: operations.DeleteEventSubscriptionsRequest,
     options?: RequestOptions,
-  ): Promise<void> {
-    return unwrapAsync(accountingRemoveEventSubscription(
+  ): Promise<models.BaseResponseDto> {
+    return unwrapAsync(accountingDeleteEventSubscriptions(
       this,
       request,
       options,
@@ -879,73 +880,73 @@ export class Accounting extends ClientSDK {
 
   async getProfile(
     options?: RequestOptions,
-  ): Promise<void> {
+  ): Promise<models.BaseResponseDto> {
     return unwrapAsync(accountingGetProfile(
       this,
       options,
     ));
   }
 
-  async createPassThrough(
+  async createPassThroughRequest(
     request: operations.CreatePassThroughRequestRequest,
     options?: RequestOptions,
   ): Promise<operations.CreatePassThroughRequestResponse> {
-    return unwrapAsync(accountingCreatePassThrough(
+    return unwrapAsync(accountingCreatePassThroughRequest(
       this,
       request,
       options,
     ));
   }
 
-  async fetchBills(
+  async getBills(
     request?: operations.GetBillsRequest | undefined,
     options?: RequestOptions,
   ): Promise<operations.GetBillsResponse> {
-    return unwrapAsync(accountingFetchBills(
+    return unwrapAsync(accountingGetBills(
       this,
       request,
       options,
     ));
   }
 
-  async addBill(
+  async createBill(
     request: operations.CreateBillRequest,
     options?: RequestOptions,
   ): Promise<operations.CreateBillResponse> {
-    return unwrapAsync(accountingAddBill(
+    return unwrapAsync(accountingCreateBill(
       this,
       request,
       options,
     ));
   }
 
-  async fetchBill(
+  async getBill(
     request: operations.GetBillRequest,
     options?: RequestOptions,
   ): Promise<operations.GetBillResponse> {
-    return unwrapAsync(accountingFetchBill(
+    return unwrapAsync(accountingGetBill(
       this,
       request,
       options,
     ));
   }
 
-  async removeBill(
+  async deleteBill(
     request: operations.DeleteBillRequest,
     options?: RequestOptions,
-  ): Promise<void> {
-    return unwrapAsync(accountingRemoveBill(
+  ): Promise<operations.DeleteBillResponse> {
+    return unwrapAsync(accountingDeleteBill(
       this,
       request,
       options,
     ));
   }
 
-  async fetchBillDocument(
+  async getBillDocument(
     request: operations.GetBillDocumentRequest,
     options?: RequestOptions,
   ): Promise<operations.GetBillDocumentResponse> {
-    return unwrapAsync(accountingFetchBillDocument(
+    return unwrapAsync(accountingGetBillDocument(
       this,
       request,
       options,
@@ -963,55 +964,55 @@ export class Accounting extends ClientSDK {
     ));
   }
 
-  async listBookingProposals(
+  async getBookingProposals(
     request?: operations.GetBookingProposalsRequest | undefined,
     options?: RequestOptions,
   ): Promise<operations.GetBookingProposalsResponse> {
-    return unwrapAsync(accountingListBookingProposals(
+    return unwrapAsync(accountingGetBookingProposals(
       this,
       request,
       options,
     ));
   }
 
-  async retrieveBookingProposal(
+  async getBookingProposal(
     request: operations.GetBookingProposalRequest,
     options?: RequestOptions,
   ): Promise<operations.GetBookingProposalResponse> {
-    return unwrapAsync(accountingRetrieveBookingProposal(
+    return unwrapAsync(accountingGetBookingProposal(
       this,
       request,
       options,
     ));
   }
 
-  async fetchBookingProposalDocument(
+  async getBookingProposalDocument(
     request: operations.GetBookingProposalDocumentRequest,
     options?: RequestOptions,
   ): Promise<operations.GetBookingProposalDocumentResponse> {
-    return unwrapAsync(accountingFetchBookingProposalDocument(
+    return unwrapAsync(accountingGetBookingProposalDocument(
       this,
       request,
       options,
     ));
   }
 
-  async addBooking(
+  async createBookings(
     request: operations.CreateBookingsRequest,
     options?: RequestOptions,
   ): Promise<operations.CreateBookingsResponse> {
-    return unwrapAsync(accountingAddBooking(
+    return unwrapAsync(accountingCreateBookings(
       this,
       request,
       options,
     ));
   }
 
-  async retrieveVendorCredits(
+  async getVendorCredits(
     request?: operations.GetVendorCreditsRequest | undefined,
     options?: RequestOptions,
   ): Promise<operations.GetVendorCreditsResponse> {
-    return unwrapAsync(accountingRetrieveVendorCredits(
+    return unwrapAsync(accountingGetVendorCredits(
       this,
       request,
       options,
@@ -1029,55 +1030,55 @@ export class Accounting extends ClientSDK {
     ));
   }
 
-  async modifyVendorCredit(
+  async updateVendorCredit(
     request: operations.UpdateVendorCreditRequest,
     options?: RequestOptions,
   ): Promise<operations.UpdateVendorCreditResponse> {
-    return unwrapAsync(accountingModifyVendorCredit(
+    return unwrapAsync(accountingUpdateVendorCredit(
       this,
       request,
       options,
     ));
   }
 
-  async modifyBillLineItem(
+  async updateBillLineItem(
     request: operations.UpdateBillLineItemRequest,
     options?: RequestOptions,
   ): Promise<operations.UpdateBillLineItemResponse> {
-    return unwrapAsync(accountingModifyBillLineItem(
+    return unwrapAsync(accountingUpdateBillLineItem(
       this,
       request,
       options,
     ));
   }
 
-  async fetchPurchaseOrder(
+  async getPurchaseOrder(
     request: operations.GetPurchaseOrderRequest,
     options?: RequestOptions,
   ): Promise<operations.GetPurchaseOrderResponse> {
-    return unwrapAsync(accountingFetchPurchaseOrder(
+    return unwrapAsync(accountingGetPurchaseOrder(
       this,
       request,
       options,
     ));
   }
 
-  async retrievePurchaseOrderLineItems(
+  async getPurchaseOrderLineItems(
     request: operations.GetPurchaseOrderLineItemsRequest,
     options?: RequestOptions,
   ): Promise<operations.GetPurchaseOrderLineItemsResponse> {
-    return unwrapAsync(accountingRetrievePurchaseOrderLineItems(
+    return unwrapAsync(accountingGetPurchaseOrderLineItems(
       this,
       request,
       options,
     ));
   }
 
-  async retrievePurchaseOrderLineItem(
+  async getPurchaseOrderLineItem(
     request: operations.GetPurchaseOrderLineItemRequest,
     options?: RequestOptions,
   ): Promise<operations.GetPurchaseOrderLineItemResponse> {
-    return unwrapAsync(accountingRetrievePurchaseOrderLineItem(
+    return unwrapAsync(accountingGetPurchaseOrderLineItem(
       this,
       request,
       options,
@@ -1095,77 +1096,77 @@ export class Accounting extends ClientSDK {
     ));
   }
 
-  async retrieveGoodsReceipt(
+  async getGoodsReceipt(
     request: operations.GetGoodsReceiptRequest,
     options?: RequestOptions,
   ): Promise<operations.GetGoodsReceiptResponse> {
-    return unwrapAsync(accountingRetrieveGoodsReceipt(
+    return unwrapAsync(accountingGetGoodsReceipt(
       this,
       request,
       options,
     ));
   }
 
-  async retrieveGoodsReceiptLineItems(
+  async getGoodsReceiptLineItems(
     request: operations.GetGoodsReceiptLineItemsRequest,
     options?: RequestOptions,
   ): Promise<operations.GetGoodsReceiptLineItemsResponse> {
-    return unwrapAsync(accountingRetrieveGoodsReceiptLineItems(
+    return unwrapAsync(accountingGetGoodsReceiptLineItems(
       this,
       request,
       options,
     ));
   }
 
-  async fetchUnits(
+  async getUnits(
     request?: operations.GetUnitsRequest | undefined,
     options?: RequestOptions,
   ): Promise<operations.GetUnitsResponse> {
-    return unwrapAsync(accountingFetchUnits(
+    return unwrapAsync(accountingGetUnits(
       this,
       request,
       options,
     ));
   }
 
-  async retrieveOpenItems(
+  async getOpenItems(
     request?: operations.GetOpenItemsRequest | undefined,
     options?: RequestOptions,
   ): Promise<operations.GetOpenItemsResponse> {
-    return unwrapAsync(accountingRetrieveOpenItems(
+    return unwrapAsync(accountingGetOpenItems(
       this,
       request,
       options,
     ));
   }
 
-  async fetchTrialBalance(
+  async getTrialBalance(
     request?: operations.GetTrialBalanceRequest | undefined,
     options?: RequestOptions,
   ): Promise<operations.GetTrialBalanceResponse> {
-    return unwrapAsync(accountingFetchTrialBalance(
+    return unwrapAsync(accountingGetTrialBalance(
       this,
       request,
       options,
     ));
   }
 
-  async listCreditNotes(
+  async getCreditNotes(
     request?: operations.GetCreditNotesRequest | undefined,
     options?: RequestOptions,
   ): Promise<operations.GetCreditNotesResponse> {
-    return unwrapAsync(accountingListCreditNotes(
+    return unwrapAsync(accountingGetCreditNotes(
       this,
       request,
       options,
     ));
   }
 
-  async fetchCreditNote(
+  async getCreditNote(
     request: operations.GetCreditNoteRequest,
     options?: RequestOptions,
   ): Promise<operations.GetCreditNoteResponse> {
-    return unwrapAsync(accountingFetchCreditNote(
+    return unwrapAsync(accountingGetCreditNote(
       this,
       request,
       options,