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

package/lib/cjs/resources/avalara_accounts.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resource_1 = require("../resource");
+class AvalaraAccounts extends resource_1.ApiResource {
+    // static readonly PATH = 'avalara_accounts'
+    async list(params, options) {
+        return this.resources.list({ type: AvalaraAccounts.TYPE }, params, options);
+    }
+    async create(resource, params, options) {
+        return this.resources.create(Object.assign(Object.assign({}, resource), { type: AvalaraAccounts.TYPE }), params, options);
+    }
+    async update(resource, params, options) {
+        return this.resources.update(Object.assign(Object.assign({}, resource), { type: AvalaraAccounts.TYPE }), params, options);
+    }
+    async delete(id, options) {
+        await this.resources.delete((typeof id === 'string') ? { id, type: AvalaraAccounts.TYPE } : id, options);
+    }
+    async markets(avalaraAccountId, params, options) {
+        const _avalaraAccountId = avalaraAccountId.id || avalaraAccountId;
+        return this.resources.fetch({ type: 'markets' }, `avalara_accounts/${_avalaraAccountId}/markets`, params, options);
+    }
+    async attachments(avalaraAccountId, params, options) {
+        const _avalaraAccountId = avalaraAccountId.id || avalaraAccountId;
+        return this.resources.fetch({ type: 'attachments' }, `avalara_accounts/${_avalaraAccountId}/attachments`, 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);
+    }
+    isAvalaraAccount(resource) {
+        return resource.type && (resource.type === AvalaraAccounts.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: AvalaraAccounts.TYPE } : { id: id.id, type: AvalaraAccounts.TYPE };
+    }
+    type() {
+        return AvalaraAccounts.TYPE;
+    }
+}
+AvalaraAccounts.TYPE = 'avalara_accounts';
+exports.default = AvalaraAccounts;

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

@@ -0,0 +1,44 @@
+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 { AxervePayment, AxervePaymentType } from './axerve_payments';
+type AxerveGatewayType = 'axerve_gateways';
+type AxerveGatewayRel = ResourceRel & {
+    type: AxerveGatewayType;
+};
+type AxervePaymentRel = ResourceRel & {
+    type: AxervePaymentType;
+};
+interface AxerveGateway extends Resource {
+    readonly type: AxerveGatewayType;
+    name: string;
+    login: string;
+    payment_methods?: PaymentMethod[];
+    axerve_payments?: AxervePayment[];
+}
+interface AxerveGatewayCreate extends ResourceCreate {
+    name: string;
+    login: string;
+    api_key: string;
+    axerve_payments?: AxervePaymentRel[];
+}
+interface AxerveGatewayUpdate extends ResourceUpdate {
+    name: string;
+    login: string;
+    api_key?: string;
+    axerve_payments?: AxervePaymentRel[];
+}
+declare class AxerveGateways extends ApiResource<AxerveGateway> {
+    static readonly TYPE: AxerveGatewayType;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<AxerveGateway>>;
+    create(resource: AxerveGatewayCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<AxerveGateway>;
+    update(resource: AxerveGatewayUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<AxerveGateway>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    payment_methods(axerveGatewayId: string | AxerveGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<PaymentMethod>>;
+    axerve_payments(axerveGatewayId: string | AxerveGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<AxervePayment>>;
+    isAxerveGateway(resource: any): resource is AxerveGateway;
+    relationship(id: string | ResourceId | null): AxerveGatewayRel;
+    type(): AxerveGatewayType;
+}
+export default AxerveGateways;
+export type { AxerveGateway, AxerveGatewayCreate, AxerveGatewayUpdate, AxerveGatewayType };

package/lib/cjs/resources/axerve_gateways.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resource_1 = require("../resource");
+class AxerveGateways extends resource_1.ApiResource {
+    // static readonly PATH = 'axerve_gateways'
+    async list(params, options) {
+        return this.resources.list({ type: AxerveGateways.TYPE }, params, options);
+    }
+    async create(resource, params, options) {
+        return this.resources.create(Object.assign(Object.assign({}, resource), { type: AxerveGateways.TYPE }), params, options);
+    }
+    async update(resource, params, options) {
+        return this.resources.update(Object.assign(Object.assign({}, resource), { type: AxerveGateways.TYPE }), params, options);
+    }
+    async delete(id, options) {
+        await this.resources.delete((typeof id === 'string') ? { id, type: AxerveGateways.TYPE } : id, options);
+    }
+    async payment_methods(axerveGatewayId, params, options) {
+        const _axerveGatewayId = axerveGatewayId.id || axerveGatewayId;
+        return this.resources.fetch({ type: 'payment_methods' }, `axerve_gateways/${_axerveGatewayId}/payment_methods`, 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);
+    }
+    isAxerveGateway(resource) {
+        return resource.type && (resource.type === AxerveGateways.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: AxerveGateways.TYPE } : { id: id.id, type: AxerveGateways.TYPE };
+    }
+    type() {
+        return AxerveGateways.TYPE;
+    }
+}
+AxerveGateways.TYPE = 'axerve_gateways';
+exports.default = AxerveGateways;

package/lib/cjs/resources/axerve_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 AxervePaymentType = 'axerve_payments';
+type AxervePaymentRel = ResourceRel & {
+    type: AxervePaymentType;
+};
+type OrderRel = ResourceRel & {
+    type: OrderType;
+};
+interface AxervePayment extends Resource {
+    readonly type: AxervePaymentType;
+    login: string;
+    return_url: string;
+    payment_request_data?: object;
+    mismatched_amounts?: boolean;
+    intent_amount_cents: number;
+    intent_amount_float?: number;
+    formatted_intent_amount?: string;
+    payment_instrument?: object;
+    order?: Order;
+    payment_gateway?: PaymentGateway;
+}
+interface AxervePaymentCreate extends ResourceCreate {
+    return_url: string;
+    order: OrderRel;
+}
+interface AxervePaymentUpdate extends ResourceUpdate {
+    payment_request_data?: object;
+    _update?: boolean;
+    order?: OrderRel;
+}
+declare class AxervePayments extends ApiResource<AxervePayment> {
+    static readonly TYPE: AxervePaymentType;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<AxervePayment>>;
+    create(resource: AxervePaymentCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<AxervePayment>;
+    update(resource: AxervePaymentUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<AxervePayment>;
+    delete(id: string | ResourceId, 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>;
+    isAxervePayment(resource: any): resource is AxervePayment;
+    relationship(id: string | ResourceId | null): AxervePaymentRel;
+    type(): AxervePaymentType;
+}
+export default AxervePayments;
+export type { AxervePayment, AxervePaymentCreate, AxervePaymentUpdate, AxervePaymentType };

package/lib/cjs/resources/axerve_payments.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resource_1 = require("../resource");
+class AxervePayments extends resource_1.ApiResource {
+    // static readonly PATH = 'axerve_payments'
+    async list(params, options) {
+        return this.resources.list({ type: AxervePayments.TYPE }, params, options);
+    }
+    async create(resource, params, options) {
+        return this.resources.create(Object.assign(Object.assign({}, resource), { type: AxervePayments.TYPE }), params, options);
+    }
+    async update(resource, params, options) {
+        return this.resources.update(Object.assign(Object.assign({}, resource), { type: AxervePayments.TYPE }), params, options);
+    }
+    async delete(id, options) {
+        await this.resources.delete((typeof id === 'string') ? { id, type: AxervePayments.TYPE } : id, options);
+    }
+    async order(axervePaymentId, params, options) {
+        const _axervePaymentId = axervePaymentId.id || axervePaymentId;
+        return this.resources.fetch({ type: 'orders' }, `axerve_payments/${_axervePaymentId}/order`, params, options);
+    }
+    async payment_gateway(axervePaymentId, params, options) {
+        const _axervePaymentId = axervePaymentId.id || axervePaymentId;
+        return this.resources.fetch({ type: 'payment_gateways' }, `axerve_payments/${_axervePaymentId}/payment_gateway`, params, options);
+    }
+    isAxervePayment(resource) {
+        return resource.type && (resource.type === AxervePayments.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: AxervePayments.TYPE } : { id: id.id, type: AxervePayments.TYPE };
+    }
+    type() {
+        return AxervePayments.TYPE;
+    }
+}
+AxervePayments.TYPE = 'axerve_payments';
+exports.default = AxervePayments;

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

@@ -0,0 +1,36 @@
+import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsRetrieve, QueryParamsList } from '../query';
+import type { Market, MarketType } from './markets';
+import type { Attachment } from './attachments';
+type BillingInfoValidationRuleType = 'billing_info_validation_rules';
+type BillingInfoValidationRuleRel = ResourceRel & {
+    type: BillingInfoValidationRuleType;
+};
+type MarketRel = ResourceRel & {
+    type: MarketType;
+};
+interface BillingInfoValidationRule extends Resource {
+    readonly type: BillingInfoValidationRuleType;
+    market?: Market;
+    attachments?: Attachment[];
+}
+interface BillingInfoValidationRuleCreate extends ResourceCreate {
+    market: MarketRel;
+}
+interface BillingInfoValidationRuleUpdate extends ResourceUpdate {
+    market?: MarketRel;
+}
+declare class BillingInfoValidationRules extends ApiResource<BillingInfoValidationRule> {
+    static readonly TYPE: BillingInfoValidationRuleType;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<BillingInfoValidationRule>>;
+    create(resource: BillingInfoValidationRuleCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<BillingInfoValidationRule>;
+    update(resource: BillingInfoValidationRuleUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<BillingInfoValidationRule>;
+    delete(id: string | ResourceId, 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>>;
+    isBillingInfoValidationRule(resource: any): resource is BillingInfoValidationRule;
+    relationship(id: string | ResourceId | null): BillingInfoValidationRuleRel;
+    type(): BillingInfoValidationRuleType;
+}
+export default BillingInfoValidationRules;
+export type { BillingInfoValidationRule, BillingInfoValidationRuleCreate, BillingInfoValidationRuleUpdate, BillingInfoValidationRuleType };

package/lib/cjs/resources/billing_info_validation_rules.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resource_1 = require("../resource");
+class BillingInfoValidationRules extends resource_1.ApiResource {
+    // static readonly PATH = 'billing_info_validation_rules'
+    async list(params, options) {
+        return this.resources.list({ type: BillingInfoValidationRules.TYPE }, params, options);
+    }
+    async create(resource, params, options) {
+        return this.resources.create(Object.assign(Object.assign({}, resource), { type: BillingInfoValidationRules.TYPE }), params, options);
+    }
+    async update(resource, params, options) {
+        return this.resources.update(Object.assign(Object.assign({}, resource), { type: BillingInfoValidationRules.TYPE }), params, options);
+    }
+    async delete(id, options) {
+        await this.resources.delete((typeof id === 'string') ? { id, type: BillingInfoValidationRules.TYPE } : id, options);
+    }
+    async market(billingInfoValidationRuleId, params, options) {
+        const _billingInfoValidationRuleId = billingInfoValidationRuleId.id || billingInfoValidationRuleId;
+        return this.resources.fetch({ type: 'markets' }, `billing_info_validation_rules/${_billingInfoValidationRuleId}/market`, params, options);
+    }
+    async attachments(billingInfoValidationRuleId, params, options) {
+        const _billingInfoValidationRuleId = billingInfoValidationRuleId.id || billingInfoValidationRuleId;
+        return this.resources.fetch({ type: 'attachments' }, `billing_info_validation_rules/${_billingInfoValidationRuleId}/attachments`, params, options);
+    }
+    isBillingInfoValidationRule(resource) {
+        return resource.type && (resource.type === BillingInfoValidationRules.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: BillingInfoValidationRules.TYPE } : { id: id.id, type: BillingInfoValidationRules.TYPE };
+    }
+    type() {
+        return BillingInfoValidationRules.TYPE;
+    }
+}
+BillingInfoValidationRules.TYPE = 'billing_info_validation_rules';
+exports.default = BillingInfoValidationRules;

package/lib/cjs/resources/bing_geocoders.d.ts

@@ -0,0 +1,36 @@
+import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsRetrieve, QueryParamsList } from '../query';
+import type { Address } from './addresses';
+import type { Attachment } from './attachments';
+type BingGeocoderType = 'bing_geocoders';
+type BingGeocoderRel = ResourceRel & {
+    type: BingGeocoderType;
+};
+interface BingGeocoder extends Resource {
+    readonly type: BingGeocoderType;
+    name: string;
+    addresses?: Address[];
+    attachments?: Attachment[];
+}
+interface BingGeocoderCreate extends ResourceCreate {
+    name: string;
+    key: string;
+}
+interface BingGeocoderUpdate extends ResourceUpdate {
+    name: string;
+    key?: string;
+}
+declare class BingGeocoders extends ApiResource<BingGeocoder> {
+    static readonly TYPE: BingGeocoderType;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<BingGeocoder>>;
+    create(resource: BingGeocoderCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<BingGeocoder>;
+    update(resource: BingGeocoderUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<BingGeocoder>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    addresses(bingGeocoderId: string | BingGeocoder, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Address>>;
+    attachments(bingGeocoderId: string | BingGeocoder, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    isBingGeocoder(resource: any): resource is BingGeocoder;
+    relationship(id: string | ResourceId | null): BingGeocoderRel;
+    type(): BingGeocoderType;
+}
+export default BingGeocoders;
+export type { BingGeocoder, BingGeocoderCreate, BingGeocoderUpdate, BingGeocoderType };

package/lib/cjs/resources/bing_geocoders.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resource_1 = require("../resource");
+class BingGeocoders extends resource_1.ApiResource {
+    // static readonly PATH = 'bing_geocoders'
+    async list(params, options) {
+        return this.resources.list({ type: BingGeocoders.TYPE }, params, options);
+    }
+    async create(resource, params, options) {
+        return this.resources.create(Object.assign(Object.assign({}, resource), { type: BingGeocoders.TYPE }), params, options);
+    }
+    async update(resource, params, options) {
+        return this.resources.update(Object.assign(Object.assign({}, resource), { type: BingGeocoders.TYPE }), params, options);
+    }
+    async delete(id, options) {
+        await this.resources.delete((typeof id === 'string') ? { id, type: BingGeocoders.TYPE } : id, options);
+    }
+    async addresses(bingGeocoderId, params, options) {
+        const _bingGeocoderId = bingGeocoderId.id || bingGeocoderId;
+        return this.resources.fetch({ type: 'addresses' }, `bing_geocoders/${_bingGeocoderId}/addresses`, params, options);
+    }
+    async attachments(bingGeocoderId, params, options) {
+        const _bingGeocoderId = bingGeocoderId.id || bingGeocoderId;
+        return this.resources.fetch({ type: 'attachments' }, `bing_geocoders/${_bingGeocoderId}/attachments`, params, options);
+    }
+    isBingGeocoder(resource) {
+        return resource.type && (resource.type === BingGeocoders.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: BingGeocoders.TYPE } : { id: id.id, type: BingGeocoders.TYPE };
+    }
+    type() {
+        return BingGeocoders.TYPE;
+    }
+}
+BingGeocoders.TYPE = 'bing_geocoders';
+exports.default = BingGeocoders;

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

@@ -0,0 +1,57 @@
+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 { BraintreePayment, BraintreePaymentType } from './braintree_payments';
+type BraintreeGatewayType = 'braintree_gateways';
+type BraintreeGatewayRel = ResourceRel & {
+    type: BraintreeGatewayType;
+};
+type BraintreePaymentRel = ResourceRel & {
+    type: BraintreePaymentType;
+};
+interface BraintreeGateway extends Resource {
+    readonly type: BraintreeGatewayType;
+    name: string;
+    descriptor_name?: string;
+    descriptor_phone?: string;
+    descriptor_url?: string;
+    webhook_endpoint_url?: string;
+    payment_methods?: PaymentMethod[];
+    braintree_payments?: BraintreePayment[];
+}
+interface BraintreeGatewayCreate extends ResourceCreate {
+    name: string;
+    merchant_account_id: string;
+    merchant_id: string;
+    public_key: string;
+    private_key: string;
+    descriptor_name?: string;
+    descriptor_phone?: string;
+    descriptor_url?: string;
+    braintree_payments?: BraintreePaymentRel[];
+}
+interface BraintreeGatewayUpdate extends ResourceUpdate {
+    name: string;
+    merchant_account_id?: string;
+    merchant_id?: string;
+    public_key?: string;
+    private_key?: string;
+    descriptor_name?: string;
+    descriptor_phone?: string;
+    descriptor_url?: string;
+    braintree_payments?: BraintreePaymentRel[];
+}
+declare class BraintreeGateways extends ApiResource<BraintreeGateway> {
+    static readonly TYPE: BraintreeGatewayType;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<BraintreeGateway>>;
+    create(resource: BraintreeGatewayCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<BraintreeGateway>;
+    update(resource: BraintreeGatewayUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<BraintreeGateway>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    payment_methods(braintreeGatewayId: string | BraintreeGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<PaymentMethod>>;
+    braintree_payments(braintreeGatewayId: string | BraintreeGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<BraintreePayment>>;
+    isBraintreeGateway(resource: any): resource is BraintreeGateway;
+    relationship(id: string | ResourceId | null): BraintreeGatewayRel;
+    type(): BraintreeGatewayType;
+}
+export default BraintreeGateways;
+export type { BraintreeGateway, BraintreeGatewayCreate, BraintreeGatewayUpdate, BraintreeGatewayType };

package/lib/cjs/resources/braintree_gateways.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resource_1 = require("../resource");
+class BraintreeGateways extends resource_1.ApiResource {
+    // static readonly PATH = 'braintree_gateways'
+    async list(params, options) {
+        return this.resources.list({ type: BraintreeGateways.TYPE }, params, options);
+    }
+    async create(resource, params, options) {
+        return this.resources.create(Object.assign(Object.assign({}, resource), { type: BraintreeGateways.TYPE }), params, options);
+    }
+    async update(resource, params, options) {
+        return this.resources.update(Object.assign(Object.assign({}, resource), { type: BraintreeGateways.TYPE }), params, options);
+    }
+    async delete(id, options) {
+        await this.resources.delete((typeof id === 'string') ? { id, type: BraintreeGateways.TYPE } : id, options);
+    }
+    async payment_methods(braintreeGatewayId, params, options) {
+        const _braintreeGatewayId = braintreeGatewayId.id || braintreeGatewayId;
+        return this.resources.fetch({ type: 'payment_methods' }, `braintree_gateways/${_braintreeGatewayId}/payment_methods`, 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);
+    }
+    isBraintreeGateway(resource) {
+        return resource.type && (resource.type === BraintreeGateways.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: BraintreeGateways.TYPE } : { id: id.id, type: BraintreeGateways.TYPE };
+    }
+    type() {
+        return BraintreeGateways.TYPE;
+    }
+}
+BraintreeGateways.TYPE = 'braintree_gateways';
+exports.default = BraintreeGateways;

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

@@ -0,0 +1,49 @@
+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 BraintreePaymentType = 'braintree_payments';
+type BraintreePaymentRel = ResourceRel & {
+    type: BraintreePaymentType;
+};
+type OrderRel = ResourceRel & {
+    type: OrderType;
+};
+interface BraintreePayment extends Resource {
+    readonly type: BraintreePaymentType;
+    client_token: string;
+    payment_method_nonce?: string;
+    payment_id?: string;
+    local?: boolean;
+    options?: object;
+    payment_instrument?: object;
+    order?: Order;
+    payment_gateway?: PaymentGateway;
+}
+interface BraintreePaymentCreate extends ResourceCreate {
+    payment_id?: string;
+    local?: boolean;
+    options?: object;
+    order: OrderRel;
+}
+interface BraintreePaymentUpdate extends ResourceUpdate {
+    payment_method_nonce?: string;
+    payment_id?: string;
+    local?: boolean;
+    options?: object;
+    order?: OrderRel;
+}
+declare class BraintreePayments extends ApiResource<BraintreePayment> {
+    static readonly TYPE: BraintreePaymentType;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<BraintreePayment>>;
+    create(resource: BraintreePaymentCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<BraintreePayment>;
+    update(resource: BraintreePaymentUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<BraintreePayment>;
+    delete(id: string | ResourceId, 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>;
+    isBraintreePayment(resource: any): resource is BraintreePayment;
+    relationship(id: string | ResourceId | null): BraintreePaymentRel;
+    type(): BraintreePaymentType;
+}
+export default BraintreePayments;
+export type { BraintreePayment, BraintreePaymentCreate, BraintreePaymentUpdate, BraintreePaymentType };

package/lib/cjs/resources/braintree_payments.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resource_1 = require("../resource");
+class BraintreePayments extends resource_1.ApiResource {
+    // static readonly PATH = 'braintree_payments'
+    async list(params, options) {
+        return this.resources.list({ type: BraintreePayments.TYPE }, params, options);
+    }
+    async create(resource, params, options) {
+        return this.resources.create(Object.assign(Object.assign({}, resource), { type: BraintreePayments.TYPE }), params, options);
+    }
+    async update(resource, params, options) {
+        return this.resources.update(Object.assign(Object.assign({}, resource), { type: BraintreePayments.TYPE }), params, options);
+    }
+    async delete(id, options) {
+        await this.resources.delete((typeof id === 'string') ? { id, type: BraintreePayments.TYPE } : id, options);
+    }
+    async order(braintreePaymentId, params, options) {
+        const _braintreePaymentId = braintreePaymentId.id || braintreePaymentId;
+        return this.resources.fetch({ type: 'orders' }, `braintree_payments/${_braintreePaymentId}/order`, params, options);
+    }
+    async payment_gateway(braintreePaymentId, params, options) {
+        const _braintreePaymentId = braintreePaymentId.id || braintreePaymentId;
+        return this.resources.fetch({ type: 'payment_gateways' }, `braintree_payments/${_braintreePaymentId}/payment_gateway`, params, options);
+    }
+    isBraintreePayment(resource) {
+        return resource.type && (resource.type === BraintreePayments.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: BraintreePayments.TYPE } : { id: id.id, type: BraintreePayments.TYPE };
+    }
+    type() {
+        return BraintreePayments.TYPE;
+    }
+}
+BraintreePayments.TYPE = 'braintree_payments';
+exports.default = BraintreePayments;

package/lib/cjs/resources/bundles.d.ts

@@ -0,0 +1,77 @@
+import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsRetrieve, QueryParamsList } from '../query';
+import type { Market, MarketType } from './markets';
+import type { SkuList, SkuListType } from './sku_lists';
+import type { Sku } from './skus';
+import type { Attachment } from './attachments';
+type BundleType = 'bundles';
+type BundleRel = ResourceRel & {
+    type: BundleType;
+};
+type MarketRel = ResourceRel & {
+    type: MarketType;
+};
+type SkuListRel = ResourceRel & {
+    type: SkuListType;
+};
+interface Bundle extends Resource {
+    readonly type: BundleType;
+    code: string;
+    name: string;
+    currency_code?: string;
+    description?: string;
+    image_url?: string;
+    do_not_ship?: boolean;
+    do_not_track?: boolean;
+    price_amount_cents: number;
+    price_amount_float: number;
+    formatted_price_amount: string;
+    compare_at_amount_cents: number;
+    compare_at_amount_float: number;
+    formatted_compare_at_amount: string;
+    skus_count?: number;
+    market?: Market;
+    sku_list?: SkuList;
+    skus?: Sku[];
+    attachments?: Attachment[];
+}
+interface BundleCreate extends ResourceCreate {
+    code: string;
+    name: string;
+    currency_code?: string;
+    description?: string;
+    image_url?: string;
+    price_amount_cents: number;
+    compare_at_amount_cents: number;
+    _compute_price_amount?: boolean;
+    _compute_compare_at_amount?: boolean;
+    market?: MarketRel;
+    sku_list: SkuListRel;
+}
+interface BundleUpdate extends ResourceUpdate {
+    code: string;
+    name: string;
+    currency_code?: string;
+    description?: string;
+    image_url?: string;
+    price_amount_cents: number;
+    compare_at_amount_cents: number;
+    _compute_price_amount?: boolean;
+    _compute_compare_at_amount?: boolean;
+}
+declare class Bundles extends ApiResource<Bundle> {
+    static readonly TYPE: BundleType;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Bundle>>;
+    create(resource: BundleCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Bundle>;
+    update(resource: BundleUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Bundle>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    market(bundleId: string | Bundle, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Market>;
+    sku_list(bundleId: string | Bundle, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<SkuList>;
+    skus(bundleId: string | Bundle, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Sku>>;
+    attachments(bundleId: string | Bundle, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    isBundle(resource: any): resource is Bundle;
+    relationship(id: string | ResourceId | null): BundleRel;
+    type(): BundleType;
+}
+export default Bundles;
+export type { Bundle, BundleCreate, BundleUpdate, BundleType };