@commercelayer/sdk 4.27.1 → 4.28.1

package/lib/esm/model.d.ts

@@ -1,5 +1,5 @@
 /**
- * ©2023 Commerce Layer Inc.
+ * ©2024 Commerce Layer Inc.
  **/
 export type { Address, AddressCreate, AddressUpdate } from './resources/addresses';
 export type { Adjustment, AdjustmentCreate, AdjustmentUpdate } from './resources/adjustments';
@@ -16,6 +16,7 @@ export type { BingGeocoder, BingGeocoderCreate, BingGeocoderUpdate } from './res
 export type { BraintreeGateway, BraintreeGatewayCreate, BraintreeGatewayUpdate } from './resources/braintree_gateways';
 export type { BraintreePayment, BraintreePaymentCreate, BraintreePaymentUpdate } from './resources/braintree_payments';
 export type { Bundle, BundleCreate, BundleUpdate } from './resources/bundles';
+export type { BuyXPayYPromotion, BuyXPayYPromotionCreate, BuyXPayYPromotionUpdate } from './resources/buy_x_pay_y_promotions';
 export type { Capture, CaptureUpdate } from './resources/captures';
 export type { CarrierAccount } from './resources/carrier_accounts';
 export type { CheckoutComGateway, CheckoutComGatewayCreate, CheckoutComGatewayUpdate } from './resources/checkout_com_gateways';
@@ -24,6 +25,7 @@ export type { Cleanup, CleanupCreate } from './resources/cleanups';
 export type { CouponCodesPromotionRule, CouponCodesPromotionRuleCreate, CouponCodesPromotionRuleUpdate } from './resources/coupon_codes_promotion_rules';
 export type { CouponRecipient, CouponRecipientCreate, CouponRecipientUpdate } from './resources/coupon_recipients';
 export type { Coupon, CouponCreate, CouponUpdate } from './resources/coupons';
+export type { CustomPromotionRule, CustomPromotionRuleCreate, CustomPromotionRuleUpdate } from './resources/custom_promotion_rules';
 export type { CustomerAddress, CustomerAddressCreate, CustomerAddressUpdate } from './resources/customer_addresses';
 export type { CustomerGroup, CustomerGroupCreate, CustomerGroupUpdate } from './resources/customer_groups';
 export type { CustomerPasswordReset, CustomerPasswordResetCreate, CustomerPasswordResetUpdate } from './resources/customer_password_resets';
@@ -72,6 +74,7 @@ export type { ParcelLineItem, ParcelLineItemCreate, ParcelLineItemUpdate } from
 export type { Parcel, ParcelCreate, ParcelUpdate } from './resources/parcels';
 export type { PaymentGateway } from './resources/payment_gateways';
 export type { PaymentMethod, PaymentMethodCreate, PaymentMethodUpdate } from './resources/payment_methods';
+export type { PaymentOption, PaymentOptionCreate, PaymentOptionUpdate } from './resources/payment_options';
 export type { PaypalGateway, PaypalGatewayCreate, PaypalGatewayUpdate } from './resources/paypal_gateways';
 export type { PaypalPayment, PaypalPaymentCreate, PaypalPaymentUpdate } from './resources/paypal_payments';
 export type { PercentageDiscountPromotion, PercentageDiscountPromotionCreate, PercentageDiscountPromotionUpdate } from './resources/percentage_discount_promotions';
@@ -84,11 +87,12 @@ export type { PromotionRule } from './resources/promotion_rules';
 export type { Promotion } from './resources/promotions';
 export type { RecurringOrderCopy, RecurringOrderCopyCreate, RecurringOrderCopyUpdate } from './resources/recurring_order_copies';
 export type { Refund } from './resources/refunds';
+export type { ReservedStock } from './resources/reserved_stocks';
 export type { ReturnLineItem, ReturnLineItemCreate, ReturnLineItemUpdate } from './resources/return_line_items';
 export type { Return, ReturnCreate, ReturnUpdate } from './resources/returns';
 export type { SatispayGateway, SatispayGatewayCreate, SatispayGatewayUpdate } from './resources/satispay_gateways';
 export type { SatispayPayment, SatispayPaymentCreate, SatispayPaymentUpdate } from './resources/satispay_payments';
-export type { Shipment, ShipmentUpdate } from './resources/shipments';
+export type { Shipment, ShipmentCreate, ShipmentUpdate } from './resources/shipments';
 export type { ShippingCategory, ShippingCategoryCreate, ShippingCategoryUpdate } from './resources/shipping_categories';
 export type { ShippingMethodTier } from './resources/shipping_method_tiers';
 export type { ShippingMethod, ShippingMethodCreate, ShippingMethodUpdate } from './resources/shipping_methods';
@@ -100,17 +104,20 @@ export type { SkuList, SkuListCreate, SkuListUpdate } from './resources/sku_list
 export type { SkuOption, SkuOptionCreate, SkuOptionUpdate } from './resources/sku_options';
 export type { Sku, SkuCreate, SkuUpdate } from './resources/skus';
 export type { StockItem, StockItemCreate, StockItemUpdate } from './resources/stock_items';
-export type { StockLineItem } from './resources/stock_line_items';
+export type { StockLineItem, StockLineItemCreate, StockLineItemUpdate } from './resources/stock_line_items';
 export type { StockLocation, StockLocationCreate, StockLocationUpdate } from './resources/stock_locations';
+export type { StockReservation, StockReservationCreate, StockReservationUpdate } from './resources/stock_reservations';
 export type { StockTransfer, StockTransferCreate, StockTransferUpdate } from './resources/stock_transfers';
 export type { StripeGateway, StripeGatewayCreate, StripeGatewayUpdate } from './resources/stripe_gateways';
 export type { StripePayment, StripePaymentCreate, StripePaymentUpdate } from './resources/stripe_payments';
 export type { SubscriptionModel, SubscriptionModelCreate, SubscriptionModelUpdate } from './resources/subscription_models';
+export type { Tag, TagCreate, TagUpdate } from './resources/tags';
 export type { TaxCalculator } from './resources/tax_calculators';
 export type { TaxCategory, TaxCategoryCreate, TaxCategoryUpdate } from './resources/tax_categories';
 export type { TaxRule, TaxRuleCreate, TaxRuleUpdate } from './resources/tax_rules';
 export type { TaxjarAccount, TaxjarAccountCreate, TaxjarAccountUpdate } from './resources/taxjar_accounts';
 export type { Transaction } from './resources/transactions';
+export type { Version } from './resources/versions';
 export type { Void } from './resources/voids';
 export type { Webhook, WebhookCreate, WebhookUpdate } from './resources/webhooks';
 export type { WireTransfer, WireTransferCreate, WireTransferUpdate } from './resources/wire_transfers';

package/lib/esm/resource.d.ts

@@ -1,15 +1,13 @@
-import { ApiClientInitConfig } from './client';
-import { QueryParamsRetrieve, QueryParamsList } from './query';
-import { ResourceTypeLock } from './api';
-import { InterceptorManager } from './interceptor';
-import { QueryParams } from '.';
+import { type ApiClientInitConfig } from './client';
+import { type QueryParamsRetrieve, type QueryParamsList } from './query';
+import type { ResourceTypeLock } from './api';
+import type { InterceptorManager } from './interceptor';
+import type { QueryParams } from '.';
 type ResourceNull = {
     id: null;
 } & ResourceType;
 type ResourceRel = ResourceId | ResourceNull;
-type Metadata = {
-    [key: string]: any;
-};
+type Metadata = Record<string, any>;
 interface ResourceType {
     readonly type: ResourceTypeLock;
 }
@@ -74,4 +72,4 @@ declare abstract class ApiResource {
     update(resource: ResourceUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Resource>;
 }
 export default ResourceAdapter;
-export { ApiResource, ResourcesConfig, ResourcesInitConfig };
+export { ApiResource, type ResourcesConfig, type ResourcesInitConfig };

package/lib/esm/resources/addresses.d.ts

@@ -1,12 +1,18 @@
 import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourcesConfig, ResourceId, ResourceRel, ListResponse } from '../resource';
 import type { QueryParamsList, QueryParamsRetrieve } from '../query';
 import type { Geocoder } from './geocoders';
+import type { Event } from './events';
+import type { Tag } from './tags';
+import type { Version } from './versions';
 type AddressRel = ResourceRel & {
     type: typeof Addresses.TYPE;
 };
 type GeocoderRel = ResourceRel & {
     type: 'geocoders';
 };
+type TagRel = ResourceRel & {
+    type: 'tags';
+};
 interface Address extends Resource {
     business?: boolean;
     first_name?: string;
@@ -33,6 +39,9 @@ interface Address extends Resource {
     static_map_url?: string;
     billing_info?: string;
     geocoder?: Geocoder;
+    events?: Event[];
+    tags?: Tag[];
+    versions?: Version[];
 }
 interface AddressCreate extends ResourceCreate {
     business?: boolean;
@@ -52,6 +61,7 @@ interface AddressCreate extends ResourceCreate {
     lng?: number;
     billing_info?: string;
     geocoder?: GeocoderRel;
+    tags?: TagRel[];
 }
 interface AddressUpdate extends ResourceUpdate {
     business?: boolean;
@@ -71,6 +81,7 @@ interface AddressUpdate extends ResourceUpdate {
     lng?: number;
     billing_info?: string;
     geocoder?: GeocoderRel;
+    tags?: TagRel[];
 }
 declare class Addresses extends ApiResource {
     static readonly TYPE: 'addresses';
@@ -80,6 +91,9 @@ declare class Addresses extends ApiResource {
     update(resource: AddressUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Address>;
     delete(id: string, options?: ResourcesConfig): Promise<void>;
     geocoder(addressId: string | Address, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Geocoder>;
+    events(addressId: string | Address, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
+    tags(addressId: string | Address, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Tag>>;
+    versions(addressId: string | Address, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isAddress(resource: any): resource is Address;
     relationship(id: string | ResourceId | null): AddressRel;
     type(): string;

package/lib/esm/resources/addresses.js

@@ -20,6 +20,18 @@ class Addresses extends ApiResource {
         const _addressId = addressId.id || addressId;
         return this.resources.fetch({ type: 'geocoders' }, `addresses/${_addressId}/geocoder`, params, options);
     }
+    async events(addressId, params, options) {
+        const _addressId = addressId.id || addressId;
+        return this.resources.fetch({ type: 'events' }, `addresses/${_addressId}/events`, params, options);
+    }
+    async tags(addressId, params, options) {
+        const _addressId = addressId.id || addressId;
+        return this.resources.fetch({ type: 'tags' }, `addresses/${_addressId}/tags`, params, options);
+    }
+    async versions(addressId, params, options) {
+        const _addressId = addressId.id || addressId;
+        return this.resources.fetch({ type: 'versions' }, `addresses/${_addressId}/versions`, params, options);
+    }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     isAddress(resource) {
         return resource.type && (resource.type === Addresses.TYPE);

package/lib/esm/resources/adjustments.d.ts

@@ -1,5 +1,6 @@
 import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourcesConfig, ResourceId, ResourceRel, ListResponse } from '../resource';
 import type { QueryParamsList, QueryParamsRetrieve } from '../query';
+import type { Version } from './versions';
 type AdjustmentRel = ResourceRel & {
     type: typeof Adjustments.TYPE;
 };
@@ -9,6 +10,7 @@ interface Adjustment extends Resource {
     amount_cents?: number;
     amount_float?: number;
     formatted_amount?: string;
+    versions?: Version[];
 }
 interface AdjustmentCreate extends ResourceCreate {
     name: string;
@@ -27,6 +29,7 @@ declare class Adjustments extends ApiResource {
     retrieve(id: string, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Adjustment>;
     update(resource: AdjustmentUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Adjustment>;
     delete(id: string, options?: ResourcesConfig): Promise<void>;
+    versions(adjustmentId: string | Adjustment, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isAdjustment(resource: any): resource is Adjustment;
     relationship(id: string | ResourceId | null): AdjustmentRel;
     type(): string;

package/lib/esm/resources/adjustments.js

@@ -16,6 +16,10 @@ class Adjustments extends ApiResource {
     async delete(id, options) {
         await this.resources.delete({ type: Adjustments.TYPE, id }, options);
     }
+    async versions(adjustmentId, params, options) {
+        const _adjustmentId = adjustmentId.id || adjustmentId;
+        return this.resources.fetch({ type: 'versions' }, `adjustments/${_adjustmentId}/versions`, params, options);
+    }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     isAdjustment(resource) {
         return resource.type && (resource.type === Adjustments.TYPE);

package/lib/esm/resources/adyen_gateways.d.ts

@@ -1,6 +1,7 @@
 import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourcesConfig, ResourceId, ResourceRel, ListResponse } from '../resource';
 import type { QueryParamsList, QueryParamsRetrieve } from '../query';
 import type { PaymentMethod } from './payment_methods';
+import type { Version } from './versions';
 import type { AdyenPayment } from './adyen_payments';
 type AdyenGatewayRel = ResourceRel & {
     type: typeof AdyenGateways.TYPE;
@@ -15,6 +16,7 @@ interface AdyenGateway extends Resource {
     webhook_endpoint_secret?: string;
     webhook_endpoint_url?: string;
     payment_methods?: PaymentMethod[];
+    versions?: Version[];
     adyen_payments?: AdyenPayment[];
 }
 interface AdyenGatewayCreate extends ResourceCreate {
@@ -23,7 +25,7 @@ interface AdyenGatewayCreate extends ResourceCreate {
     api_key: string;
     public_key?: string;
     live_url_prefix: string;
-    api_version?: string;
+    api_version?: number;
     async_api?: boolean;
     webhook_endpoint_secret?: string;
     adyen_payments?: AdyenPaymentRel[];
@@ -34,7 +36,7 @@ interface AdyenGatewayUpdate extends ResourceUpdate {
     api_key?: string;
     public_key?: string;
     live_url_prefix?: string;
-    api_version?: string;
+    api_version?: number;
     async_api?: boolean;
     webhook_endpoint_secret?: string;
     adyen_payments?: AdyenPaymentRel[];
@@ -47,6 +49,7 @@ declare class AdyenGateways extends ApiResource {
     update(resource: AdyenGatewayUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<AdyenGateway>;
     delete(id: string, options?: ResourcesConfig): Promise<void>;
     payment_methods(adyenGatewayId: string | AdyenGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<PaymentMethod>>;
+    versions(adyenGatewayId: string | AdyenGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     adyen_payments(adyenGatewayId: string | AdyenGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<AdyenPayment>>;
     isAdyenGateway(resource: any): resource is AdyenGateway;
     relationship(id: string | ResourceId | null): AdyenGatewayRel;

package/lib/esm/resources/adyen_gateways.js

@@ -20,6 +20,10 @@ class AdyenGateways extends ApiResource {
         const _adyenGatewayId = adyenGatewayId.id || adyenGatewayId;
         return this.resources.fetch({ type: 'payment_methods' }, `adyen_gateways/${_adyenGatewayId}/payment_methods`, params, options);
     }
+    async versions(adyenGatewayId, params, options) {
+        const _adyenGatewayId = adyenGatewayId.id || adyenGatewayId;
+        return this.resources.fetch({ type: 'versions' }, `adyen_gateways/${_adyenGatewayId}/versions`, params, options);
+    }
     async adyen_payments(adyenGatewayId, params, options) {
         const _adyenGatewayId = adyenGatewayId.id || adyenGatewayId;
         return this.resources.fetch({ type: 'adyen_payments' }, `adyen_gateways/${_adyenGatewayId}/adyen_payments`, params, options);

package/lib/esm/resources/adyen_payments.d.ts

@@ -2,6 +2,7 @@ import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourcesConfig,
 import type { QueryParamsList, QueryParamsRetrieve } from '../query';
 import type { Order } from './orders';
 import type { PaymentGateway } from './payment_gateways';
+import type { Version } from './versions';
 type AdyenPaymentRel = ResourceRel & {
     type: typeof AdyenPayments.TYPE;
 };
@@ -18,6 +19,7 @@ interface AdyenPayment extends Resource {
     payment_instrument?: object;
     order?: Order;
     payment_gateway?: PaymentGateway;
+    versions?: Version[];
 }
 interface AdyenPaymentCreate extends ResourceCreate {
     order: OrderRel;
@@ -38,6 +40,7 @@ declare class AdyenPayments extends ApiResource {
     delete(id: string, options?: ResourcesConfig): Promise<void>;
     order(adyenPaymentId: string | AdyenPayment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Order>;
     payment_gateway(adyenPaymentId: string | AdyenPayment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<PaymentGateway>;
+    versions(adyenPaymentId: string | AdyenPayment, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isAdyenPayment(resource: any): resource is AdyenPayment;
     relationship(id: string | ResourceId | null): AdyenPaymentRel;
     type(): string;

package/lib/esm/resources/adyen_payments.js

@@ -24,6 +24,10 @@ class AdyenPayments extends ApiResource {
         const _adyenPaymentId = adyenPaymentId.id || adyenPaymentId;
         return this.resources.fetch({ type: 'payment_gateways' }, `adyen_payments/${_adyenPaymentId}/payment_gateway`, params, options);
     }
+    async versions(adyenPaymentId, params, options) {
+        const _adyenPaymentId = adyenPaymentId.id || adyenPaymentId;
+        return this.resources.fetch({ type: 'versions' }, `adyen_payments/${_adyenPaymentId}/versions`, params, options);
+    }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     isAdyenPayment(resource) {
         return resource.type && (resource.type === AdyenPayments.TYPE);

package/lib/esm/resources/authorizations.d.ts

@@ -1,9 +1,11 @@
 import { ApiResource, Resource, ResourceUpdate, ResourcesConfig, ResourceId, ResourceRel, ListResponse } from '../resource';
 import type { QueryParamsList, QueryParamsRetrieve } from '../query';
 import type { Order } from './orders';
+import type { Attachment } from './attachments';
+import type { Event } from './events';
+import type { Version } from './versions';
 import type { Capture } from './captures';
 import type { Void } from './voids';
-import type { Event } from './events';
 type AuthorizationRel = ResourceRel & {
     type: typeof Authorizations.TYPE;
 };
@@ -34,9 +36,11 @@ interface Authorization extends Resource {
     void_balance_float?: number;
     formatted_void_balance?: string;
     order?: Order;
+    attachments?: Attachment[];
+    events?: Event[];
+    versions?: Version[];
     captures?: Capture[];
     voids?: Void[];
-    events?: Event[];
 }
 interface AuthorizationUpdate extends ResourceUpdate {
     _capture?: boolean;
@@ -49,9 +53,11 @@ declare class Authorizations extends ApiResource {
     retrieve(id: string, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Authorization>;
     update(resource: AuthorizationUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Authorization>;
     order(authorizationId: string | Authorization, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Order>;
+    attachments(authorizationId: string | Authorization, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    events(authorizationId: string | Authorization, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
+    versions(authorizationId: string | Authorization, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     captures(authorizationId: string | Authorization, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Capture>>;
     voids(authorizationId: string | Authorization, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Void>>;
-    events(authorizationId: string | Authorization, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
     isAuthorization(resource: any): resource is Authorization;
     relationship(id: string | ResourceId | null): AuthorizationRel;
     type(): string;

package/lib/esm/resources/authorizations.js

@@ -14,6 +14,18 @@ class Authorizations extends ApiResource {
         const _authorizationId = authorizationId.id || authorizationId;
         return this.resources.fetch({ type: 'orders' }, `authorizations/${_authorizationId}/order`, params, options);
     }
+    async attachments(authorizationId, params, options) {
+        const _authorizationId = authorizationId.id || authorizationId;
+        return this.resources.fetch({ type: 'attachments' }, `authorizations/${_authorizationId}/attachments`, params, options);
+    }
+    async events(authorizationId, params, options) {
+        const _authorizationId = authorizationId.id || authorizationId;
+        return this.resources.fetch({ type: 'events' }, `authorizations/${_authorizationId}/events`, params, options);
+    }
+    async versions(authorizationId, params, options) {
+        const _authorizationId = authorizationId.id || authorizationId;
+        return this.resources.fetch({ type: 'versions' }, `authorizations/${_authorizationId}/versions`, params, options);
+    }
     async captures(authorizationId, params, options) {
         const _authorizationId = authorizationId.id || authorizationId;
         return this.resources.fetch({ type: 'captures' }, `authorizations/${_authorizationId}/captures`, params, options);
@@ -22,10 +34,6 @@ class Authorizations extends ApiResource {
         const _authorizationId = authorizationId.id || authorizationId;
         return this.resources.fetch({ type: 'voids' }, `authorizations/${_authorizationId}/voids`, params, options);
     }
-    async events(authorizationId, params, options) {
-        const _authorizationId = authorizationId.id || authorizationId;
-        return this.resources.fetch({ type: 'events' }, `authorizations/${_authorizationId}/events`, params, options);
-    }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     isAuthorization(resource) {
         return resource.type && (resource.type === Authorizations.TYPE);

package/lib/esm/resources/avalara_accounts.d.ts

@@ -2,6 +2,7 @@ import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourcesConfig,
 import type { QueryParamsList, QueryParamsRetrieve } from '../query';
 import type { Market } from './markets';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 import type { TaxCategory } from './tax_categories';
 type AvalaraAccountRel = ResourceRel & {
     type: typeof AvalaraAccounts.TYPE;
@@ -13,10 +14,11 @@ interface AvalaraAccount extends Resource {
     name?: string;
     username?: string;
     company_code?: string;
-    commit_invoice?: string;
-    ddp?: string;
+    commit_invoice?: boolean;
+    ddp?: boolean;
     markets?: Market[];
     attachments?: Attachment[];
+    versions?: Version[];
     tax_categories?: TaxCategory[];
 }
 interface AvalaraAccountCreate extends ResourceCreate {
@@ -24,8 +26,8 @@ interface AvalaraAccountCreate extends ResourceCreate {
     username: string;
     password: string;
     company_code: string;
-    commit_invoice?: string;
-    ddp?: string;
+    commit_invoice?: boolean;
+    ddp?: boolean;
     tax_categories?: TaxCategoryRel[];
 }
 interface AvalaraAccountUpdate extends ResourceUpdate {
@@ -33,8 +35,8 @@ interface AvalaraAccountUpdate extends ResourceUpdate {
     username?: string;
     password?: string;
     company_code?: string;
-    commit_invoice?: string;
-    ddp?: string;
+    commit_invoice?: boolean;
+    ddp?: boolean;
     tax_categories?: TaxCategoryRel[];
 }
 declare class AvalaraAccounts extends ApiResource {
@@ -46,6 +48,7 @@ declare class AvalaraAccounts extends ApiResource {
     delete(id: string, options?: ResourcesConfig): Promise<void>;
     markets(avalaraAccountId: string | AvalaraAccount, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Market>>;
     attachments(avalaraAccountId: string | AvalaraAccount, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    versions(avalaraAccountId: string | AvalaraAccount, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     tax_categories(avalaraAccountId: string | AvalaraAccount, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<TaxCategory>>;
     isAvalaraAccount(resource: any): resource is AvalaraAccount;
     relationship(id: string | ResourceId | null): AvalaraAccountRel;

package/lib/esm/resources/avalara_accounts.js

@@ -24,6 +24,10 @@ class AvalaraAccounts extends ApiResource {
         const _avalaraAccountId = avalaraAccountId.id || avalaraAccountId;
         return this.resources.fetch({ type: 'attachments' }, `avalara_accounts/${_avalaraAccountId}/attachments`, params, options);
     }
+    async versions(avalaraAccountId, params, options) {
+        const _avalaraAccountId = avalaraAccountId.id || avalaraAccountId;
+        return this.resources.fetch({ type: 'versions' }, `avalara_accounts/${_avalaraAccountId}/versions`, params, options);
+    }
     async tax_categories(avalaraAccountId, params, options) {
         const _avalaraAccountId = avalaraAccountId.id || avalaraAccountId;
         return this.resources.fetch({ type: 'tax_categories' }, `avalara_accounts/${_avalaraAccountId}/tax_categories`, params, options);

package/lib/esm/resources/axerve_gateways.d.ts

@@ -1,6 +1,7 @@
 import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourcesConfig, ResourceId, ResourceRel, ListResponse } from '../resource';
 import type { QueryParamsList, QueryParamsRetrieve } from '../query';
 import type { PaymentMethod } from './payment_methods';
+import type { Version } from './versions';
 import type { AxervePayment } from './axerve_payments';
 type AxerveGatewayRel = ResourceRel & {
     type: typeof AxerveGateways.TYPE;
@@ -11,7 +12,9 @@ type AxervePaymentRel = ResourceRel & {
 interface AxerveGateway extends Resource {
     name?: string;
     login?: string;
+    webhook_endpoint_url?: string;
     payment_methods?: PaymentMethod[];
+    versions?: Version[];
     axerve_payments?: AxervePayment[];
 }
 interface AxerveGatewayCreate extends ResourceCreate {
@@ -34,6 +37,7 @@ declare class AxerveGateways extends ApiResource {
     update(resource: AxerveGatewayUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<AxerveGateway>;
     delete(id: string, options?: ResourcesConfig): Promise<void>;
     payment_methods(axerveGatewayId: string | AxerveGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<PaymentMethod>>;
+    versions(axerveGatewayId: string | AxerveGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     axerve_payments(axerveGatewayId: string | AxerveGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<AxervePayment>>;
     isAxerveGateway(resource: any): resource is AxerveGateway;
     relationship(id: string | ResourceId | null): AxerveGatewayRel;

package/lib/esm/resources/axerve_gateways.js

@@ -20,6 +20,10 @@ class AxerveGateways extends ApiResource {
         const _axerveGatewayId = axerveGatewayId.id || axerveGatewayId;
         return this.resources.fetch({ type: 'payment_methods' }, `axerve_gateways/${_axerveGatewayId}/payment_methods`, params, options);
     }
+    async versions(axerveGatewayId, params, options) {
+        const _axerveGatewayId = axerveGatewayId.id || axerveGatewayId;
+        return this.resources.fetch({ type: 'versions' }, `axerve_gateways/${_axerveGatewayId}/versions`, params, options);
+    }
     async axerve_payments(axerveGatewayId, params, options) {
         const _axerveGatewayId = axerveGatewayId.id || axerveGatewayId;
         return this.resources.fetch({ type: 'axerve_payments' }, `axerve_gateways/${_axerveGatewayId}/axerve_payments`, params, options);

package/lib/esm/resources/axerve_payments.d.ts

@@ -2,6 +2,7 @@ import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourcesConfig,
 import type { QueryParamsList, QueryParamsRetrieve } from '../query';
 import type { Order } from './orders';
 import type { PaymentGateway } from './payment_gateways';
+import type { Version } from './versions';
 type AxervePaymentRel = ResourceRel & {
     type: typeof AxervePayments.TYPE;
 };
@@ -12,6 +13,9 @@ interface AxervePayment extends Resource {
     login?: string;
     return_url?: string;
     payment_request_data?: object;
+    client_ip?: string;
+    buyer_details?: object;
+    request_token?: boolean;
     mismatched_amounts?: boolean;
     intent_amount_cents?: number;
     intent_amount_float?: number;
@@ -19,9 +23,13 @@ interface AxervePayment extends Resource {
     payment_instrument?: object;
     order?: Order;
     payment_gateway?: PaymentGateway;
+    versions?: Version[];
 }
 interface AxervePaymentCreate extends ResourceCreate {
     return_url: string;
+    client_ip?: string;
+    buyer_details?: object;
+    request_token?: boolean;
     order: OrderRel;
 }
 interface AxervePaymentUpdate extends ResourceUpdate {
@@ -38,6 +46,7 @@ declare class AxervePayments extends ApiResource {
     delete(id: string, options?: ResourcesConfig): Promise<void>;
     order(axervePaymentId: string | AxervePayment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Order>;
     payment_gateway(axervePaymentId: string | AxervePayment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<PaymentGateway>;
+    versions(axervePaymentId: string | AxervePayment, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isAxervePayment(resource: any): resource is AxervePayment;
     relationship(id: string | ResourceId | null): AxervePaymentRel;
     type(): string;

package/lib/esm/resources/axerve_payments.js

@@ -24,6 +24,10 @@ class AxervePayments extends ApiResource {
         const _axervePaymentId = axervePaymentId.id || axervePaymentId;
         return this.resources.fetch({ type: 'payment_gateways' }, `axerve_payments/${_axervePaymentId}/payment_gateway`, params, options);
     }
+    async versions(axervePaymentId, params, options) {
+        const _axervePaymentId = axervePaymentId.id || axervePaymentId;
+        return this.resources.fetch({ type: 'versions' }, `axerve_payments/${_axervePaymentId}/versions`, params, options);
+    }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     isAxervePayment(resource) {
         return resource.type && (resource.type === AxervePayments.TYPE);

package/lib/esm/resources/billing_info_validation_rules.d.ts

@@ -2,6 +2,7 @@ import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourcesConfig,
 import type { QueryParamsList, QueryParamsRetrieve } from '../query';
 import type { Market } from './markets';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 type BillingInfoValidationRuleRel = ResourceRel & {
     type: typeof BillingInfoValidationRules.TYPE;
 };
@@ -11,6 +12,7 @@ type MarketRel = ResourceRel & {
 interface BillingInfoValidationRule extends Resource {
     market?: Market;
     attachments?: Attachment[];
+    versions?: Version[];
 }
 interface BillingInfoValidationRuleCreate extends ResourceCreate {
     market: MarketRel;
@@ -27,6 +29,7 @@ declare class BillingInfoValidationRules extends ApiResource {
     delete(id: string, options?: ResourcesConfig): Promise<void>;
     market(billingInfoValidationRuleId: string | BillingInfoValidationRule, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Market>;
     attachments(billingInfoValidationRuleId: string | BillingInfoValidationRule, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    versions(billingInfoValidationRuleId: string | BillingInfoValidationRule, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isBillingInfoValidationRule(resource: any): resource is BillingInfoValidationRule;
     relationship(id: string | ResourceId | null): BillingInfoValidationRuleRel;
     type(): string;

package/lib/esm/resources/billing_info_validation_rules.js

@@ -24,6 +24,10 @@ class BillingInfoValidationRules extends ApiResource {
         const _billingInfoValidationRuleId = billingInfoValidationRuleId.id || billingInfoValidationRuleId;
         return this.resources.fetch({ type: 'attachments' }, `billing_info_validation_rules/${_billingInfoValidationRuleId}/attachments`, params, options);
     }
+    async versions(billingInfoValidationRuleId, params, options) {
+        const _billingInfoValidationRuleId = billingInfoValidationRuleId.id || billingInfoValidationRuleId;
+        return this.resources.fetch({ type: 'versions' }, `billing_info_validation_rules/${_billingInfoValidationRuleId}/versions`, params, options);
+    }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     isBillingInfoValidationRule(resource) {
         return resource.type && (resource.type === BillingInfoValidationRules.TYPE);

package/lib/esm/resources/braintree_gateways.d.ts

@@ -1,6 +1,7 @@
 import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourcesConfig, ResourceId, ResourceRel, ListResponse } from '../resource';
 import type { QueryParamsList, QueryParamsRetrieve } from '../query';
 import type { PaymentMethod } from './payment_methods';
+import type { Version } from './versions';
 import type { BraintreePayment } from './braintree_payments';
 type BraintreeGatewayRel = ResourceRel & {
     type: typeof BraintreeGateways.TYPE;
@@ -15,6 +16,7 @@ interface BraintreeGateway extends Resource {
     descriptor_url?: string;
     webhook_endpoint_url?: string;
     payment_methods?: PaymentMethod[];
+    versions?: Version[];
     braintree_payments?: BraintreePayment[];
 }
 interface BraintreeGatewayCreate extends ResourceCreate {
@@ -47,6 +49,7 @@ declare class BraintreeGateways extends ApiResource {
     update(resource: BraintreeGatewayUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<BraintreeGateway>;
     delete(id: string, options?: ResourcesConfig): Promise<void>;
     payment_methods(braintreeGatewayId: string | BraintreeGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<PaymentMethod>>;
+    versions(braintreeGatewayId: string | BraintreeGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     braintree_payments(braintreeGatewayId: string | BraintreeGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<BraintreePayment>>;
     isBraintreeGateway(resource: any): resource is BraintreeGateway;
     relationship(id: string | ResourceId | null): BraintreeGatewayRel;

package/lib/esm/resources/braintree_gateways.js

@@ -20,6 +20,10 @@ class BraintreeGateways extends ApiResource {
         const _braintreeGatewayId = braintreeGatewayId.id || braintreeGatewayId;
         return this.resources.fetch({ type: 'payment_methods' }, `braintree_gateways/${_braintreeGatewayId}/payment_methods`, params, options);
     }
+    async versions(braintreeGatewayId, params, options) {
+        const _braintreeGatewayId = braintreeGatewayId.id || braintreeGatewayId;
+        return this.resources.fetch({ type: 'versions' }, `braintree_gateways/${_braintreeGatewayId}/versions`, params, options);
+    }
     async braintree_payments(braintreeGatewayId, params, options) {
         const _braintreeGatewayId = braintreeGatewayId.id || braintreeGatewayId;
         return this.resources.fetch({ type: 'braintree_payments' }, `braintree_gateways/${_braintreeGatewayId}/braintree_payments`, params, options);

package/lib/esm/resources/braintree_payments.d.ts

@@ -2,6 +2,7 @@ import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourcesConfig,
 import type { QueryParamsList, QueryParamsRetrieve } from '../query';
 import type { Order } from './orders';
 import type { PaymentGateway } from './payment_gateways';
+import type { Version } from './versions';
 type BraintreePaymentRel = ResourceRel & {
     type: typeof BraintreePayments.TYPE;
 };
@@ -17,6 +18,7 @@ interface BraintreePayment extends Resource {
     payment_instrument?: object;
     order?: Order;
     payment_gateway?: PaymentGateway;
+    versions?: Version[];
 }
 interface BraintreePaymentCreate extends ResourceCreate {
     payment_id?: string;
@@ -40,6 +42,7 @@ declare class BraintreePayments extends ApiResource {
     delete(id: string, options?: ResourcesConfig): Promise<void>;
     order(braintreePaymentId: string | BraintreePayment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Order>;
     payment_gateway(braintreePaymentId: string | BraintreePayment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<PaymentGateway>;
+    versions(braintreePaymentId: string | BraintreePayment, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isBraintreePayment(resource: any): resource is BraintreePayment;
     relationship(id: string | ResourceId | null): BraintreePaymentRel;
     type(): string;

package/lib/esm/resources/braintree_payments.js

@@ -24,6 +24,10 @@ class BraintreePayments extends ApiResource {
         const _braintreePaymentId = braintreePaymentId.id || braintreePaymentId;
         return this.resources.fetch({ type: 'payment_gateways' }, `braintree_payments/${_braintreePaymentId}/payment_gateway`, params, options);
     }
+    async versions(braintreePaymentId, params, options) {
+        const _braintreePaymentId = braintreePaymentId.id || braintreePaymentId;
+        return this.resources.fetch({ type: 'versions' }, `braintree_payments/${_braintreePaymentId}/versions`, params, options);
+    }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     isBraintreePayment(resource) {
         return resource.type && (resource.type === BraintreePayments.TYPE);