@commercelayer/sdk 4.27.1 → 4.28.1

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

@@ -18,10 +18,15 @@ import type { SatispayPayment } from './satispay_payments';
 import type { StripePayment } from './stripe_payments';
 import type { WireTransfer } from './wire_transfers';
 import type { LineItem } from './line_items';
+import type { LineItemOption } from './line_item_options';
+import type { StockReservation } from './stock_reservations';
+import type { StockLineItem } from './stock_line_items';
+import type { StockTransfer } from './stock_transfers';
 import type { Shipment } from './shipments';
+import type { PaymentOption } from './payment_options';
 import type { Authorization } from './authorizations';
-import type { Void } from './voids';
 import type { Capture } from './captures';
+import type { Void } from './voids';
 import type { Refund } from './refunds';
 import type { Return } from './returns';
 import type { OrderSubscription } from './order_subscriptions';
@@ -30,6 +35,8 @@ import type { OrderCopy } from './order_copies';
 import type { RecurringOrderCopy } from './recurring_order_copies';
 import type { Attachment } from './attachments';
 import type { Event } from './events';
+import type { Tag } from './tags';
+import type { Version } from './versions';
 type OrderRel = ResourceRel & {
     type: typeof Orders.TYPE;
 };
@@ -75,8 +82,11 @@ type StripePaymentRel = ResourceRel & {
 type WireTransferRel = ResourceRel & {
     type: 'wire_transfers';
 };
+type TagRel = ResourceRel & {
+    type: 'tags';
+};
 interface Order extends Resource {
-    number?: number;
+    number?: string;
     autorefresh?: boolean;
     status?: string;
     payment_status?: string;
@@ -89,12 +99,14 @@ interface Order extends Resource {
     tax_included?: boolean;
     tax_rate?: number;
     freight_taxable?: boolean;
+    payment_method_taxable?: boolean;
+    adjustment_taxable?: boolean;
+    gift_card_taxable?: boolean;
     requires_billing_info?: boolean;
     country_code?: string;
     shipping_country_code_lock?: string;
     coupon_code?: string;
     gift_card_code?: string;
-    gift_card_or_coupon_code?: string;
     subtotal_amount_cents?: number;
     subtotal_amount_float?: number;
     formatted_subtotal_amount?: string;
@@ -155,10 +167,14 @@ interface Order extends Resource {
     duty_amount_cents?: number;
     duty_amount_float?: number;
     formatted_duty_amount?: string;
+    place_total_amount_cents?: number;
+    place_total_amount_float?: number;
+    formatted_place_total_amount?: string;
     skus_count?: number;
     line_item_options_count?: number;
     shipments_count?: number;
     tax_calculations_count?: number;
+    validations_count?: number;
     payment_source_details?: object;
     token?: string;
     cart_url?: string;
@@ -186,30 +202,42 @@ interface Order extends Resource {
     payment_method?: PaymentMethod;
     payment_source?: AdyenPayment | AxervePayment | BraintreePayment | CheckoutComPayment | ExternalPayment | KlarnaPayment | PaypalPayment | SatispayPayment | StripePayment | WireTransfer;
     line_items?: LineItem[];
+    line_item_options?: LineItemOption[];
+    stock_reservations?: StockReservation[];
+    stock_line_items?: StockLineItem[];
+    stock_transfers?: StockTransfer[];
     shipments?: Shipment[];
-    transactions?: Array<Authorization | Void | Capture | Refund>;
+    payment_options?: PaymentOption[];
+    transactions?: Array<Authorization | Capture | Void | Refund>;
     authorizations?: Authorization[];
     captures?: Capture[];
     voids?: Void[];
     refunds?: Refund[];
     returns?: Return[];
+    order_subscription?: OrderSubscription;
     order_subscriptions?: OrderSubscription[];
     order_factories?: OrderFactory[];
     order_copies?: OrderCopy[];
     recurring_order_copies?: RecurringOrderCopy[];
     attachments?: Attachment[];
     events?: Event[];
+    tags?: Tag[];
+    versions?: Version[];
 }
 interface OrderCreate extends ResourceCreate {
+    number?: string;
     autorefresh?: boolean;
     guest?: boolean;
     customer_email?: string;
     customer_password?: string;
     language_code?: string;
+    freight_taxable?: boolean;
+    payment_method_taxable?: boolean;
+    adjustment_taxable?: boolean;
+    gift_card_taxable?: boolean;
     shipping_country_code_lock?: string;
     coupon_code?: string;
     gift_card_code?: string;
-    gift_card_or_coupon_code?: string;
     cart_url?: string;
     return_url?: string;
     terms_url?: string;
@@ -220,17 +248,22 @@ interface OrderCreate extends ResourceCreate {
     billing_address?: AddressRel;
     payment_method?: PaymentMethodRel;
     payment_source?: AdyenPaymentRel | AxervePaymentRel | BraintreePaymentRel | CheckoutComPaymentRel | ExternalPaymentRel | KlarnaPaymentRel | PaypalPaymentRel | SatispayPaymentRel | StripePaymentRel | WireTransferRel;
+    tags?: TagRel[];
 }
 interface OrderUpdate extends ResourceUpdate {
+    number?: string;
     autorefresh?: boolean;
     guest?: boolean;
     customer_email?: string;
     customer_password?: string;
     language_code?: string;
+    freight_taxable?: boolean;
+    payment_method_taxable?: boolean;
+    adjustment_taxable?: boolean;
+    gift_card_taxable?: boolean;
     shipping_country_code_lock?: string;
     coupon_code?: string;
     gift_card_code?: string;
-    gift_card_or_coupon_code?: string;
     cart_url?: string;
     return_url?: string;
     terms_url?: string;
@@ -260,12 +293,15 @@ interface OrderUpdate extends ResourceUpdate {
     _refresh?: boolean;
     _validate?: boolean;
     _create_subscriptions?: boolean;
+    _start_editing?: boolean;
+    _stop_editing?: boolean;
     market?: MarketRel;
     customer?: CustomerRel;
     shipping_address?: AddressRel;
     billing_address?: AddressRel;
     payment_method?: PaymentMethodRel;
     payment_source?: AdyenPaymentRel | AxervePaymentRel | BraintreePaymentRel | CheckoutComPaymentRel | ExternalPaymentRel | KlarnaPaymentRel | PaypalPaymentRel | SatispayPaymentRel | StripePaymentRel | WireTransferRel;
+    tags?: TagRel[];
 }
 declare class Orders extends ApiResource {
     static readonly TYPE: 'orders';
@@ -284,18 +320,26 @@ declare class Orders extends ApiResource {
     available_free_bundles(orderId: string | Order, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Bundle>>;
     payment_method(orderId: string | Order, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<PaymentMethod>;
     line_items(orderId: string | Order, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<LineItem>>;
+    line_item_options(orderId: string | Order, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<LineItemOption>>;
+    stock_reservations(orderId: string | Order, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<StockReservation>>;
+    stock_line_items(orderId: string | Order, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<StockLineItem>>;
+    stock_transfers(orderId: string | Order, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<StockTransfer>>;
     shipments(orderId: string | Order, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Shipment>>;
+    payment_options(orderId: string | Order, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<PaymentOption>>;
     authorizations(orderId: string | Order, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Authorization>>;
     captures(orderId: string | Order, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Capture>>;
     voids(orderId: string | Order, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Void>>;
     refunds(orderId: string | Order, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Refund>>;
     returns(orderId: string | Order, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Return>>;
+    order_subscription(orderId: string | Order, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<OrderSubscription>;
     order_subscriptions(orderId: string | Order, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<OrderSubscription>>;
     order_factories(orderId: string | Order, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<OrderFactory>>;
     order_copies(orderId: string | Order, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<OrderCopy>>;
     recurring_order_copies(orderId: string | Order, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<RecurringOrderCopy>>;
     attachments(orderId: string | Order, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
     events(orderId: string | Order, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
+    tags(orderId: string | Order, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Tag>>;
+    versions(orderId: string | Order, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isOrder(resource: any): resource is Order;
     relationship(id: string | ResourceId | null): OrderRel;
     type(): string;

package/lib/esm/resources/orders.js

@@ -56,10 +56,30 @@ class Orders extends ApiResource {
         const _orderId = orderId.id || orderId;
         return this.resources.fetch({ type: 'line_items' }, `orders/${_orderId}/line_items`, params, options);
     }
+    async line_item_options(orderId, params, options) {
+        const _orderId = orderId.id || orderId;
+        return this.resources.fetch({ type: 'line_item_options' }, `orders/${_orderId}/line_item_options`, params, options);
+    }
+    async stock_reservations(orderId, params, options) {
+        const _orderId = orderId.id || orderId;
+        return this.resources.fetch({ type: 'stock_reservations' }, `orders/${_orderId}/stock_reservations`, params, options);
+    }
+    async stock_line_items(orderId, params, options) {
+        const _orderId = orderId.id || orderId;
+        return this.resources.fetch({ type: 'stock_line_items' }, `orders/${_orderId}/stock_line_items`, params, options);
+    }
+    async stock_transfers(orderId, params, options) {
+        const _orderId = orderId.id || orderId;
+        return this.resources.fetch({ type: 'stock_transfers' }, `orders/${_orderId}/stock_transfers`, params, options);
+    }
     async shipments(orderId, params, options) {
         const _orderId = orderId.id || orderId;
         return this.resources.fetch({ type: 'shipments' }, `orders/${_orderId}/shipments`, params, options);
     }
+    async payment_options(orderId, params, options) {
+        const _orderId = orderId.id || orderId;
+        return this.resources.fetch({ type: 'payment_options' }, `orders/${_orderId}/payment_options`, params, options);
+    }
     async authorizations(orderId, params, options) {
         const _orderId = orderId.id || orderId;
         return this.resources.fetch({ type: 'authorizations' }, `orders/${_orderId}/authorizations`, params, options);
@@ -80,6 +100,10 @@ class Orders extends ApiResource {
         const _orderId = orderId.id || orderId;
         return this.resources.fetch({ type: 'returns' }, `orders/${_orderId}/returns`, params, options);
     }
+    async order_subscription(orderId, params, options) {
+        const _orderId = orderId.id || orderId;
+        return this.resources.fetch({ type: 'order_subscriptions' }, `orders/${_orderId}/order_subscription`, params, options);
+    }
     async order_subscriptions(orderId, params, options) {
         const _orderId = orderId.id || orderId;
         return this.resources.fetch({ type: 'order_subscriptions' }, `orders/${_orderId}/order_subscriptions`, params, options);
@@ -104,6 +128,14 @@ class Orders extends ApiResource {
         const _orderId = orderId.id || orderId;
         return this.resources.fetch({ type: 'events' }, `orders/${_orderId}/events`, params, options);
     }
+    async tags(orderId, params, options) {
+        const _orderId = orderId.id || orderId;
+        return this.resources.fetch({ type: 'tags' }, `orders/${_orderId}/tags`, params, options);
+    }
+    async versions(orderId, params, options) {
+        const _orderId = orderId.id || orderId;
+        return this.resources.fetch({ type: 'versions' }, `orders/${_orderId}/versions`, params, options);
+    }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     isOrder(resource) {
         return resource.type && (resource.type === Orders.TYPE);

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

@@ -12,14 +12,14 @@ interface Organization extends Resource {
     logo_url?: string;
     favicon_url?: string;
     primary_color?: string;
-    contrast_color?: string;
     gtm_id?: string;
     gtm_id_test?: string;
-    discount_disabled?: boolean;
-    account_disabled?: boolean;
-    acceptance_disabled?: boolean;
     max_concurrent_promotions?: number;
     max_concurrent_imports?: number;
+    max_concurrent_exports?: number;
+    max_concurrent_cleanups?: number;
+    order_number_editable_test?: boolean;
+    order_number_editable_live?: boolean;
 }
 declare class Organizations extends ApiResource {
     static readonly TYPE: 'organization';

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

@@ -3,6 +3,7 @@ import type { QueryParamsList, QueryParamsRetrieve } from '../query';
 import type { StockLocation } from './stock_locations';
 import type { Parcel } from './parcels';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 type PackageRel = ResourceRel & {
     type: typeof Packages.TYPE;
 };
@@ -19,6 +20,7 @@ interface Package extends Resource {
     stock_location?: StockLocation;
     parcels?: Parcel[];
     attachments?: Attachment[];
+    versions?: Version[];
 }
 interface PackageCreate extends ResourceCreate {
     name: string;
@@ -48,6 +50,7 @@ declare class Packages extends ApiResource {
     stock_location(packageId: string | Package, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<StockLocation>;
     parcels(packageId: string | Package, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Parcel>>;
     attachments(packageId: string | Package, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    versions(packageId: string | Package, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isPackage(resource: any): resource is Package;
     relationship(id: string | ResourceId | null): PackageRel;
     type(): string;

package/lib/esm/resources/packages.js

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

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

@@ -2,6 +2,7 @@ import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourcesConfig,
 import type { QueryParamsList, QueryParamsRetrieve } from '../query';
 import type { Parcel } from './parcels';
 import type { StockLineItem } from './stock_line_items';
+import type { Version } from './versions';
 type ParcelLineItemRel = ResourceRel & {
     type: typeof ParcelLineItems.TYPE;
 };
@@ -13,6 +14,7 @@ type StockLineItemRel = ResourceRel & {
 };
 interface ParcelLineItem extends Resource {
     sku_code?: string;
+    bundle_code?: string;
     quantity?: number;
     name?: string;
     image_url?: string;
@@ -22,9 +24,9 @@ interface ParcelLineItem extends Resource {
     * @deprecated This field should not be used as it may be removed in the future without notice
     */
     shipment_line_item?: object;
+    versions?: Version[];
 }
 interface ParcelLineItemCreate extends ResourceCreate {
-    sku_code?: string;
     quantity: number;
     parcel: ParcelRel;
     stock_line_item: StockLineItemRel;
@@ -43,6 +45,7 @@ declare class ParcelLineItems extends ApiResource {
     delete(id: string, options?: ResourcesConfig): Promise<void>;
     parcel(parcelLineItemId: string | ParcelLineItem, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Parcel>;
     stock_line_item(parcelLineItemId: string | ParcelLineItem, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<StockLineItem>;
+    versions(parcelLineItemId: string | ParcelLineItem, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isParcelLineItem(resource: any): resource is ParcelLineItem;
     relationship(id: string | ResourceId | null): ParcelLineItemRel;
     type(): string;

package/lib/esm/resources/parcel_line_items.js

@@ -24,6 +24,10 @@ class ParcelLineItems extends ApiResource {
         const _parcelLineItemId = parcelLineItemId.id || parcelLineItemId;
         return this.resources.fetch({ type: 'stock_line_items' }, `parcel_line_items/${_parcelLineItemId}/stock_line_item`, params, options);
     }
+    async versions(parcelLineItemId, params, options) {
+        const _parcelLineItemId = parcelLineItemId.id || parcelLineItemId;
+        return this.resources.fetch({ type: 'versions' }, `parcel_line_items/${_parcelLineItemId}/versions`, params, options);
+    }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     isParcelLineItem(resource) {
         return resource.type && (resource.type === ParcelLineItems.TYPE);

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

@@ -5,6 +5,7 @@ import type { Package } from './packages';
 import type { ParcelLineItem } from './parcel_line_items';
 import type { Attachment } from './attachments';
 import type { Event } from './events';
+import type { Version } from './versions';
 type ParcelRel = ResourceRel & {
     type: typeof Parcels.TYPE;
 };
@@ -35,15 +36,17 @@ interface Parcel extends Resource {
     tracking_status?: string;
     tracking_status_detail?: string;
     tracking_status_updated_at?: string;
-    tracking_details?: string;
+    tracking_details?: object;
     carrier_weight_oz?: string;
     signed_by?: string;
     incoterm?: string;
+    delivery_confirmation?: string;
     shipment?: Shipment;
     package?: Package;
     parcel_line_items?: ParcelLineItem[];
     attachments?: Attachment[];
     events?: Event[];
+    versions?: Version[];
 }
 interface ParcelCreate extends ResourceCreate {
     weight: number;
@@ -65,10 +68,11 @@ interface ParcelCreate extends ResourceCreate {
     tracking_status?: string;
     tracking_status_detail?: string;
     tracking_status_updated_at?: string;
-    tracking_details?: string;
+    tracking_details?: object;
     carrier_weight_oz?: string;
     signed_by?: string;
     incoterm?: string;
+    delivery_confirmation?: string;
     shipment: ShipmentRel;
     package: PackageRel;
 }
@@ -92,10 +96,11 @@ interface ParcelUpdate extends ResourceUpdate {
     tracking_status?: string;
     tracking_status_detail?: string;
     tracking_status_updated_at?: string;
-    tracking_details?: string;
+    tracking_details?: object;
     carrier_weight_oz?: string;
     signed_by?: string;
     incoterm?: string;
+    delivery_confirmation?: string;
     shipment?: ShipmentRel;
     package?: PackageRel;
 }
@@ -111,6 +116,7 @@ declare class Parcels extends ApiResource {
     parcel_line_items(parcelId: string | Parcel, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<ParcelLineItem>>;
     attachments(parcelId: string | Parcel, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
     events(parcelId: string | Parcel, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
+    versions(parcelId: string | Parcel, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isParcel(resource: any): resource is Parcel;
     relationship(id: string | ResourceId | null): ParcelRel;
     type(): string;

package/lib/esm/resources/parcels.js

@@ -36,6 +36,10 @@ class Parcels extends ApiResource {
         const _parcelId = parcelId.id || parcelId;
         return this.resources.fetch({ type: 'events' }, `parcels/${_parcelId}/events`, params, options);
     }
+    async versions(parcelId, params, options) {
+        const _parcelId = parcelId.id || parcelId;
+        return this.resources.fetch({ type: 'versions' }, `parcels/${_parcelId}/versions`, params, options);
+    }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     isParcel(resource) {
         return resource.type && (resource.type === Parcels.TYPE);

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

@@ -1,18 +1,21 @@
 import { ApiResource, Resource, ResourcesConfig, ResourceId, ResourceRel, ListResponse } from '../resource';
 import type { QueryParamsList, QueryParamsRetrieve } from '../query';
 import type { PaymentMethod } from './payment_methods';
+import type { Version } from './versions';
 type PaymentGatewayRel = ResourceRel & {
     type: typeof PaymentGateways.TYPE;
 };
 interface PaymentGateway extends Resource {
     name?: string;
     payment_methods?: PaymentMethod[];
+    versions?: Version[];
 }
 declare class PaymentGateways extends ApiResource {
     static readonly TYPE: 'payment_gateways';
     list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<PaymentGateway>>;
     retrieve(id: string, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<PaymentGateway>;
     payment_methods(paymentGatewayId: string | PaymentGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<PaymentMethod>>;
+    versions(paymentGatewayId: string | PaymentGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isPaymentGateway(resource: any): resource is PaymentGateway;
     relationship(id: string | ResourceId | null): PaymentGatewayRel;
     type(): string;

package/lib/esm/resources/payment_gateways.js

@@ -11,6 +11,10 @@ class PaymentGateways extends ApiResource {
         const _paymentGatewayId = paymentGatewayId.id || paymentGatewayId;
         return this.resources.fetch({ type: 'payment_methods' }, `payment_gateways/${_paymentGatewayId}/payment_methods`, params, options);
     }
+    async versions(paymentGatewayId, params, options) {
+        const _paymentGatewayId = paymentGatewayId.id || paymentGatewayId;
+        return this.resources.fetch({ type: 'versions' }, `payment_gateways/${_paymentGatewayId}/versions`, params, options);
+    }
     // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     isPaymentGateway(resource) {
         return resource.type && (resource.type === PaymentGateways.TYPE);

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

@@ -3,6 +3,7 @@ import type { QueryParamsList, QueryParamsRetrieve } from '../query';
 import type { Market } from './markets';
 import type { PaymentGateway } from './payment_gateways';
 import type { Attachment } from './attachments';
+import type { Version } from './versions';
 type PaymentMethodRel = ResourceRel & {
     type: typeof PaymentMethods.TYPE;
 };
@@ -13,11 +14,12 @@ type PaymentGatewayRel = ResourceRel & {
     type: 'payment_gateways';
 };
 interface PaymentMethod extends Resource {
-    payment_source_type?: string;
     name?: string;
+    payment_source_type?: string;
     currency_code?: string;
     moto?: boolean;
     require_capture?: boolean;
+    auto_place?: boolean;
     auto_capture?: boolean;
     disabled_at?: string;
     price_amount_cents?: number;
@@ -29,13 +31,17 @@ interface PaymentMethod extends Resource {
     market?: Market;
     payment_gateway?: PaymentGateway;
     attachments?: Attachment[];
+    versions?: Version[];
 }
 interface PaymentMethodCreate extends ResourceCreate {
     payment_source_type: string;
     currency_code?: string;
     moto?: boolean;
     require_capture?: boolean;
+    auto_place?: boolean;
     auto_capture?: boolean;
+    _disable?: boolean;
+    _enable?: boolean;
     price_amount_cents: number;
     auto_capture_max_amount_cents?: number;
     market?: MarketRel;
@@ -46,6 +52,7 @@ interface PaymentMethodUpdate extends ResourceUpdate {
     currency_code?: string;
     moto?: boolean;
     require_capture?: boolean;
+    auto_place?: boolean;
     auto_capture?: boolean;
     _disable?: boolean;
     _enable?: boolean;
@@ -64,6 +71,7 @@ declare class PaymentMethods extends ApiResource {
     market(paymentMethodId: string | PaymentMethod, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Market>;
     payment_gateway(paymentMethodId: string | PaymentMethod, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<PaymentGateway>;
     attachments(paymentMethodId: string | PaymentMethod, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    versions(paymentMethodId: string | PaymentMethod, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     isPaymentMethod(resource: any): resource is PaymentMethod;
     relationship(id: string | ResourceId | null): PaymentMethodRel;
     type(): string;

package/lib/esm/resources/payment_methods.js

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

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

@@ -0,0 +1,43 @@
+import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourcesConfig, ResourceId, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsList, QueryParamsRetrieve } from '../query';
+import type { Order } from './orders';
+import type { Attachment } from './attachments';
+type PaymentOptionRel = ResourceRel & {
+    type: typeof PaymentOptions.TYPE;
+};
+type OrderRel = ResourceRel & {
+    type: 'orders';
+};
+interface PaymentOption extends Resource {
+    name?: string;
+    payment_source_type?: string;
+    data?: object;
+    order?: Order;
+    attachments?: Attachment[];
+}
+interface PaymentOptionCreate extends ResourceCreate {
+    name?: string;
+    payment_source_type: string;
+    data: object;
+    order: OrderRel;
+}
+interface PaymentOptionUpdate extends ResourceUpdate {
+    name?: string;
+    data?: object;
+    order?: OrderRel;
+}
+declare class PaymentOptions extends ApiResource {
+    static readonly TYPE: 'payment_options';
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<PaymentOption>>;
+    create(resource: PaymentOptionCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<PaymentOption>;
+    retrieve(id: string, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<PaymentOption>;
+    update(resource: PaymentOptionUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<PaymentOption>;
+    delete(id: string, options?: ResourcesConfig): Promise<void>;
+    order(paymentOptionId: string | PaymentOption, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Order>;
+    attachments(paymentOptionId: string | PaymentOption, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    isPaymentOption(resource: any): resource is PaymentOption;
+    relationship(id: string | ResourceId | null): PaymentOptionRel;
+    type(): string;
+}
+export default PaymentOptions;
+export { PaymentOption, PaymentOptionCreate, PaymentOptionUpdate };

package/lib/esm/resources/payment_options.js

@@ -0,0 +1,39 @@
+import { ApiResource } from '../resource';
+class PaymentOptions extends ApiResource {
+    // static readonly PATH = 'payment_options'
+    async list(params, options) {
+        return this.resources.list({ type: PaymentOptions.TYPE }, params, options);
+    }
+    async create(resource, params, options) {
+        return this.resources.create(Object.assign(Object.assign({}, resource), { type: PaymentOptions.TYPE }), params, options);
+    }
+    async retrieve(id, params, options) {
+        return this.resources.retrieve({ type: PaymentOptions.TYPE, id }, params, options);
+    }
+    async update(resource, params, options) {
+        return this.resources.update(Object.assign(Object.assign({}, resource), { type: PaymentOptions.TYPE }), params, options);
+    }
+    async delete(id, options) {
+        await this.resources.delete({ type: PaymentOptions.TYPE, id }, options);
+    }
+    async order(paymentOptionId, params, options) {
+        const _paymentOptionId = paymentOptionId.id || paymentOptionId;
+        return this.resources.fetch({ type: 'orders' }, `payment_options/${_paymentOptionId}/order`, params, options);
+    }
+    async attachments(paymentOptionId, params, options) {
+        const _paymentOptionId = paymentOptionId.id || paymentOptionId;
+        return this.resources.fetch({ type: 'attachments' }, `payment_options/${_paymentOptionId}/attachments`, params, options);
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+    isPaymentOption(resource) {
+        return resource.type && (resource.type === PaymentOptions.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: PaymentOptions.TYPE } : { id: id.id, type: PaymentOptions.TYPE };
+    }
+    type() {
+        return PaymentOptions.TYPE;
+    }
+}
+PaymentOptions.TYPE = 'payment_options';
+export default PaymentOptions;

package/lib/esm/resources/paypal_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 { PaypalPayment } from './paypal_payments';
 type PaypalGatewayRel = ResourceRel & {
     type: typeof PaypalGateways.TYPE;
@@ -8,6 +9,7 @@ type PaypalGatewayRel = ResourceRel & {
 interface PaypalGateway extends Resource {
     name?: string;
     payment_methods?: PaymentMethod[];
+    versions?: Version[];
     paypal_payments?: PaypalPayment[];
 }
 interface PaypalGatewayCreate extends ResourceCreate {
@@ -28,6 +30,7 @@ declare class PaypalGateways extends ApiResource {
     update(resource: PaypalGatewayUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<PaypalGateway>;
     delete(id: string, options?: ResourcesConfig): Promise<void>;
     payment_methods(paypalGatewayId: string | PaypalGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<PaymentMethod>>;
+    versions(paypalGatewayId: string | PaypalGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
     paypal_payments(paypalGatewayId: string | PaypalGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<PaypalPayment>>;
     isPaypalGateway(resource: any): resource is PaypalGateway;
     relationship(id: string | ResourceId | null): PaypalGatewayRel;

package/lib/esm/resources/paypal_gateways.js

@@ -20,6 +20,10 @@ class PaypalGateways extends ApiResource {
         const _paypalGatewayId = paypalGatewayId.id || paypalGatewayId;
         return this.resources.fetch({ type: 'payment_methods' }, `paypal_gateways/${_paypalGatewayId}/payment_methods`, params, options);
     }
+    async versions(paypalGatewayId, params, options) {
+        const _paypalGatewayId = paypalGatewayId.id || paypalGatewayId;
+        return this.resources.fetch({ type: 'versions' }, `paypal_gateways/${_paypalGatewayId}/versions`, params, options);
+    }
     async paypal_payments(paypalGatewayId, params, options) {
         const _paypalGatewayId = paypalGatewayId.id || paypalGatewayId;
         return this.resources.fetch({ type: 'paypal_payments' }, `paypal_gateways/${_paypalGatewayId}/paypal_payments`, params, options);