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

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

@@ -0,0 +1,46 @@
+import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsRetrieve, QueryParamsList } from '../query';
+import type { CouponCodesPromotionRule, CouponCodesPromotionRuleType } from './coupon_codes_promotion_rules';
+type CouponType = 'coupons';
+type CouponRel = ResourceRel & {
+    type: CouponType;
+};
+type CouponCodesPromotionRuleRel = ResourceRel & {
+    type: CouponCodesPromotionRuleType;
+};
+interface Coupon extends Resource {
+    readonly type: CouponType;
+    code: string;
+    customer_single_use?: boolean;
+    usage_limit: number;
+    usage_count?: number;
+    recipient_email?: string;
+    promotion_rule?: CouponCodesPromotionRule;
+}
+interface CouponCreate extends ResourceCreate {
+    code: string;
+    customer_single_use?: boolean;
+    usage_limit: number;
+    recipient_email?: string;
+    promotion_rule: CouponCodesPromotionRuleRel;
+}
+interface CouponUpdate extends ResourceUpdate {
+    code: string;
+    customer_single_use?: boolean;
+    usage_limit: number;
+    recipient_email?: string;
+    promotion_rule?: CouponCodesPromotionRuleRel;
+}
+declare class Coupons extends ApiResource<Coupon> {
+    static readonly TYPE: CouponType;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Coupon>>;
+    create(resource: CouponCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Coupon>;
+    update(resource: CouponUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Coupon>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    promotion_rule(couponId: string | Coupon, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<CouponCodesPromotionRule>;
+    isCoupon(resource: any): resource is Coupon;
+    relationship(id: string | ResourceId | null): CouponRel;
+    type(): CouponType;
+}
+export default Coupons;
+export type { Coupon, CouponCreate, CouponUpdate, CouponType };

package/lib/cjs/resources/coupons.js

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

package/lib/cjs/resources/customer_addresses.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 { Customer, CustomerType } from './customers';
+import type { Address, AddressType } from './addresses';
+import type { Event } from './events';
+type CustomerAddressType = 'customer_addresses';
+type CustomerAddressRel = ResourceRel & {
+    type: CustomerAddressType;
+};
+type CustomerRel = ResourceRel & {
+    type: CustomerType;
+};
+type AddressRel = ResourceRel & {
+    type: AddressType;
+};
+interface CustomerAddress extends Resource {
+    readonly type: CustomerAddressType;
+    name?: string;
+    customer?: Customer;
+    address?: Address;
+    events?: Event[];
+}
+interface CustomerAddressCreate extends ResourceCreate {
+    customer: CustomerRel;
+    address: AddressRel;
+}
+interface CustomerAddressUpdate extends ResourceUpdate {
+    customer?: CustomerRel;
+    address?: AddressRel;
+}
+declare class CustomerAddresses extends ApiResource<CustomerAddress> {
+    static readonly TYPE: CustomerAddressType;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<CustomerAddress>>;
+    create(resource: CustomerAddressCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<CustomerAddress>;
+    update(resource: CustomerAddressUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<CustomerAddress>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    customer(customerAddressId: string | CustomerAddress, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Customer>;
+    address(customerAddressId: string | CustomerAddress, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Address>;
+    events(customerAddressId: string | CustomerAddress, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
+    isCustomerAddress(resource: any): resource is CustomerAddress;
+    relationship(id: string | ResourceId | null): CustomerAddressRel;
+    type(): CustomerAddressType;
+}
+export default CustomerAddresses;
+export type { CustomerAddress, CustomerAddressCreate, CustomerAddressUpdate, CustomerAddressType };

package/lib/cjs/resources/customer_addresses.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resource_1 = require("../resource");
+class CustomerAddresses extends resource_1.ApiResource {
+    // static readonly PATH = 'customer_addresses'
+    async list(params, options) {
+        return this.resources.list({ type: CustomerAddresses.TYPE }, params, options);
+    }
+    async create(resource, params, options) {
+        return this.resources.create(Object.assign(Object.assign({}, resource), { type: CustomerAddresses.TYPE }), params, options);
+    }
+    async update(resource, params, options) {
+        return this.resources.update(Object.assign(Object.assign({}, resource), { type: CustomerAddresses.TYPE }), params, options);
+    }
+    async delete(id, options) {
+        await this.resources.delete((typeof id === 'string') ? { id, type: CustomerAddresses.TYPE } : id, options);
+    }
+    async customer(customerAddressId, params, options) {
+        const _customerAddressId = customerAddressId.id || customerAddressId;
+        return this.resources.fetch({ type: 'customers' }, `customer_addresses/${_customerAddressId}/customer`, params, options);
+    }
+    async address(customerAddressId, params, options) {
+        const _customerAddressId = customerAddressId.id || customerAddressId;
+        return this.resources.fetch({ type: 'addresses' }, `customer_addresses/${_customerAddressId}/address`, params, options);
+    }
+    async events(customerAddressId, params, options) {
+        const _customerAddressId = customerAddressId.id || customerAddressId;
+        return this.resources.fetch({ type: 'events' }, `customer_addresses/${_customerAddressId}/events`, params, options);
+    }
+    isCustomerAddress(resource) {
+        return resource.type && (resource.type === CustomerAddresses.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: CustomerAddresses.TYPE } : { id: id.id, type: CustomerAddresses.TYPE };
+    }
+    type() {
+        return CustomerAddresses.TYPE;
+    }
+}
+CustomerAddresses.TYPE = 'customer_addresses';
+exports.default = CustomerAddresses;

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

@@ -0,0 +1,37 @@
+import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsRetrieve, QueryParamsList } from '../query';
+import type { Customer } from './customers';
+import type { Market } from './markets';
+import type { Attachment } from './attachments';
+type CustomerGroupType = 'customer_groups';
+type CustomerGroupRel = ResourceRel & {
+    type: CustomerGroupType;
+};
+interface CustomerGroup extends Resource {
+    readonly type: CustomerGroupType;
+    name: string;
+    customers?: Customer[];
+    markets?: Market[];
+    attachments?: Attachment[];
+}
+interface CustomerGroupCreate extends ResourceCreate {
+    name: string;
+}
+interface CustomerGroupUpdate extends ResourceUpdate {
+    name: string;
+}
+declare class CustomerGroups extends ApiResource<CustomerGroup> {
+    static readonly TYPE: CustomerGroupType;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<CustomerGroup>>;
+    create(resource: CustomerGroupCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<CustomerGroup>;
+    update(resource: CustomerGroupUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<CustomerGroup>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    customers(customerGroupId: string | CustomerGroup, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Customer>>;
+    markets(customerGroupId: string | CustomerGroup, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Market>>;
+    attachments(customerGroupId: string | CustomerGroup, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    isCustomerGroup(resource: any): resource is CustomerGroup;
+    relationship(id: string | ResourceId | null): CustomerGroupRel;
+    type(): CustomerGroupType;
+}
+export default CustomerGroups;
+export type { CustomerGroup, CustomerGroupCreate, CustomerGroupUpdate, CustomerGroupType };

package/lib/cjs/resources/customer_groups.js

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

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

@@ -0,0 +1,37 @@
+import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsRetrieve, QueryParamsList } from '../query';
+import type { Customer } from './customers';
+import type { Event } from './events';
+type CustomerPasswordResetType = 'customer_password_resets';
+type CustomerPasswordResetRel = ResourceRel & {
+    type: CustomerPasswordResetType;
+};
+interface CustomerPasswordReset extends Resource {
+    readonly type: CustomerPasswordResetType;
+    customer_email: string;
+    reset_password_token?: string;
+    reset_password_at?: string;
+    customer?: Customer;
+    events?: Event[];
+}
+interface CustomerPasswordResetCreate extends ResourceCreate {
+    customer_email: string;
+}
+interface CustomerPasswordResetUpdate extends ResourceUpdate {
+    customer_password?: string;
+    _reset_password_token?: string;
+}
+declare class CustomerPasswordResets extends ApiResource<CustomerPasswordReset> {
+    static readonly TYPE: CustomerPasswordResetType;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<CustomerPasswordReset>>;
+    create(resource: CustomerPasswordResetCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<CustomerPasswordReset>;
+    update(resource: CustomerPasswordResetUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<CustomerPasswordReset>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    customer(customerPasswordResetId: string | CustomerPasswordReset, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Customer>;
+    events(customerPasswordResetId: string | CustomerPasswordReset, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
+    isCustomerPasswordReset(resource: any): resource is CustomerPasswordReset;
+    relationship(id: string | ResourceId | null): CustomerPasswordResetRel;
+    type(): CustomerPasswordResetType;
+}
+export default CustomerPasswordResets;
+export type { CustomerPasswordReset, CustomerPasswordResetCreate, CustomerPasswordResetUpdate, CustomerPasswordResetType };

package/lib/cjs/resources/customer_password_resets.js

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

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

@@ -0,0 +1,79 @@
+import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsRetrieve, QueryParamsList } from '../query';
+import type { Customer, CustomerType } from './customers';
+import type { AdyenPayment, AdyenPaymentType } from './adyen_payments';
+import type { AxervePayment, AxervePaymentType } from './axerve_payments';
+import type { BraintreePayment, BraintreePaymentType } from './braintree_payments';
+import type { CheckoutComPayment, CheckoutComPaymentType } from './checkout_com_payments';
+import type { ExternalPayment, ExternalPaymentType } from './external_payments';
+import type { KlarnaPayment, KlarnaPaymentType } from './klarna_payments';
+import type { PaypalPayment, PaypalPaymentType } from './paypal_payments';
+import type { SatispayPayment, SatispayPaymentType } from './satispay_payments';
+import type { StripePayment, StripePaymentType } from './stripe_payments';
+import type { WireTransfer, WireTransferType } from './wire_transfers';
+type CustomerPaymentSourceType = 'customer_payment_sources';
+type CustomerPaymentSourceRel = ResourceRel & {
+    type: CustomerPaymentSourceType;
+};
+type CustomerRel = ResourceRel & {
+    type: CustomerType;
+};
+type AdyenPaymentRel = ResourceRel & {
+    type: AdyenPaymentType;
+};
+type AxervePaymentRel = ResourceRel & {
+    type: AxervePaymentType;
+};
+type BraintreePaymentRel = ResourceRel & {
+    type: BraintreePaymentType;
+};
+type CheckoutComPaymentRel = ResourceRel & {
+    type: CheckoutComPaymentType;
+};
+type ExternalPaymentRel = ResourceRel & {
+    type: ExternalPaymentType;
+};
+type KlarnaPaymentRel = ResourceRel & {
+    type: KlarnaPaymentType;
+};
+type PaypalPaymentRel = ResourceRel & {
+    type: PaypalPaymentType;
+};
+type SatispayPaymentRel = ResourceRel & {
+    type: SatispayPaymentType;
+};
+type StripePaymentRel = ResourceRel & {
+    type: StripePaymentType;
+};
+type WireTransferRel = ResourceRel & {
+    type: WireTransferType;
+};
+interface CustomerPaymentSource extends Resource {
+    readonly type: CustomerPaymentSourceType;
+    name?: string;
+    customer_token?: string;
+    payment_source_token?: string;
+    customer?: Customer;
+    payment_source?: AdyenPayment | AxervePayment | BraintreePayment | CheckoutComPayment | ExternalPayment | KlarnaPayment | PaypalPayment | SatispayPayment | StripePayment | WireTransfer;
+}
+interface CustomerPaymentSourceCreate extends ResourceCreate {
+    customer: CustomerRel;
+    payment_source: AdyenPaymentRel | AxervePaymentRel | BraintreePaymentRel | CheckoutComPaymentRel | ExternalPaymentRel | KlarnaPaymentRel | PaypalPaymentRel | SatispayPaymentRel | StripePaymentRel | WireTransferRel;
+}
+interface CustomerPaymentSourceUpdate extends ResourceUpdate {
+    customer?: CustomerRel;
+    payment_source?: AdyenPaymentRel | AxervePaymentRel | BraintreePaymentRel | CheckoutComPaymentRel | ExternalPaymentRel | KlarnaPaymentRel | PaypalPaymentRel | SatispayPaymentRel | StripePaymentRel | WireTransferRel;
+}
+declare class CustomerPaymentSources extends ApiResource<CustomerPaymentSource> {
+    static readonly TYPE: CustomerPaymentSourceType;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<CustomerPaymentSource>>;
+    create(resource: CustomerPaymentSourceCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<CustomerPaymentSource>;
+    update(resource: CustomerPaymentSourceUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<CustomerPaymentSource>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    customer(customerPaymentSourceId: string | CustomerPaymentSource, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Customer>;
+    isCustomerPaymentSource(resource: any): resource is CustomerPaymentSource;
+    relationship(id: string | ResourceId | null): CustomerPaymentSourceRel;
+    type(): CustomerPaymentSourceType;
+}
+export default CustomerPaymentSources;
+export type { CustomerPaymentSource, CustomerPaymentSourceCreate, CustomerPaymentSourceUpdate, CustomerPaymentSourceType };

package/lib/cjs/resources/customer_payment_sources.js

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

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

@@ -0,0 +1,32 @@
+import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsRetrieve, QueryParamsList } from '../query';
+import type { Customer } from './customers';
+import type { Event } from './events';
+type CustomerSubscriptionType = 'customer_subscriptions';
+type CustomerSubscriptionRel = ResourceRel & {
+    type: CustomerSubscriptionType;
+};
+interface CustomerSubscription extends Resource {
+    readonly type: CustomerSubscriptionType;
+    customer_email: string;
+    customer?: Customer;
+    events?: Event[];
+}
+interface CustomerSubscriptionCreate extends ResourceCreate {
+    customer_email: string;
+}
+type CustomerSubscriptionUpdate = ResourceUpdate;
+declare class CustomerSubscriptions extends ApiResource<CustomerSubscription> {
+    static readonly TYPE: CustomerSubscriptionType;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<CustomerSubscription>>;
+    create(resource: CustomerSubscriptionCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<CustomerSubscription>;
+    update(resource: CustomerSubscriptionUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<CustomerSubscription>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    customer(customerSubscriptionId: string | CustomerSubscription, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Customer>;
+    events(customerSubscriptionId: string | CustomerSubscription, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
+    isCustomerSubscription(resource: any): resource is CustomerSubscription;
+    relationship(id: string | ResourceId | null): CustomerSubscriptionRel;
+    type(): CustomerSubscriptionType;
+}
+export default CustomerSubscriptions;
+export type { CustomerSubscription, CustomerSubscriptionCreate, CustomerSubscriptionUpdate, CustomerSubscriptionType };

package/lib/cjs/resources/customer_subscriptions.js

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

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

@@ -0,0 +1,67 @@
+import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsRetrieve, QueryParamsList } from '../query';
+import type { CustomerGroup, CustomerGroupType } from './customer_groups';
+import type { CustomerAddress } from './customer_addresses';
+import type { CustomerPaymentSource } from './customer_payment_sources';
+import type { CustomerSubscription } from './customer_subscriptions';
+import type { Order } from './orders';
+import type { OrderSubscription } from './order_subscriptions';
+import type { Return } from './returns';
+import type { SkuList } from './sku_lists';
+import type { Attachment } from './attachments';
+import type { Event } from './events';
+type CustomerType = 'customers';
+type CustomerRel = ResourceRel & {
+    type: CustomerType;
+};
+type CustomerGroupRel = ResourceRel & {
+    type: CustomerGroupType;
+};
+interface Customer extends Resource {
+    readonly type: CustomerType;
+    email: string;
+    status?: 'prospect' | 'acquired' | 'repeat';
+    has_password?: boolean;
+    customer_group?: CustomerGroup;
+    customer_addresses?: CustomerAddress[];
+    customer_payment_sources?: CustomerPaymentSource[];
+    customer_subscriptions?: CustomerSubscription[];
+    orders?: Order[];
+    order_subscriptions?: OrderSubscription[];
+    returns?: Return[];
+    sku_lists?: SkuList[];
+    attachments?: Attachment[];
+    events?: Event[];
+}
+interface CustomerCreate extends ResourceCreate {
+    email: string;
+    password?: string;
+    customer_group?: CustomerGroupRel;
+}
+interface CustomerUpdate extends ResourceUpdate {
+    email: string;
+    password?: string;
+    customer_group?: CustomerGroupRel;
+}
+declare class Customers extends ApiResource<Customer> {
+    static readonly TYPE: CustomerType;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Customer>>;
+    create(resource: CustomerCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Customer>;
+    update(resource: CustomerUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Customer>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    customer_group(customerId: string | Customer, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<CustomerGroup>;
+    customer_addresses(customerId: string | Customer, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<CustomerAddress>>;
+    customer_payment_sources(customerId: string | Customer, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<CustomerPaymentSource>>;
+    customer_subscriptions(customerId: string | Customer, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<CustomerSubscription>>;
+    orders(customerId: string | Customer, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Order>>;
+    order_subscriptions(customerId: string | Customer, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<OrderSubscription>>;
+    returns(customerId: string | Customer, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Return>>;
+    sku_lists(customerId: string | Customer, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<SkuList>>;
+    attachments(customerId: string | Customer, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Attachment>>;
+    events(customerId: string | Customer, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Event>>;
+    isCustomer(resource: any): resource is Customer;
+    relationship(id: string | ResourceId | null): CustomerRel;
+    type(): CustomerType;
+}
+export default Customers;
+export type { Customer, CustomerCreate, CustomerUpdate, CustomerType };

package/lib/cjs/resources/customers.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resource_1 = require("../resource");
+class Customers extends resource_1.ApiResource {
+    // static readonly PATH = 'customers'
+    async list(params, options) {
+        return this.resources.list({ type: Customers.TYPE }, params, options);
+    }
+    async create(resource, params, options) {
+        return this.resources.create(Object.assign(Object.assign({}, resource), { type: Customers.TYPE }), params, options);
+    }
+    async update(resource, params, options) {
+        return this.resources.update(Object.assign(Object.assign({}, resource), { type: Customers.TYPE }), params, options);
+    }
+    async delete(id, options) {
+        await this.resources.delete((typeof id === 'string') ? { id, type: Customers.TYPE } : id, options);
+    }
+    async customer_group(customerId, params, options) {
+        const _customerId = customerId.id || customerId;
+        return this.resources.fetch({ type: 'customer_groups' }, `customers/${_customerId}/customer_group`, params, options);
+    }
+    async customer_addresses(customerId, params, options) {
+        const _customerId = customerId.id || customerId;
+        return this.resources.fetch({ type: 'customer_addresses' }, `customers/${_customerId}/customer_addresses`, params, options);
+    }
+    async customer_payment_sources(customerId, params, options) {
+        const _customerId = customerId.id || customerId;
+        return this.resources.fetch({ type: 'customer_payment_sources' }, `customers/${_customerId}/customer_payment_sources`, params, options);
+    }
+    async customer_subscriptions(customerId, params, options) {
+        const _customerId = customerId.id || customerId;
+        return this.resources.fetch({ type: 'customer_subscriptions' }, `customers/${_customerId}/customer_subscriptions`, params, options);
+    }
+    async orders(customerId, params, options) {
+        const _customerId = customerId.id || customerId;
+        return this.resources.fetch({ type: 'orders' }, `customers/${_customerId}/orders`, params, options);
+    }
+    async order_subscriptions(customerId, params, options) {
+        const _customerId = customerId.id || customerId;
+        return this.resources.fetch({ type: 'order_subscriptions' }, `customers/${_customerId}/order_subscriptions`, params, options);
+    }
+    async returns(customerId, params, options) {
+        const _customerId = customerId.id || customerId;
+        return this.resources.fetch({ type: 'returns' }, `customers/${_customerId}/returns`, params, options);
+    }
+    async sku_lists(customerId, params, options) {
+        const _customerId = customerId.id || customerId;
+        return this.resources.fetch({ type: 'sku_lists' }, `customers/${_customerId}/sku_lists`, params, options);
+    }
+    async attachments(customerId, params, options) {
+        const _customerId = customerId.id || customerId;
+        return this.resources.fetch({ type: 'attachments' }, `customers/${_customerId}/attachments`, params, options);
+    }
+    async events(customerId, params, options) {
+        const _customerId = customerId.id || customerId;
+        return this.resources.fetch({ type: 'events' }, `customers/${_customerId}/events`, params, options);
+    }
+    isCustomer(resource) {
+        return resource.type && (resource.type === Customers.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: Customers.TYPE } : { id: id.id, type: Customers.TYPE };
+    }
+    type() {
+        return Customers.TYPE;
+    }
+}
+Customers.TYPE = 'customers';
+exports.default = Customers;