@commercelayer/sdk 5.0.0-alpha.5 → 5.0.0-beta.2

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

@@ -0,0 +1,45 @@
+import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsRetrieve, QueryParamsList } from '../query';
+import type { PaymentMethod } from './payment_methods';
+import type { KlarnaPayment, KlarnaPaymentType } from './klarna_payments';
+type KlarnaGatewayType = 'klarna_gateways';
+type KlarnaGatewayRel = ResourceRel & {
+    type: KlarnaGatewayType;
+};
+type KlarnaPaymentRel = ResourceRel & {
+    type: KlarnaPaymentType;
+};
+interface KlarnaGateway extends Resource {
+    readonly type: KlarnaGatewayType;
+    name: string;
+    payment_methods?: PaymentMethod[];
+    klarna_payments?: KlarnaPayment[];
+}
+interface KlarnaGatewayCreate extends ResourceCreate {
+    name: string;
+    country_code: string;
+    api_key: string;
+    api_secret: string;
+    klarna_payments?: KlarnaPaymentRel[];
+}
+interface KlarnaGatewayUpdate extends ResourceUpdate {
+    name: string;
+    country_code?: string;
+    api_key?: string;
+    api_secret?: string;
+    klarna_payments?: KlarnaPaymentRel[];
+}
+declare class KlarnaGateways extends ApiResource<KlarnaGateway> {
+    static readonly TYPE: KlarnaGatewayType;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<KlarnaGateway>>;
+    create(resource: KlarnaGatewayCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<KlarnaGateway>;
+    update(resource: KlarnaGatewayUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<KlarnaGateway>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    payment_methods(klarnaGatewayId: string | KlarnaGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<PaymentMethod>>;
+    klarna_payments(klarnaGatewayId: string | KlarnaGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<KlarnaPayment>>;
+    isKlarnaGateway(resource: any): resource is KlarnaGateway;
+    relationship(id: string | ResourceId | null): KlarnaGatewayRel;
+    type(): KlarnaGatewayType;
+}
+export default KlarnaGateways;
+export type { KlarnaGateway, KlarnaGatewayCreate, KlarnaGatewayUpdate, KlarnaGatewayType };

package/lib/esm/resources/klarna_gateways.js

@@ -0,0 +1,35 @@
+import { ApiResource } from '../resource';
+class KlarnaGateways extends ApiResource {
+    // static readonly PATH = 'klarna_gateways'
+    async list(params, options) {
+        return this.resources.list({ type: KlarnaGateways.TYPE }, params, options);
+    }
+    async create(resource, params, options) {
+        return this.resources.create(Object.assign(Object.assign({}, resource), { type: KlarnaGateways.TYPE }), params, options);
+    }
+    async update(resource, params, options) {
+        return this.resources.update(Object.assign(Object.assign({}, resource), { type: KlarnaGateways.TYPE }), params, options);
+    }
+    async delete(id, options) {
+        await this.resources.delete((typeof id === 'string') ? { id, type: KlarnaGateways.TYPE } : id, options);
+    }
+    async payment_methods(klarnaGatewayId, params, options) {
+        const _klarnaGatewayId = klarnaGatewayId.id || klarnaGatewayId;
+        return this.resources.fetch({ type: 'payment_methods' }, `klarna_gateways/${_klarnaGatewayId}/payment_methods`, params, options);
+    }
+    async klarna_payments(klarnaGatewayId, params, options) {
+        const _klarnaGatewayId = klarnaGatewayId.id || klarnaGatewayId;
+        return this.resources.fetch({ type: 'klarna_payments' }, `klarna_gateways/${_klarnaGatewayId}/klarna_payments`, params, options);
+    }
+    isKlarnaGateway(resource) {
+        return resource.type && (resource.type === KlarnaGateways.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: KlarnaGateways.TYPE } : { id: id.id, type: KlarnaGateways.TYPE };
+    }
+    type() {
+        return KlarnaGateways.TYPE;
+    }
+}
+KlarnaGateways.TYPE = 'klarna_gateways';
+export default KlarnaGateways;

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

@@ -0,0 +1,47 @@
+import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsRetrieve, QueryParamsList } from '../query';
+import type { Order, OrderType } from './orders';
+import type { PaymentGateway } from './payment_gateways';
+type KlarnaPaymentType = 'klarna_payments';
+type KlarnaPaymentRel = ResourceRel & {
+    type: KlarnaPaymentType;
+};
+type OrderRel = ResourceRel & {
+    type: OrderType;
+};
+interface KlarnaPayment extends Resource {
+    readonly type: KlarnaPaymentType;
+    session_id?: string;
+    client_token?: string;
+    payment_methods: object[];
+    auth_token?: string;
+    mismatched_amounts?: boolean;
+    intent_amount_cents: number;
+    intent_amount_float?: number;
+    formatted_intent_amount?: string;
+    payment_instrument?: object;
+    order?: Order;
+    payment_gateway?: PaymentGateway;
+}
+interface KlarnaPaymentCreate extends ResourceCreate {
+    order: OrderRel;
+}
+interface KlarnaPaymentUpdate extends ResourceUpdate {
+    auth_token?: string;
+    _update?: boolean;
+    order?: OrderRel;
+}
+declare class KlarnaPayments extends ApiResource<KlarnaPayment> {
+    static readonly TYPE: KlarnaPaymentType;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<KlarnaPayment>>;
+    create(resource: KlarnaPaymentCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<KlarnaPayment>;
+    update(resource: KlarnaPaymentUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<KlarnaPayment>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    order(klarnaPaymentId: string | KlarnaPayment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Order>;
+    payment_gateway(klarnaPaymentId: string | KlarnaPayment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<PaymentGateway>;
+    isKlarnaPayment(resource: any): resource is KlarnaPayment;
+    relationship(id: string | ResourceId | null): KlarnaPaymentRel;
+    type(): KlarnaPaymentType;
+}
+export default KlarnaPayments;
+export type { KlarnaPayment, KlarnaPaymentCreate, KlarnaPaymentUpdate, KlarnaPaymentType };

package/lib/esm/resources/klarna_payments.js

@@ -0,0 +1,35 @@
+import { ApiResource } from '../resource';
+class KlarnaPayments extends ApiResource {
+    // static readonly PATH = 'klarna_payments'
+    async list(params, options) {
+        return this.resources.list({ type: KlarnaPayments.TYPE }, params, options);
+    }
+    async create(resource, params, options) {
+        return this.resources.create(Object.assign(Object.assign({}, resource), { type: KlarnaPayments.TYPE }), params, options);
+    }
+    async update(resource, params, options) {
+        return this.resources.update(Object.assign(Object.assign({}, resource), { type: KlarnaPayments.TYPE }), params, options);
+    }
+    async delete(id, options) {
+        await this.resources.delete((typeof id === 'string') ? { id, type: KlarnaPayments.TYPE } : id, options);
+    }
+    async order(klarnaPaymentId, params, options) {
+        const _klarnaPaymentId = klarnaPaymentId.id || klarnaPaymentId;
+        return this.resources.fetch({ type: 'orders' }, `klarna_payments/${_klarnaPaymentId}/order`, params, options);
+    }
+    async payment_gateway(klarnaPaymentId, params, options) {
+        const _klarnaPaymentId = klarnaPaymentId.id || klarnaPaymentId;
+        return this.resources.fetch({ type: 'payment_gateways' }, `klarna_payments/${_klarnaPaymentId}/payment_gateway`, params, options);
+    }
+    isKlarnaPayment(resource) {
+        return resource.type && (resource.type === KlarnaPayments.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: KlarnaPayments.TYPE } : { id: id.id, type: KlarnaPayments.TYPE };
+    }
+    type() {
+        return KlarnaPayments.TYPE;
+    }
+}
+KlarnaPayments.TYPE = 'klarna_payments';
+export default KlarnaPayments;

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

@@ -0,0 +1,58 @@
+import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsRetrieve, QueryParamsList } from '../query';
+import type { LineItem, LineItemType } from './line_items';
+import type { SkuOption, SkuOptionType } from './sku_options';
+type LineItemOptionType = 'line_item_options';
+type LineItemOptionRel = ResourceRel & {
+    type: LineItemOptionType;
+};
+type LineItemRel = ResourceRel & {
+    type: LineItemType;
+};
+type SkuOptionRel = ResourceRel & {
+    type: SkuOptionType;
+};
+interface LineItemOption extends Resource {
+    readonly type: LineItemOptionType;
+    name?: string;
+    quantity: number;
+    currency_code?: string;
+    unit_amount_cents?: number;
+    unit_amount_float?: number;
+    formatted_unit_amount?: string;
+    total_amount_cents?: number;
+    total_amount_float: number;
+    formatted_total_amount?: string;
+    delay_hours?: number;
+    delay_days?: number;
+    options: object;
+    line_item?: LineItem;
+    sku_option?: SkuOption;
+}
+interface LineItemOptionCreate extends ResourceCreate {
+    name?: string;
+    quantity: number;
+    options: object;
+    line_item: LineItemRel;
+    sku_option: SkuOptionRel;
+}
+interface LineItemOptionUpdate extends ResourceUpdate {
+    name?: string;
+    quantity: number;
+    options: object;
+    sku_option?: SkuOptionRel;
+}
+declare class LineItemOptions extends ApiResource<LineItemOption> {
+    static readonly TYPE: LineItemOptionType;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<LineItemOption>>;
+    create(resource: LineItemOptionCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<LineItemOption>;
+    update(resource: LineItemOptionUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<LineItemOption>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    line_item(lineItemOptionId: string | LineItemOption, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<LineItem>;
+    sku_option(lineItemOptionId: string | LineItemOption, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<SkuOption>;
+    isLineItemOption(resource: any): resource is LineItemOption;
+    relationship(id: string | ResourceId | null): LineItemOptionRel;
+    type(): LineItemOptionType;
+}
+export default LineItemOptions;
+export type { LineItemOption, LineItemOptionCreate, LineItemOptionUpdate, LineItemOptionType };

package/lib/esm/resources/line_item_options.js

@@ -0,0 +1,35 @@
+import { ApiResource } from '../resource';
+class LineItemOptions extends ApiResource {
+    // static readonly PATH = 'line_item_options'
+    async list(params, options) {
+        return this.resources.list({ type: LineItemOptions.TYPE }, params, options);
+    }
+    async create(resource, params, options) {
+        return this.resources.create(Object.assign(Object.assign({}, resource), { type: LineItemOptions.TYPE }), params, options);
+    }
+    async update(resource, params, options) {
+        return this.resources.update(Object.assign(Object.assign({}, resource), { type: LineItemOptions.TYPE }), params, options);
+    }
+    async delete(id, options) {
+        await this.resources.delete((typeof id === 'string') ? { id, type: LineItemOptions.TYPE } : id, options);
+    }
+    async line_item(lineItemOptionId, params, options) {
+        const _lineItemOptionId = lineItemOptionId.id || lineItemOptionId;
+        return this.resources.fetch({ type: 'line_items' }, `line_item_options/${_lineItemOptionId}/line_item`, params, options);
+    }
+    async sku_option(lineItemOptionId, params, options) {
+        const _lineItemOptionId = lineItemOptionId.id || lineItemOptionId;
+        return this.resources.fetch({ type: 'sku_options' }, `line_item_options/${_lineItemOptionId}/sku_option`, params, options);
+    }
+    isLineItemOption(resource) {
+        return resource.type && (resource.type === LineItemOptions.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: LineItemOptions.TYPE } : { id: id.id, type: LineItemOptions.TYPE };
+    }
+    type() {
+        return LineItemOptions.TYPE;
+    }
+}
+LineItemOptions.TYPE = 'line_item_options';
+export default LineItemOptions;

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

@@ -0,0 +1,127 @@
+import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsRetrieve, QueryParamsList } from '../query';
+import type { Order, OrderType } from './orders';
+import type { Adjustment, AdjustmentType } from './adjustments';
+import type { Bundle, BundleType } from './bundles';
+import type { ExternalPromotion, ExternalPromotionType } from './external_promotions';
+import type { FixedAmountPromotion, FixedAmountPromotionType } from './fixed_amount_promotions';
+import type { FreeShippingPromotion, FreeShippingPromotionType } from './free_shipping_promotions';
+import type { GiftCard, GiftCardType } from './gift_cards';
+import type { PaymentMethod, PaymentMethodType } from './payment_methods';
+import type { PercentageDiscountPromotion, PercentageDiscountPromotionType } from './percentage_discount_promotions';
+import type { Shipment, ShipmentType } from './shipments';
+import type { Sku, SkuType } from './skus';
+import type { LineItemOption } from './line_item_options';
+import type { StockLineItem } from './stock_line_items';
+import type { StockTransfer } from './stock_transfers';
+type LineItemType = 'line_items';
+type LineItemRel = ResourceRel & {
+    type: LineItemType;
+};
+type OrderRel = ResourceRel & {
+    type: OrderType;
+};
+type AdjustmentRel = ResourceRel & {
+    type: AdjustmentType;
+};
+type BundleRel = ResourceRel & {
+    type: BundleType;
+};
+type ExternalPromotionRel = ResourceRel & {
+    type: ExternalPromotionType;
+};
+type FixedAmountPromotionRel = ResourceRel & {
+    type: FixedAmountPromotionType;
+};
+type FreeShippingPromotionRel = ResourceRel & {
+    type: FreeShippingPromotionType;
+};
+type GiftCardRel = ResourceRel & {
+    type: GiftCardType;
+};
+type PaymentMethodRel = ResourceRel & {
+    type: PaymentMethodType;
+};
+type PercentageDiscountPromotionRel = ResourceRel & {
+    type: PercentageDiscountPromotionType;
+};
+type ShipmentRel = ResourceRel & {
+    type: ShipmentType;
+};
+type SkuRel = ResourceRel & {
+    type: SkuType;
+};
+interface LineItem extends Resource {
+    readonly type: LineItemType;
+    sku_code?: string;
+    bundle_code?: string;
+    quantity: number;
+    currency_code?: string;
+    unit_amount_cents?: number;
+    unit_amount_float?: number;
+    formatted_unit_amount?: string;
+    options_amount_cents?: number;
+    options_amount_float?: number;
+    formatted_options_amount?: string;
+    discount_cents?: number;
+    discount_float?: number;
+    formatted_discount?: string;
+    total_amount_cents?: number;
+    total_amount_float: number;
+    formatted_total_amount?: string;
+    tax_amount_cents?: number;
+    tax_amount_float: number;
+    formatted_tax_amount?: string;
+    name?: string;
+    image_url?: string;
+    discount_breakdown?: object;
+    tax_rate?: number;
+    tax_breakdown?: object;
+    item_type?: string;
+    order?: Order;
+    item?: Adjustment | Bundle | ExternalPromotion | FixedAmountPromotion | FreeShippingPromotion | GiftCard | PaymentMethod | PercentageDiscountPromotion | Shipment | Sku;
+    line_item_options?: LineItemOption[];
+    /**
+    * @deprecated This field should not be used as it may be removed in the future without notice
+    */
+    shipment_line_items?: object[];
+    stock_line_items?: StockLineItem[];
+    stock_transfers?: StockTransfer[];
+}
+interface LineItemCreate extends ResourceCreate {
+    sku_code?: string;
+    bundle_code?: string;
+    quantity: number;
+    _external_price?: boolean;
+    _update_quantity?: boolean;
+    unit_amount_cents?: number;
+    name?: string;
+    image_url?: string;
+    item_type?: string;
+    order: OrderRel;
+    item?: AdjustmentRel | BundleRel | ExternalPromotionRel | FixedAmountPromotionRel | FreeShippingPromotionRel | GiftCardRel | PaymentMethodRel | PercentageDiscountPromotionRel | ShipmentRel | SkuRel;
+}
+interface LineItemUpdate extends ResourceUpdate {
+    sku_code?: string;
+    bundle_code?: string;
+    quantity: number;
+    _external_price?: boolean;
+    name?: string;
+    image_url?: string;
+}
+declare class LineItems extends ApiResource<LineItem> {
+    static readonly TYPE: LineItemType;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<LineItem>>;
+    create(resource: LineItemCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<LineItem>;
+    update(resource: LineItemUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<LineItem>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    order(lineItemId: string | LineItem, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Order>;
+    line_item_options(lineItemId: string | LineItem, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<LineItemOption>>;
+    stock_line_items(lineItemId: string | LineItem, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<StockLineItem>>;
+    stock_transfers(lineItemId: string | LineItem, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<StockTransfer>>;
+    isLineItem(resource: any): resource is LineItem;
+    relationship(id: string | ResourceId | null): LineItemRel;
+    type(): LineItemType;
+}
+export default LineItems;
+export type { LineItem, LineItemCreate, LineItemUpdate, LineItemType };

package/lib/esm/resources/line_items.js

@@ -0,0 +1,43 @@
+import { ApiResource } from '../resource';
+class LineItems extends ApiResource {
+    // static readonly PATH = 'line_items'
+    async list(params, options) {
+        return this.resources.list({ type: LineItems.TYPE }, params, options);
+    }
+    async create(resource, params, options) {
+        return this.resources.create(Object.assign(Object.assign({}, resource), { type: LineItems.TYPE }), params, options);
+    }
+    async update(resource, params, options) {
+        return this.resources.update(Object.assign(Object.assign({}, resource), { type: LineItems.TYPE }), params, options);
+    }
+    async delete(id, options) {
+        await this.resources.delete((typeof id === 'string') ? { id, type: LineItems.TYPE } : id, options);
+    }
+    async order(lineItemId, params, options) {
+        const _lineItemId = lineItemId.id || lineItemId;
+        return this.resources.fetch({ type: 'orders' }, `line_items/${_lineItemId}/order`, params, options);
+    }
+    async line_item_options(lineItemId, params, options) {
+        const _lineItemId = lineItemId.id || lineItemId;
+        return this.resources.fetch({ type: 'line_item_options' }, `line_items/${_lineItemId}/line_item_options`, params, options);
+    }
+    async stock_line_items(lineItemId, params, options) {
+        const _lineItemId = lineItemId.id || lineItemId;
+        return this.resources.fetch({ type: 'stock_line_items' }, `line_items/${_lineItemId}/stock_line_items`, params, options);
+    }
+    async stock_transfers(lineItemId, params, options) {
+        const _lineItemId = lineItemId.id || lineItemId;
+        return this.resources.fetch({ type: 'stock_transfers' }, `line_items/${_lineItemId}/stock_transfers`, params, options);
+    }
+    isLineItem(resource) {
+        return resource.type && (resource.type === LineItems.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: LineItems.TYPE } : { id: id.id, type: LineItems.TYPE };
+    }
+    type() {
+        return LineItems.TYPE;
+    }
+}
+LineItems.TYPE = 'line_items';
+export default LineItems;

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

@@ -0,0 +1,31 @@
+import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsRetrieve, QueryParamsList } from '../query';
+import type { PaymentMethod } from './payment_methods';
+type ManualGatewayType = 'manual_gateways';
+type ManualGatewayRel = ResourceRel & {
+    type: ManualGatewayType;
+};
+interface ManualGateway extends Resource {
+    readonly type: ManualGatewayType;
+    name: string;
+    payment_methods?: PaymentMethod[];
+}
+interface ManualGatewayCreate extends ResourceCreate {
+    name: string;
+}
+interface ManualGatewayUpdate extends ResourceUpdate {
+    name: string;
+}
+declare class ManualGateways extends ApiResource<ManualGateway> {
+    static readonly TYPE: ManualGatewayType;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<ManualGateway>>;
+    create(resource: ManualGatewayCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<ManualGateway>;
+    update(resource: ManualGatewayUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<ManualGateway>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    payment_methods(manualGatewayId: string | ManualGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<PaymentMethod>>;
+    isManualGateway(resource: any): resource is ManualGateway;
+    relationship(id: string | ResourceId | null): ManualGatewayRel;
+    type(): ManualGatewayType;
+}
+export default ManualGateways;
+export type { ManualGateway, ManualGatewayCreate, ManualGatewayUpdate, ManualGatewayType };

package/lib/esm/resources/manual_gateways.js

@@ -0,0 +1,31 @@
+import { ApiResource } from '../resource';
+class ManualGateways extends ApiResource {
+    // static readonly PATH = 'manual_gateways'
+    async list(params, options) {
+        return this.resources.list({ type: ManualGateways.TYPE }, params, options);
+    }
+    async create(resource, params, options) {
+        return this.resources.create(Object.assign(Object.assign({}, resource), { type: ManualGateways.TYPE }), params, options);
+    }
+    async update(resource, params, options) {
+        return this.resources.update(Object.assign(Object.assign({}, resource), { type: ManualGateways.TYPE }), params, options);
+    }
+    async delete(id, options) {
+        await this.resources.delete((typeof id === 'string') ? { id, type: ManualGateways.TYPE } : id, options);
+    }
+    async payment_methods(manualGatewayId, params, options) {
+        const _manualGatewayId = manualGatewayId.id || manualGatewayId;
+        return this.resources.fetch({ type: 'payment_methods' }, `manual_gateways/${_manualGatewayId}/payment_methods`, params, options);
+    }
+    isManualGateway(resource) {
+        return resource.type && (resource.type === ManualGateways.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: ManualGateways.TYPE } : { id: id.id, type: ManualGateways.TYPE };
+    }
+    type() {
+        return ManualGateways.TYPE;
+    }
+}
+ManualGateways.TYPE = 'manual_gateways';
+export default ManualGateways;

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

@@ -0,0 +1,42 @@
+import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsRetrieve, QueryParamsList } from '../query';
+import type { Market } from './markets';
+import type { Attachment } from './attachments';
+import type { TaxRule, TaxRuleType } from './tax_rules';
+type ManualTaxCalculatorType = 'manual_tax_calculators';
+type ManualTaxCalculatorRel = ResourceRel & {
+    type: ManualTaxCalculatorType;
+};
+type TaxRuleRel = ResourceRel & {
+    type: TaxRuleType;
+};
+interface ManualTaxCalculator extends Resource {
+    readonly type: ManualTaxCalculatorType;
+    name: string;
+    markets?: Market[];
+    attachments?: Attachment[];
+    tax_rules?: TaxRule[];
+}
+interface ManualTaxCalculatorCreate extends ResourceCreate {
+    name: string;
+    tax_rules?: TaxRuleRel[];
+}
+interface ManualTaxCalculatorUpdate extends ResourceUpdate {
+    name: string;
+    tax_rules?: TaxRuleRel[];
+}
+declare class ManualTaxCalculators extends ApiResource<ManualTaxCalculator> {
+    static readonly TYPE: ManualTaxCalculatorType;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<ManualTaxCalculator>>;
+    create(resource: ManualTaxCalculatorCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<ManualTaxCalculator>;
+    update(resource: ManualTaxCalculatorUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<ManualTaxCalculator>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    markets(manualTaxCalculatorId: string | ManualTaxCalculator, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Market>>;
+    attachments(manualTaxCalculatorId: string | ManualTaxCalculator, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    tax_rules(manualTaxCalculatorId: string | ManualTaxCalculator, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<TaxRule>>;
+    isManualTaxCalculator(resource: any): resource is ManualTaxCalculator;
+    relationship(id: string | ResourceId | null): ManualTaxCalculatorRel;
+    type(): ManualTaxCalculatorType;
+}
+export default ManualTaxCalculators;
+export type { ManualTaxCalculator, ManualTaxCalculatorCreate, ManualTaxCalculatorUpdate, ManualTaxCalculatorType };

package/lib/esm/resources/manual_tax_calculators.js

@@ -0,0 +1,39 @@
+import { ApiResource } from '../resource';
+class ManualTaxCalculators extends ApiResource {
+    // static readonly PATH = 'manual_tax_calculators'
+    async list(params, options) {
+        return this.resources.list({ type: ManualTaxCalculators.TYPE }, params, options);
+    }
+    async create(resource, params, options) {
+        return this.resources.create(Object.assign(Object.assign({}, resource), { type: ManualTaxCalculators.TYPE }), params, options);
+    }
+    async update(resource, params, options) {
+        return this.resources.update(Object.assign(Object.assign({}, resource), { type: ManualTaxCalculators.TYPE }), params, options);
+    }
+    async delete(id, options) {
+        await this.resources.delete((typeof id === 'string') ? { id, type: ManualTaxCalculators.TYPE } : id, options);
+    }
+    async markets(manualTaxCalculatorId, params, options) {
+        const _manualTaxCalculatorId = manualTaxCalculatorId.id || manualTaxCalculatorId;
+        return this.resources.fetch({ type: 'markets' }, `manual_tax_calculators/${_manualTaxCalculatorId}/markets`, params, options);
+    }
+    async attachments(manualTaxCalculatorId, params, options) {
+        const _manualTaxCalculatorId = manualTaxCalculatorId.id || manualTaxCalculatorId;
+        return this.resources.fetch({ type: 'attachments' }, `manual_tax_calculators/${_manualTaxCalculatorId}/attachments`, params, options);
+    }
+    async tax_rules(manualTaxCalculatorId, params, options) {
+        const _manualTaxCalculatorId = manualTaxCalculatorId.id || manualTaxCalculatorId;
+        return this.resources.fetch({ type: 'tax_rules' }, `manual_tax_calculators/${_manualTaxCalculatorId}/tax_rules`, params, options);
+    }
+    isManualTaxCalculator(resource) {
+        return resource.type && (resource.type === ManualTaxCalculators.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: ManualTaxCalculators.TYPE } : { id: id.id, type: ManualTaxCalculators.TYPE };
+    }
+    type() {
+        return ManualTaxCalculators.TYPE;
+    }
+}
+ManualTaxCalculators.TYPE = 'manual_tax_calculators';
+export default ManualTaxCalculators;