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

package/lib/cjs/resources/stripe_gateways.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 { PaymentMethod } from './payment_methods';
+import type { StripePayment } from './stripe_payments';
+type StripeGatewayType = 'stripe_gateways';
+type StripeGatewayRel = ResourceRel & {
+    type: StripeGatewayType;
+};
+interface StripeGateway extends Resource {
+    readonly type: StripeGatewayType;
+    name: string;
+    auto_payments?: boolean;
+    webhook_endpoint_id?: string;
+    webhook_endpoint_secret?: string;
+    webhook_endpoint_url?: string;
+    payment_methods?: PaymentMethod[];
+    stripe_payments?: StripePayment[];
+}
+interface StripeGatewayCreate extends ResourceCreate {
+    name: string;
+    login: string;
+    publishable_key?: string;
+    auto_payments?: boolean;
+}
+interface StripeGatewayUpdate extends ResourceUpdate {
+    name: string;
+    auto_payments?: boolean;
+}
+declare class StripeGateways extends ApiResource<StripeGateway> {
+    static readonly TYPE: StripeGatewayType;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<StripeGateway>>;
+    create(resource: StripeGatewayCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<StripeGateway>;
+    update(resource: StripeGatewayUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<StripeGateway>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    payment_methods(stripeGatewayId: string | StripeGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<PaymentMethod>>;
+    stripe_payments(stripeGatewayId: string | StripeGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<StripePayment>>;
+    isStripeGateway(resource: any): resource is StripeGateway;
+    relationship(id: string | ResourceId | null): StripeGatewayRel;
+    type(): StripeGatewayType;
+}
+export default StripeGateways;
+export type { StripeGateway, StripeGatewayCreate, StripeGatewayUpdate, StripeGatewayType };

package/lib/cjs/resources/stripe_gateways.js

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

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

@@ -0,0 +1,48 @@
+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 StripePaymentType = 'stripe_payments';
+type StripePaymentRel = ResourceRel & {
+    type: StripePaymentType;
+};
+type OrderRel = ResourceRel & {
+    type: OrderType;
+};
+interface StripePayment extends Resource {
+    readonly type: StripePaymentType;
+    client_secret: string;
+    publishable_key?: string;
+    options?: object;
+    payment_method?: 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 StripePaymentCreate extends ResourceCreate {
+    options?: object;
+    order: OrderRel;
+}
+interface StripePaymentUpdate extends ResourceUpdate {
+    options?: object;
+    _refresh?: boolean;
+    order?: OrderRel;
+}
+declare class StripePayments extends ApiResource<StripePayment> {
+    static readonly TYPE: StripePaymentType;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<StripePayment>>;
+    create(resource: StripePaymentCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<StripePayment>;
+    update(resource: StripePaymentUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<StripePayment>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    order(stripePaymentId: string | StripePayment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Order>;
+    payment_gateway(stripePaymentId: string | StripePayment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<PaymentGateway>;
+    isStripePayment(resource: any): resource is StripePayment;
+    relationship(id: string | ResourceId | null): StripePaymentRel;
+    type(): StripePaymentType;
+}
+export default StripePayments;
+export type { StripePayment, StripePaymentCreate, StripePaymentUpdate, StripePaymentType };

package/lib/cjs/resources/stripe_payments.js

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

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

@@ -0,0 +1,25 @@
+import { ApiResource, Resource, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsList } from '../query';
+import type { Market } from './markets';
+import type { Attachment } from './attachments';
+type TaxCalculatorType = 'tax_calculators';
+type TaxCalculatorRel = ResourceRel & {
+    type: TaxCalculatorType;
+};
+interface TaxCalculator extends Resource {
+    readonly type: TaxCalculatorType;
+    name: string;
+    markets?: Market[];
+    attachments?: Attachment[];
+}
+declare class TaxCalculators extends ApiResource<TaxCalculator> {
+    static readonly TYPE: TaxCalculatorType;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<TaxCalculator>>;
+    markets(taxCalculatorId: string | TaxCalculator, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Market>>;
+    attachments(taxCalculatorId: string | TaxCalculator, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    isTaxCalculator(resource: any): resource is TaxCalculator;
+    relationship(id: string | ResourceId | null): TaxCalculatorRel;
+    type(): TaxCalculatorType;
+}
+export default TaxCalculators;
+export type { TaxCalculator, TaxCalculatorType };

package/lib/cjs/resources/tax_calculators.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resource_1 = require("../resource");
+class TaxCalculators extends resource_1.ApiResource {
+    // static readonly PATH = 'tax_calculators'
+    async list(params, options) {
+        return this.resources.list({ type: TaxCalculators.TYPE }, params, options);
+    }
+    async markets(taxCalculatorId, params, options) {
+        const _taxCalculatorId = taxCalculatorId.id || taxCalculatorId;
+        return this.resources.fetch({ type: 'markets' }, `tax_calculators/${_taxCalculatorId}/markets`, params, options);
+    }
+    async attachments(taxCalculatorId, params, options) {
+        const _taxCalculatorId = taxCalculatorId.id || taxCalculatorId;
+        return this.resources.fetch({ type: 'attachments' }, `tax_calculators/${_taxCalculatorId}/attachments`, params, options);
+    }
+    isTaxCalculator(resource) {
+        return resource.type && (resource.type === TaxCalculators.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: TaxCalculators.TYPE } : { id: id.id, type: TaxCalculators.TYPE };
+    }
+    type() {
+        return TaxCalculators.TYPE;
+    }
+}
+TaxCalculators.TYPE = 'tax_calculators';
+exports.default = TaxCalculators;

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

@@ -0,0 +1,60 @@
+import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsRetrieve, QueryParamsList } from '../query';
+import type { Sku, SkuType } from './skus';
+import type { AvalaraAccount, AvalaraAccountType } from './avalara_accounts';
+import type { TaxjarAccount, TaxjarAccountType } from './taxjar_accounts';
+import type { ManualTaxCalculator, ManualTaxCalculatorType } from './manual_tax_calculators';
+import type { ExternalTaxCalculator, ExternalTaxCalculatorType } from './external_tax_calculators';
+import type { Attachment } from './attachments';
+type TaxCategoryType = 'tax_categories';
+type TaxCategoryRel = ResourceRel & {
+    type: TaxCategoryType;
+};
+type SkuRel = ResourceRel & {
+    type: SkuType;
+};
+type AvalaraAccountRel = ResourceRel & {
+    type: AvalaraAccountType;
+};
+type TaxjarAccountRel = ResourceRel & {
+    type: TaxjarAccountType;
+};
+type ManualTaxCalculatorRel = ResourceRel & {
+    type: ManualTaxCalculatorType;
+};
+type ExternalTaxCalculatorRel = ResourceRel & {
+    type: ExternalTaxCalculatorType;
+};
+interface TaxCategory extends Resource {
+    readonly type: TaxCategoryType;
+    code: string;
+    sku_code?: string;
+    sku?: Sku;
+    tax_calculator?: AvalaraAccount | TaxjarAccount | ManualTaxCalculator | ExternalTaxCalculator;
+    attachments?: Attachment[];
+}
+interface TaxCategoryCreate extends ResourceCreate {
+    code: string;
+    sku_code?: string;
+    sku: SkuRel;
+    tax_calculator: AvalaraAccountRel | TaxjarAccountRel | ManualTaxCalculatorRel | ExternalTaxCalculatorRel;
+}
+interface TaxCategoryUpdate extends ResourceUpdate {
+    code: string;
+    sku_code?: string;
+    sku?: SkuRel;
+}
+declare class TaxCategories extends ApiResource<TaxCategory> {
+    static readonly TYPE: TaxCategoryType;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<TaxCategory>>;
+    create(resource: TaxCategoryCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<TaxCategory>;
+    update(resource: TaxCategoryUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<TaxCategory>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    sku(taxCategoryId: string | TaxCategory, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Sku>;
+    attachments(taxCategoryId: string | TaxCategory, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    isTaxCategory(resource: any): resource is TaxCategory;
+    relationship(id: string | ResourceId | null): TaxCategoryRel;
+    type(): TaxCategoryType;
+}
+export default TaxCategories;
+export type { TaxCategory, TaxCategoryCreate, TaxCategoryUpdate, TaxCategoryType };

package/lib/cjs/resources/tax_categories.js

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

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

@@ -0,0 +1,70 @@
+import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsRetrieve, QueryParamsList } from '../query';
+import type { ManualTaxCalculator, ManualTaxCalculatorType } from './manual_tax_calculators';
+type TaxRuleType = 'tax_rules';
+type TaxRuleRel = ResourceRel & {
+    type: TaxRuleType;
+};
+type ManualTaxCalculatorRel = ResourceRel & {
+    type: ManualTaxCalculatorType;
+};
+interface TaxRule extends Resource {
+    readonly type: TaxRuleType;
+    name: string;
+    tax_rate?: number;
+    country_code_regex?: string;
+    not_country_code_regex?: string;
+    state_code_regex?: string;
+    not_state_code_regex?: string;
+    zip_code_regex?: string;
+    not_zip_code_regex?: string;
+    freight_taxable?: boolean;
+    payment_method_taxable?: boolean;
+    gift_card_taxable?: boolean;
+    adjustment_taxable?: boolean;
+    breakdown?: object;
+    manual_tax_calculator?: ManualTaxCalculator;
+}
+interface TaxRuleCreate extends ResourceCreate {
+    name: string;
+    tax_rate?: number;
+    country_code_regex?: string;
+    not_country_code_regex?: string;
+    state_code_regex?: string;
+    not_state_code_regex?: string;
+    zip_code_regex?: string;
+    not_zip_code_regex?: string;
+    freight_taxable?: boolean;
+    payment_method_taxable?: boolean;
+    gift_card_taxable?: boolean;
+    adjustment_taxable?: boolean;
+    manual_tax_calculator: ManualTaxCalculatorRel;
+}
+interface TaxRuleUpdate extends ResourceUpdate {
+    name: string;
+    tax_rate?: number;
+    country_code_regex?: string;
+    not_country_code_regex?: string;
+    state_code_regex?: string;
+    not_state_code_regex?: string;
+    zip_code_regex?: string;
+    not_zip_code_regex?: string;
+    freight_taxable?: boolean;
+    payment_method_taxable?: boolean;
+    gift_card_taxable?: boolean;
+    adjustment_taxable?: boolean;
+    manual_tax_calculator?: ManualTaxCalculatorRel;
+}
+declare class TaxRules extends ApiResource<TaxRule> {
+    static readonly TYPE: TaxRuleType;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<TaxRule>>;
+    create(resource: TaxRuleCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<TaxRule>;
+    update(resource: TaxRuleUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<TaxRule>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    manual_tax_calculator(taxRuleId: string | TaxRule, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<ManualTaxCalculator>;
+    isTaxRule(resource: any): resource is TaxRule;
+    relationship(id: string | ResourceId | null): TaxRuleRel;
+    type(): TaxRuleType;
+}
+export default TaxRules;
+export type { TaxRule, TaxRuleCreate, TaxRuleUpdate, TaxRuleType };

package/lib/cjs/resources/tax_rules.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resource_1 = require("../resource");
+class TaxRules extends resource_1.ApiResource {
+    // static readonly PATH = 'tax_rules'
+    async list(params, options) {
+        return this.resources.list({ type: TaxRules.TYPE }, params, options);
+    }
+    async create(resource, params, options) {
+        return this.resources.create(Object.assign(Object.assign({}, resource), { type: TaxRules.TYPE }), params, options);
+    }
+    async update(resource, params, options) {
+        return this.resources.update(Object.assign(Object.assign({}, resource), { type: TaxRules.TYPE }), params, options);
+    }
+    async delete(id, options) {
+        await this.resources.delete((typeof id === 'string') ? { id, type: TaxRules.TYPE } : id, options);
+    }
+    async manual_tax_calculator(taxRuleId, params, options) {
+        const _taxRuleId = taxRuleId.id || taxRuleId;
+        return this.resources.fetch({ type: 'manual_tax_calculators' }, `tax_rules/${_taxRuleId}/manual_tax_calculator`, params, options);
+    }
+    isTaxRule(resource) {
+        return resource.type && (resource.type === TaxRules.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: TaxRules.TYPE } : { id: id.id, type: TaxRules.TYPE };
+    }
+    type() {
+        return TaxRules.TYPE;
+    }
+}
+TaxRules.TYPE = 'tax_rules';
+exports.default = TaxRules;

package/lib/cjs/resources/taxjar_accounts.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 { Market } from './markets';
+import type { Attachment } from './attachments';
+import type { TaxCategory, TaxCategoryType } from './tax_categories';
+type TaxjarAccountType = 'taxjar_accounts';
+type TaxjarAccountRel = ResourceRel & {
+    type: TaxjarAccountType;
+};
+type TaxCategoryRel = ResourceRel & {
+    type: TaxCategoryType;
+};
+interface TaxjarAccount extends Resource {
+    readonly type: TaxjarAccountType;
+    name: string;
+    markets?: Market[];
+    attachments?: Attachment[];
+    tax_categories?: TaxCategory[];
+}
+interface TaxjarAccountCreate extends ResourceCreate {
+    name: string;
+    api_key: string;
+    tax_categories?: TaxCategoryRel[];
+}
+interface TaxjarAccountUpdate extends ResourceUpdate {
+    name: string;
+    api_key?: string;
+    tax_categories?: TaxCategoryRel[];
+}
+declare class TaxjarAccounts extends ApiResource<TaxjarAccount> {
+    static readonly TYPE: TaxjarAccountType;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<TaxjarAccount>>;
+    create(resource: TaxjarAccountCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<TaxjarAccount>;
+    update(resource: TaxjarAccountUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<TaxjarAccount>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    markets(taxjarAccountId: string | TaxjarAccount, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Market>>;
+    attachments(taxjarAccountId: string | TaxjarAccount, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    tax_categories(taxjarAccountId: string | TaxjarAccount, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<TaxCategory>>;
+    isTaxjarAccount(resource: any): resource is TaxjarAccount;
+    relationship(id: string | ResourceId | null): TaxjarAccountRel;
+    type(): TaxjarAccountType;
+}
+export default TaxjarAccounts;
+export type { TaxjarAccount, TaxjarAccountCreate, TaxjarAccountUpdate, TaxjarAccountType };

package/lib/cjs/resources/taxjar_accounts.js

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

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

@@ -0,0 +1,32 @@
+import { ApiResource, Resource, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsRetrieve, QueryParamsList } from '../query';
+import type { Order } from './orders';
+type TransactionType = 'transactions';
+type TransactionRel = ResourceRel & {
+    type: TransactionType;
+};
+interface Transaction extends Resource {
+    readonly type: TransactionType;
+    number: string;
+    currency_code: string;
+    amount_cents: number;
+    amount_float: number;
+    formatted_amount: string;
+    succeeded: boolean;
+    message?: string;
+    error_code?: string;
+    error_detail?: string;
+    token?: string;
+    gateway_transaction_id?: string;
+    order?: Order;
+}
+declare class Transactions extends ApiResource<Transaction> {
+    static readonly TYPE: TransactionType;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Transaction>>;
+    order(transactionId: string | Transaction, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Order>;
+    isTransaction(resource: any): resource is Transaction;
+    relationship(id: string | ResourceId | null): TransactionRel;
+    type(): TransactionType;
+}
+export default Transactions;
+export type { Transaction, TransactionType };

package/lib/cjs/resources/transactions.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resource_1 = require("../resource");
+class Transactions extends resource_1.ApiResource {
+    // static readonly PATH = 'transactions'
+    async list(params, options) {
+        return this.resources.list({ type: Transactions.TYPE }, params, options);
+    }
+    async order(transactionId, params, options) {
+        const _transactionId = transactionId.id || transactionId;
+        return this.resources.fetch({ type: 'orders' }, `transactions/${_transactionId}/order`, params, options);
+    }
+    isTransaction(resource) {
+        return resource.type && (resource.type === Transactions.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: Transactions.TYPE } : { id: id.id, type: Transactions.TYPE };
+    }
+    type() {
+        return Transactions.TYPE;
+    }
+}
+Transactions.TYPE = 'transactions';
+exports.default = Transactions;

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

@@ -0,0 +1,38 @@
+import { ApiResource, Resource, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsRetrieve, QueryParamsList } from '../query';
+import type { Order } from './orders';
+import type { Authorization } from './authorizations';
+import type { Event } from './events';
+type VoidType = 'voids';
+type VoidRel = ResourceRel & {
+    type: VoidType;
+};
+interface Void extends Resource {
+    readonly type: VoidType;
+    number: string;
+    currency_code: string;
+    amount_cents: number;
+    amount_float: number;
+    formatted_amount: string;
+    succeeded: boolean;
+    message?: string;
+    error_code?: string;
+    error_detail?: string;
+    token?: string;
+    gateway_transaction_id?: string;
+    order?: Order;
+    reference_authorization?: Authorization;
+    events?: Event[];
+}
+declare class Voids extends ApiResource<Void> {
+    static readonly TYPE: VoidType;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Void>>;
+    order(voidId: string | Void, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Order>;
+    reference_authorization(voidId: string | Void, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Authorization>;
+    events(voidId: string | Void, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
+    isVoid(resource: any): resource is Void;
+    relationship(id: string | ResourceId | null): VoidRel;
+    type(): VoidType;
+}
+export default Voids;
+export type { Void, VoidType };

package/lib/cjs/resources/voids.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resource_1 = require("../resource");
+class Voids extends resource_1.ApiResource {
+    // static readonly PATH = 'voids'
+    async list(params, options) {
+        return this.resources.list({ type: Voids.TYPE }, params, options);
+    }
+    async order(voidId, params, options) {
+        const _voidId = voidId.id || voidId;
+        return this.resources.fetch({ type: 'orders' }, `voids/${_voidId}/order`, params, options);
+    }
+    async reference_authorization(voidId, params, options) {
+        const _voidId = voidId.id || voidId;
+        return this.resources.fetch({ type: 'authorizations' }, `voids/${_voidId}/reference_authorization`, params, options);
+    }
+    async events(voidId, params, options) {
+        const _voidId = voidId.id || voidId;
+        return this.resources.fetch({ type: 'events' }, `voids/${_voidId}/events`, params, options);
+    }
+    isVoid(resource) {
+        return resource.type && (resource.type === Voids.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: Voids.TYPE } : { id: id.id, type: Voids.TYPE };
+    }
+    type() {
+        return Voids.TYPE;
+    }
+}
+Voids.TYPE = 'voids';
+exports.default = Voids;