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

package/lib/esm/query.js

@@ -0,0 +1,45 @@
+import Debug from './debug';
+const debug = Debug('query');
+const isParamsList = (params) => {
+    return params && (params.filters || params.pageNumber || params.pageSize || params.sort);
+};
+const generateQueryStringParams = (params, res) => {
+    debug('generate query string params: %O, %O', params, res);
+    const qp = {};
+    if (!params)
+        return qp;
+    // Include
+    if (params.include)
+        qp.include = params.include.join(',');
+    // Fields
+    if (params.fields) {
+        if (Array.isArray(params.fields))
+            params.fields = { [res.type || res]: params.fields };
+        Object.entries(params.fields).forEach(([p, v]) => {
+            qp[`fields[${p}]`] = v.join(',');
+        });
+    }
+    if (isParamsList(params)) {
+        // Sort
+        if (params.sort) {
+            if (Array.isArray(params.sort))
+                qp.sort = params.sort.join(',');
+            else
+                qp.sort = Object.entries(params.sort).map(([k, v]) => `${v === 'desc' ? '-' : ''}${k}`).join(',');
+        }
+        // Page
+        if (params.pageNumber)
+            qp['page[number]'] = String(params.pageNumber);
+        if (params.pageSize)
+            qp['page[size]'] = String(params.pageSize);
+        // Filters
+        if (params.filters) {
+            Object.entries(params.filters).forEach(([p, v]) => {
+                qp[`filter[q][${p}]`] = String(v);
+            });
+        }
+    }
+    debug('query string params: %O', qp);
+    return qp;
+};
+export { generateQueryStringParams, isParamsList };

package/lib/esm/resource.d.ts

@@ -0,0 +1,87 @@
+import type { ApiClientInitConfig } from './client';
+import type { QueryParamsRetrieve, QueryParamsList, QueryFilter } from './query';
+import type { ResourceTypeLock } from './api';
+import type { InterceptorManager } from './interceptor';
+import { QueryParams } from '.';
+type ResourceNull = {
+    id: null;
+} & ResourceType;
+type ResourceRel = ResourceId | ResourceNull;
+type Metadata = {
+    [key: string]: any;
+};
+interface ResourceType {
+    readonly type: ResourceTypeLock;
+}
+interface ResourceId extends ResourceType {
+    readonly id: string;
+}
+interface ResourceBase {
+    reference?: string;
+    reference_origin?: string;
+    metadata?: Metadata;
+}
+interface Resource extends ResourceBase, ResourceId {
+    readonly created_at: string;
+    readonly updated_at: string;
+}
+interface ResourceCreate extends ResourceBase {
+}
+interface ResourceUpdate extends ResourceBase {
+    readonly id: string;
+}
+type ListMeta = {
+    readonly pageCount: number;
+    readonly recordCount: number;
+    readonly currentPage: number;
+    readonly recordsPerPage: number;
+};
+declare class ListResponse<R> extends Array<R> {
+    readonly meta: ListMeta;
+    constructor(meta: ListMeta, data: R[]);
+    first(): R | undefined;
+    last(): R | undefined;
+    get(index: number): R | undefined;
+    hasNextPage(): boolean;
+    hasPrevPage(): boolean;
+    getRecordCount(): number;
+    getPageCount(): number;
+    get recordCount(): number;
+    get pageCount(): number;
+}
+export type { Metadata, ResourceType, ResourceId, Resource, ResourceCreate, ResourceUpdate, ListResponse, ResourceRel };
+type ResourceAdapterConfig = {};
+type ResourcesInitConfig = ResourceAdapterConfig & ApiClientInitConfig;
+type ResourcesConfig = Partial<ResourcesInitConfig>;
+declare class ResourceAdapter {
+    #private;
+    constructor(config: ResourcesInitConfig);
+    get interceptors(): InterceptorManager;
+    private localConfig;
+    config(config: ResourcesConfig): void;
+    singleton<R extends Resource>(resource: ResourceType, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<R>;
+    retrieve<R extends Resource>(resource: ResourceId, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<R>;
+    list<R extends Resource>(resource: ResourceType, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<R>>;
+    create<C extends ResourceCreate, R extends Resource>(resource: C & ResourceType, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<R>;
+    update<U extends ResourceUpdate, R extends Resource>(resource: U & ResourceId, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<R>;
+    delete(resource: ResourceId, options?: ResourcesConfig): Promise<void>;
+    fetch<R extends Resource>(resource: string | ResourceType, path: string, params?: QueryParams, options?: ResourcesConfig): Promise<R | ListResponse<R>>;
+}
+declare abstract class ApiResourceBase<R extends Resource> {
+    static readonly TYPE: ResourceTypeLock;
+    protected readonly resources: ResourceAdapter;
+    constructor(adapter: ResourceAdapter);
+    abstract relationship(id: string | ResourceId | null): ResourceRel;
+    abstract type(): ResourceTypeLock;
+    update(resource: ResourceUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<R>;
+    count(filter?: QueryFilter | QueryParamsList, options?: ResourcesConfig): Promise<number>;
+}
+declare abstract class ApiResource<R extends Resource> extends ApiResourceBase<R> {
+    retrieve(id: string | ResourceId, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<R>;
+    list(params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<R>>;
+}
+declare abstract class ApiSingleton<R extends Resource> extends ApiResourceBase<R> {
+    retrieve(params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<R>;
+}
+export default ResourceAdapter;
+export { ApiResource, ApiSingleton, ResourcesConfig, ResourcesInitConfig };

package/lib/esm/resource.js

@@ -0,0 +1,163 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ResourceAdapter_client, _ResourceAdapter_config;
+import ApiClient from './client';
+import { denormalize, normalize } from './jsonapi';
+import { generateQueryStringParams, isParamsList } from './query';
+import config from './config';
+import Debug from './debug';
+const debug = Debug('resource');
+class ListResponse extends Array {
+    constructor(meta, data) {
+        super(...(data || []));
+        this.meta = meta;
+    }
+    first() { return this.length ? this[0] : undefined; }
+    last() { return this.length ? this[this.length - 1] : undefined; }
+    get(index) { return (this.length && (index >= 0)) ? this[index] : undefined; }
+    hasNextPage() { return (this.meta.currentPage < this.meta.pageCount); }
+    hasPrevPage() { return (this.meta.currentPage > 1); }
+    getRecordCount() { return this.meta.recordCount; }
+    getPageCount() { return this.meta.pageCount; }
+    get recordCount() { return this.meta.recordCount; }
+    get pageCount() { return this.meta.pageCount; }
+}
+class ResourceAdapter {
+    constructor(config) {
+        _ResourceAdapter_client.set(this, void 0);
+        _ResourceAdapter_config.set(this, {});
+        __classPrivateFieldSet(this, _ResourceAdapter_client, ApiClient.create(config), "f");
+        this.localConfig(config);
+    }
+    get interceptors() { return __classPrivateFieldGet(this, _ResourceAdapter_client, "f").interceptors; }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    localConfig(config) {
+        // if (typeof config.xyz !== 'undefined') this.#config.xyz = config.xyz
+    }
+    config(config) {
+        debug('config %o', config);
+        // ResourceAdapter config
+        this.localConfig(config);
+        // Client config
+        __classPrivateFieldGet(this, _ResourceAdapter_client, "f").config(config);
+    }
+    async singleton(resource, params, options) {
+        debug('singleton: %o, %O, %O', resource, params || {}, options || {});
+        const queryParams = generateQueryStringParams(params, resource);
+        if (options === null || options === void 0 ? void 0 : options.params)
+            Object.assign(queryParams, options === null || options === void 0 ? void 0 : options.params);
+        const res = await __classPrivateFieldGet(this, _ResourceAdapter_client, "f").request('get', `${resource.type}`, undefined, { ...options, params: queryParams });
+        const r = denormalize(res);
+        return r;
+    }
+    async retrieve(resource, params, options) {
+        debug('retrieve: %o, %O, %O', resource, params || {}, options || {});
+        const queryParams = generateQueryStringParams(params, resource);
+        if (options === null || options === void 0 ? void 0 : options.params)
+            Object.assign(queryParams, options === null || options === void 0 ? void 0 : options.params);
+        const res = await __classPrivateFieldGet(this, _ResourceAdapter_client, "f").request('get', `${resource.type}/${resource.id}`, undefined, { ...options, params: queryParams });
+        const r = denormalize(res);
+        return r;
+    }
+    async list(resource, params, options) {
+        var _a, _b;
+        debug('list: %o, %O, %O', resource, params || {}, options || {});
+        const queryParams = generateQueryStringParams(params, resource);
+        if (options === null || options === void 0 ? void 0 : options.params)
+            Object.assign(queryParams, options === null || options === void 0 ? void 0 : options.params);
+        const res = await __classPrivateFieldGet(this, _ResourceAdapter_client, "f").request('get', `${resource.type}`, undefined, { ...options, params: queryParams });
+        const r = denormalize(res);
+        const meta = {
+            pageCount: Number((_a = res.meta) === null || _a === void 0 ? void 0 : _a.page_count),
+            recordCount: Number((_b = res.meta) === null || _b === void 0 ? void 0 : _b.record_count),
+            currentPage: (params === null || params === void 0 ? void 0 : params.pageNumber) || config.default.pageNumber,
+            recordsPerPage: (params === null || params === void 0 ? void 0 : params.pageSize) || config.default.pageSize
+        };
+        return new ListResponse(meta, r);
+    }
+    async create(resource, params, options) {
+        debug('create: %o, %O, %O', resource, params || {}, options || {});
+        const queryParams = generateQueryStringParams(params, resource);
+        if (options === null || options === void 0 ? void 0 : options.params)
+            Object.assign(queryParams, options === null || options === void 0 ? void 0 : options.params);
+        const data = normalize(resource);
+        const res = await __classPrivateFieldGet(this, _ResourceAdapter_client, "f").request('post', resource.type, data, { ...options, params: queryParams });
+        const r = denormalize(res);
+        return r;
+    }
+    async update(resource, params, options) {
+        debug('update: %o, %O, %O', resource, params || {}, options || {});
+        const queryParams = generateQueryStringParams(params, resource);
+        if (options === null || options === void 0 ? void 0 : options.params)
+            Object.assign(queryParams, options === null || options === void 0 ? void 0 : options.params);
+        const data = normalize(resource);
+        const res = await __classPrivateFieldGet(this, _ResourceAdapter_client, "f").request('patch', `${resource.type}/${resource.id}`, data, { ...options, params: queryParams });
+        const r = denormalize(res);
+        return r;
+    }
+    async delete(resource, options) {
+        debug('delete: %o, %O', resource, options || {});
+        await __classPrivateFieldGet(this, _ResourceAdapter_client, "f").request('delete', `${resource.type}/${resource.id}`, undefined, options);
+    }
+    async fetch(resource, path, params, options) {
+        var _a, _b;
+        debug('fetch: %o, %O, %O', path, params || {}, options || {});
+        const queryParams = generateQueryStringParams(params, resource);
+        if (options === null || options === void 0 ? void 0 : options.params)
+            Object.assign(queryParams, options === null || options === void 0 ? void 0 : options.params);
+        const res = await __classPrivateFieldGet(this, _ResourceAdapter_client, "f").request('get', path, undefined, { ...options, params: queryParams });
+        const r = denormalize(res);
+        if (Array.isArray(r)) {
+            const p = params;
+            const meta = {
+                pageCount: Number((_a = res.meta) === null || _a === void 0 ? void 0 : _a.page_count),
+                recordCount: Number((_b = res.meta) === null || _b === void 0 ? void 0 : _b.record_count),
+                currentPage: (p === null || p === void 0 ? void 0 : p.pageNumber) || config.default.pageNumber,
+                recordsPerPage: (p === null || p === void 0 ? void 0 : p.pageSize) || config.default.pageSize
+            };
+            return new ListResponse(meta, r);
+        }
+        else
+            return r;
+    }
+}
+_ResourceAdapter_client = new WeakMap(), _ResourceAdapter_config = new WeakMap();
+class ApiResourceBase {
+    constructor(adapter) {
+        debug('new resource instance: %s', this.type());
+        this.resources = adapter;
+    }
+    // reference, reference_origin and metadata attributes are always updatable
+    async update(resource, params, options) {
+        return this.resources.update({ ...resource, type: this.type() }, params, options);
+    }
+    async count(filter, options) {
+        const params = { filters: isParamsList(filter) ? filter.filters : filter, pageNumber: 1, pageSize: 1 };
+        const response = await this.resources.list({ type: this.type() }, params, options);
+        return Promise.resolve(response.meta.recordCount);
+    }
+}
+class ApiResource extends ApiResourceBase {
+    async retrieve(id, params, options) {
+        return this.resources.retrieve((typeof id === 'string') ? { type: this.type(), id } : id, params, options);
+    }
+    async list(params, options) {
+        return this.resources.list({ type: this.type() }, params, options);
+    }
+}
+class ApiSingleton extends ApiResourceBase {
+    async retrieve(params, options) {
+        return this.resources.singleton({ type: this.type() }, params, options);
+    }
+}
+export default ResourceAdapter;
+export { ApiResource, ApiSingleton };

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

@@ -0,0 +1,88 @@
+import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel } from '../resource';
+import type { QueryParamsRetrieve } from '../query';
+import type { Geocoder, GeocoderType } from './geocoders';
+type AddressType = 'addresses';
+type AddressRel = ResourceRel & {
+    type: AddressType;
+};
+type GeocoderRel = ResourceRel & {
+    type: GeocoderType;
+};
+interface Address extends Resource {
+    readonly type: AddressType;
+    business?: boolean | null;
+    first_name?: string | null;
+    last_name?: string | null;
+    company?: string | null;
+    full_name?: string | null;
+    line_1: string;
+    line_2?: string | null;
+    city: string;
+    zip_code?: string | null;
+    state_code: string;
+    country_code: string;
+    phone: string;
+    full_address?: string | null;
+    name?: string | null;
+    email?: string | null;
+    notes?: string | null;
+    lat?: number | null;
+    lng?: number | null;
+    is_localized?: boolean | null;
+    is_geocoded?: boolean | null;
+    provider_name?: string | null;
+    map_url?: string | null;
+    static_map_url?: string | null;
+    billing_info?: string | null;
+    geocoder?: Geocoder | null;
+}
+interface AddressCreate extends ResourceCreate {
+    business?: boolean | null;
+    first_name?: string | null;
+    last_name?: string | null;
+    company?: string | null;
+    line_1: string;
+    line_2?: string | null;
+    city: string;
+    zip_code?: string | null;
+    state_code: string;
+    country_code: string;
+    phone: string;
+    email?: string | null;
+    notes?: string | null;
+    lat?: number | null;
+    lng?: number | null;
+    billing_info?: string | null;
+    geocoder?: GeocoderRel | null;
+}
+interface AddressUpdate extends ResourceUpdate {
+    business?: boolean | null;
+    first_name?: string | null;
+    last_name?: string | null;
+    company?: string | null;
+    line_1?: string | null;
+    line_2?: string | null;
+    city?: string | null;
+    zip_code?: string | null;
+    state_code?: string | null;
+    country_code?: string | null;
+    phone?: string | null;
+    email?: string | null;
+    notes?: string | null;
+    lat?: number | null;
+    lng?: number | null;
+    billing_info?: string | null;
+    geocoder?: GeocoderRel | null;
+}
+declare class Addresses extends ApiResource<Address> {
+    static readonly TYPE: AddressType;
+    create(resource: AddressCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Address>;
+    update(resource: AddressUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Address>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    geocoder(addressId: string | Address, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Geocoder>;
+    isAddress(resource: any): resource is Address;
+    relationship(id: string | ResourceId | null): AddressRel;
+    type(): AddressType;
+}
+export default Addresses;
+export type { Address, AddressCreate, AddressUpdate, AddressType };

package/lib/esm/resources/addresses.js

@@ -0,0 +1,27 @@
+import { ApiResource } from '../resource';
+class Addresses extends ApiResource {
+    async create(resource, params, options) {
+        return this.resources.create({ ...resource, type: Addresses.TYPE }, params, options);
+    }
+    async update(resource, params, options) {
+        return this.resources.update({ ...resource, type: Addresses.TYPE }, params, options);
+    }
+    async delete(id, options) {
+        await this.resources.delete((typeof id === 'string') ? { id, type: Addresses.TYPE } : id, options);
+    }
+    async geocoder(addressId, params, options) {
+        const _addressId = addressId.id || addressId;
+        return this.resources.fetch({ type: 'geocoders' }, `addresses/${_addressId}/geocoder`, params, options);
+    }
+    isAddress(resource) {
+        return resource.type && (resource.type === Addresses.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: Addresses.TYPE } : { id: id.id, type: Addresses.TYPE };
+    }
+    type() {
+        return Addresses.TYPE;
+    }
+}
+Addresses.TYPE = 'addresses';
+export default Addresses;

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

@@ -0,0 +1,35 @@
+import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel } from '../resource';
+import type { QueryParamsRetrieve } from '../query';
+type AdjustmentType = 'adjustments';
+type AdjustmentRel = ResourceRel & {
+    type: AdjustmentType;
+};
+interface Adjustment extends Resource {
+    readonly type: AdjustmentType;
+    name: string;
+    currency_code: string;
+    amount_cents: number;
+    amount_float: number;
+    formatted_amount: string;
+}
+interface AdjustmentCreate extends ResourceCreate {
+    name: string;
+    currency_code: string;
+    amount_cents: number;
+}
+interface AdjustmentUpdate extends ResourceUpdate {
+    name?: string | null;
+    currency_code?: string | null;
+    amount_cents?: number | null;
+}
+declare class Adjustments extends ApiResource<Adjustment> {
+    static readonly TYPE: AdjustmentType;
+    create(resource: AdjustmentCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Adjustment>;
+    update(resource: AdjustmentUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Adjustment>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    isAdjustment(resource: any): resource is Adjustment;
+    relationship(id: string | ResourceId | null): AdjustmentRel;
+    type(): AdjustmentType;
+}
+export default Adjustments;
+export type { Adjustment, AdjustmentCreate, AdjustmentUpdate, AdjustmentType };

package/lib/esm/resources/adjustments.js

@@ -0,0 +1,23 @@
+import { ApiResource } from '../resource';
+class Adjustments extends ApiResource {
+    async create(resource, params, options) {
+        return this.resources.create({ ...resource, type: Adjustments.TYPE }, params, options);
+    }
+    async update(resource, params, options) {
+        return this.resources.update({ ...resource, type: Adjustments.TYPE }, params, options);
+    }
+    async delete(id, options) {
+        await this.resources.delete((typeof id === 'string') ? { id, type: Adjustments.TYPE } : id, options);
+    }
+    isAdjustment(resource) {
+        return resource.type && (resource.type === Adjustments.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: Adjustments.TYPE } : { id: id.id, type: Adjustments.TYPE };
+    }
+    type() {
+        return Adjustments.TYPE;
+    }
+}
+Adjustments.TYPE = 'adjustments';
+export default Adjustments;

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

@@ -0,0 +1,56 @@
+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 { AdyenPayment, AdyenPaymentType } from './adyen_payments';
+type AdyenGatewayType = 'adyen_gateways';
+type AdyenGatewayRel = ResourceRel & {
+    type: AdyenGatewayType;
+};
+type AdyenPaymentRel = ResourceRel & {
+    type: AdyenPaymentType;
+};
+interface AdyenGateway extends Resource {
+    readonly type: AdyenGatewayType;
+    name: string;
+    live_url_prefix: string;
+    async_api?: boolean | null;
+    webhook_endpoint_secret?: string | null;
+    webhook_endpoint_url?: string | null;
+    payment_methods?: PaymentMethod[] | null;
+    adyen_payments?: AdyenPayment[] | null;
+}
+interface AdyenGatewayCreate extends ResourceCreate {
+    name: string;
+    merchant_account: string;
+    api_key: string;
+    public_key?: string | null;
+    live_url_prefix: string;
+    api_version?: string | null;
+    async_api?: boolean | null;
+    webhook_endpoint_secret?: string | null;
+    adyen_payments?: AdyenPaymentRel[] | null;
+}
+interface AdyenGatewayUpdate extends ResourceUpdate {
+    name?: string | null;
+    merchant_account?: string | null;
+    api_key?: string | null;
+    public_key?: string | null;
+    live_url_prefix?: string | null;
+    api_version?: string | null;
+    async_api?: boolean | null;
+    webhook_endpoint_secret?: string | null;
+    adyen_payments?: AdyenPaymentRel[] | null;
+}
+declare class AdyenGateways extends ApiResource<AdyenGateway> {
+    static readonly TYPE: AdyenGatewayType;
+    create(resource: AdyenGatewayCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<AdyenGateway>;
+    update(resource: AdyenGatewayUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<AdyenGateway>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    payment_methods(adyenGatewayId: string | AdyenGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<PaymentMethod>>;
+    adyen_payments(adyenGatewayId: string | AdyenGateway, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<AdyenPayment>>;
+    isAdyenGateway(resource: any): resource is AdyenGateway;
+    relationship(id: string | ResourceId | null): AdyenGatewayRel;
+    type(): AdyenGatewayType;
+}
+export default AdyenGateways;
+export type { AdyenGateway, AdyenGatewayCreate, AdyenGatewayUpdate, AdyenGatewayType };

package/lib/esm/resources/adyen_gateways.js

@@ -0,0 +1,31 @@
+import { ApiResource } from '../resource';
+class AdyenGateways extends ApiResource {
+    async create(resource, params, options) {
+        return this.resources.create({ ...resource, type: AdyenGateways.TYPE }, params, options);
+    }
+    async update(resource, params, options) {
+        return this.resources.update({ ...resource, type: AdyenGateways.TYPE }, params, options);
+    }
+    async delete(id, options) {
+        await this.resources.delete((typeof id === 'string') ? { id, type: AdyenGateways.TYPE } : id, options);
+    }
+    async payment_methods(adyenGatewayId, params, options) {
+        const _adyenGatewayId = adyenGatewayId.id || adyenGatewayId;
+        return this.resources.fetch({ type: 'payment_methods' }, `adyen_gateways/${_adyenGatewayId}/payment_methods`, params, options);
+    }
+    async adyen_payments(adyenGatewayId, params, options) {
+        const _adyenGatewayId = adyenGatewayId.id || adyenGatewayId;
+        return this.resources.fetch({ type: 'adyen_payments' }, `adyen_gateways/${_adyenGatewayId}/adyen_payments`, params, options);
+    }
+    isAdyenGateway(resource) {
+        return resource.type && (resource.type === AdyenGateways.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: AdyenGateways.TYPE } : { id: id.id, type: AdyenGateways.TYPE };
+    }
+    type() {
+        return AdyenGateways.TYPE;
+    }
+}
+AdyenGateways.TYPE = 'adyen_gateways';
+export default AdyenGateways;

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

@@ -0,0 +1,46 @@
+import { ApiResource, Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel } from '../resource';
+import type { QueryParamsRetrieve } from '../query';
+import type { Order, OrderType } from './orders';
+import type { PaymentGateway } from './payment_gateways';
+type AdyenPaymentType = 'adyen_payments';
+type AdyenPaymentRel = ResourceRel & {
+    type: AdyenPaymentType;
+};
+type OrderRel = ResourceRel & {
+    type: OrderType;
+};
+interface AdyenPayment extends Resource {
+    readonly type: AdyenPaymentType;
+    public_key?: string | null;
+    payment_methods: object;
+    payment_request_data?: object | null;
+    payment_request_details?: object | null;
+    payment_response?: object | null;
+    mismatched_amounts?: boolean | null;
+    payment_instrument?: object | null;
+    order?: Order | null;
+    payment_gateway?: PaymentGateway | null;
+}
+interface AdyenPaymentCreate extends ResourceCreate {
+    order: OrderRel;
+}
+interface AdyenPaymentUpdate extends ResourceUpdate {
+    payment_request_data?: object | null;
+    payment_request_details?: object | null;
+    payment_response?: object | null;
+    _details?: boolean | null;
+    order?: OrderRel | null;
+}
+declare class AdyenPayments extends ApiResource<AdyenPayment> {
+    static readonly TYPE: AdyenPaymentType;
+    create(resource: AdyenPaymentCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<AdyenPayment>;
+    update(resource: AdyenPaymentUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<AdyenPayment>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    order(adyenPaymentId: string | AdyenPayment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Order>;
+    payment_gateway(adyenPaymentId: string | AdyenPayment, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<PaymentGateway>;
+    isAdyenPayment(resource: any): resource is AdyenPayment;
+    relationship(id: string | ResourceId | null): AdyenPaymentRel;
+    type(): AdyenPaymentType;
+}
+export default AdyenPayments;
+export type { AdyenPayment, AdyenPaymentCreate, AdyenPaymentUpdate, AdyenPaymentType };

package/lib/esm/resources/adyen_payments.js

@@ -0,0 +1,31 @@
+import { ApiResource } from '../resource';
+class AdyenPayments extends ApiResource {
+    async create(resource, params, options) {
+        return this.resources.create({ ...resource, type: AdyenPayments.TYPE }, params, options);
+    }
+    async update(resource, params, options) {
+        return this.resources.update({ ...resource, type: AdyenPayments.TYPE }, params, options);
+    }
+    async delete(id, options) {
+        await this.resources.delete((typeof id === 'string') ? { id, type: AdyenPayments.TYPE } : id, options);
+    }
+    async order(adyenPaymentId, params, options) {
+        const _adyenPaymentId = adyenPaymentId.id || adyenPaymentId;
+        return this.resources.fetch({ type: 'orders' }, `adyen_payments/${_adyenPaymentId}/order`, params, options);
+    }
+    async payment_gateway(adyenPaymentId, params, options) {
+        const _adyenPaymentId = adyenPaymentId.id || adyenPaymentId;
+        return this.resources.fetch({ type: 'payment_gateways' }, `adyen_payments/${_adyenPaymentId}/payment_gateway`, params, options);
+    }
+    isAdyenPayment(resource) {
+        return resource.type && (resource.type === AdyenPayments.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: AdyenPayments.TYPE } : { id: id.id, type: AdyenPayments.TYPE };
+    }
+    type() {
+        return AdyenPayments.TYPE;
+    }
+}
+AdyenPayments.TYPE = 'adyen_payments';
+export default AdyenPayments;

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

@@ -0,0 +1,21 @@
+import { ApiSingleton, Resource, ResourceId, ResourceRel } from '../resource';
+type ApplicationType = 'application';
+type ApplicationRel = ResourceRel & {
+    type: ApplicationType;
+};
+interface Application extends Resource {
+    readonly type: ApplicationType;
+    name?: string | null;
+    kind?: string | null;
+    public_access?: boolean | null;
+    redirect_uri?: string | null;
+    scopes?: string | null;
+}
+declare class Applications extends ApiSingleton<Application> {
+    static readonly TYPE: ApplicationType;
+    isApplication(resource: any): resource is Application;
+    relationship(id: string | ResourceId | null): ApplicationRel;
+    type(): ApplicationType;
+}
+export default Applications;
+export type { Application, ApplicationType };