@commercelayer/provisioning-sdk 1.0.0-beta.1

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

@@ -0,0 +1,47 @@
+import { ApiResource } from '../resource';
+import type { Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsRetrieve, QueryParamsList } from '../query';
+import type { Organization, OrganizationType } from './organizations';
+import type { Permission } from './permissions';
+import type { Membership } from './memberships';
+import type { ApiCredential } from './api_credentials';
+import type { Version } from './versions';
+type RoleType = 'roles';
+type RoleRel = ResourceRel & {
+    type: RoleType;
+};
+type OrganizationRel = ResourceRel & {
+    type: OrganizationType;
+};
+interface Role extends Resource {
+    readonly type: RoleType;
+    name: string;
+    kind?: string | null;
+    organization?: Organization | null;
+    permissions?: Permission[] | null;
+    memberships?: Membership[] | null;
+    api_credentials?: ApiCredential[] | null;
+    versions?: Version[] | null;
+}
+interface RoleCreate extends ResourceCreate {
+    name: string;
+    organization: OrganizationRel;
+}
+interface RoleUpdate extends ResourceUpdate {
+    name?: string | null;
+}
+declare class Roles extends ApiResource<Role> {
+    static readonly TYPE: RoleType;
+    create(resource: RoleCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Role>;
+    update(resource: RoleUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Role>;
+    organization(roleId: string | Role, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Organization>;
+    permissions(roleId: string | Role, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Permission>>;
+    memberships(roleId: string | Role, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Membership>>;
+    api_credentials(roleId: string | Role, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<ApiCredential>>;
+    versions(roleId: string | Role, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
+    isRole(resource: any): resource is Role;
+    relationship(id: string | ResourceId | null): RoleRel;
+    type(): RoleType;
+}
+export default Roles;
+export type { Role, RoleCreate, RoleUpdate, RoleType };

package/lib/cjs/resources/roles.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resource_1 = require("../resource");
+class Roles extends resource_1.ApiResource {
+    async create(resource, params, options) {
+        return this.resources.create({ ...resource, type: Roles.TYPE }, params, options);
+    }
+    async update(resource, params, options) {
+        return this.resources.update({ ...resource, type: Roles.TYPE }, params, options);
+    }
+    async organization(roleId, params, options) {
+        const _roleId = roleId.id || roleId;
+        return this.resources.fetch({ type: 'organizations' }, `roles/${_roleId}/organization`, params, options);
+    }
+    async permissions(roleId, params, options) {
+        const _roleId = roleId.id || roleId;
+        return this.resources.fetch({ type: 'permissions' }, `roles/${_roleId}/permissions`, params, options);
+    }
+    async memberships(roleId, params, options) {
+        const _roleId = roleId.id || roleId;
+        return this.resources.fetch({ type: 'memberships' }, `roles/${_roleId}/memberships`, params, options);
+    }
+    async api_credentials(roleId, params, options) {
+        const _roleId = roleId.id || roleId;
+        return this.resources.fetch({ type: 'api_credentials' }, `roles/${_roleId}/api_credentials`, params, options);
+    }
+    async versions(roleId, params, options) {
+        const _roleId = roleId.id || roleId;
+        return this.resources.fetch({ type: 'versions' }, `roles/${_roleId}/versions`, params, options);
+    }
+    isRole(resource) {
+        return resource.type && (resource.type === Roles.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: Roles.TYPE } : { id: id.id, type: Roles.TYPE };
+    }
+    type() {
+        return Roles.TYPE;
+    }
+}
+Roles.TYPE = 'roles';
+exports.default = Roles;

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

@@ -0,0 +1,29 @@
+import { ApiSingleton } from '../resource';
+import type { Resource, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel } from '../resource';
+import type { QueryParamsRetrieve } from '../query';
+type UserType = 'user';
+type UserRel = ResourceRel & {
+    type: UserType;
+};
+interface User extends Resource {
+    readonly type: UserType;
+    email: string;
+    first_name: string;
+    last_name: string;
+    time_zone?: string | null;
+}
+interface UserUpdate extends ResourceUpdate {
+    email?: string | null;
+    first_name?: string | null;
+    last_name?: string | null;
+    time_zone?: string | null;
+}
+declare class Users extends ApiSingleton<User> {
+    static readonly TYPE: UserType;
+    retrieve(params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<User>;
+    isUser(resource: any): resource is User;
+    relationship(id: string | ResourceId | null): UserRel;
+    type(): UserType;
+}
+export default Users;
+export type { User, UserUpdate, UserType };

package/lib/cjs/resources/user.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resource_1 = require("../resource");
+class Users extends resource_1.ApiSingleton {
+    async retrieve(params, options) {
+        return this.resources.singleton({ type: Users.TYPE }, params, options);
+    }
+    isUser(resource) {
+        return resource.type && (resource.type === Users.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: Users.TYPE } : { id: id.id, type: Users.TYPE };
+    }
+    type() {
+        return Users.TYPE;
+    }
+}
+Users.TYPE = 'user';
+exports.default = Users;

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

@@ -0,0 +1,22 @@
+import { ApiResource } from '../resource';
+import type { Resource, ResourceId, ResourceRel } from '../resource';
+type VersionType = 'versions';
+type VersionRel = ResourceRel & {
+    type: VersionType;
+};
+interface Version extends Resource {
+    readonly type: VersionType;
+    resource_type?: string | null;
+    resource_id?: string | null;
+    event?: string | null;
+    changes?: Record<string, any> | null;
+    who?: Record<string, any> | null;
+}
+declare class Versions extends ApiResource<Version> {
+    static readonly TYPE: VersionType;
+    isVersion(resource: any): resource is Version;
+    relationship(id: string | ResourceId | null): VersionRel;
+    type(): VersionType;
+}
+export default Versions;
+export type { Version, VersionType };

package/lib/cjs/resources/versions.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resource_1 = require("../resource");
+class Versions extends resource_1.ApiResource {
+    isVersion(resource) {
+        return resource.type && (resource.type === Versions.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: Versions.TYPE } : { id: id.id, type: Versions.TYPE };
+    }
+    type() {
+        return Versions.TYPE;
+    }
+}
+Versions.TYPE = 'versions';
+exports.default = Versions;

package/lib/cjs/static.d.ts

@@ -0,0 +1,9 @@
+import { SdkError, ApiError } from './error';
+import type { CommerceLayerProvisioningClient, CommerceLayerInitConfig } from './commercelayer';
+export declare const CommerceLayerProvisioningStatic: {
+    resources: () => readonly string[];
+    isSdkError: (error: unknown) => error is SdkError;
+    isApiError: (error: unknown) => error is ApiError;
+    init: (config: CommerceLayerInitConfig) => CommerceLayerProvisioningClient;
+    readonly schemaVersion: string;
+};

package/lib/cjs/static.js

@@ -0,0 +1,45 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommerceLayerProvisioningStatic = void 0;
+const api = __importStar(require("./api"));
+const error_1 = require("./error");
+const commercelayer_1 = __importStar(require("./commercelayer"));
+/* Static functions */
+exports.CommerceLayerProvisioningStatic = {
+    resources: () => {
+        return api.resourceList;
+    },
+    isSdkError: (error) => {
+        return error_1.SdkError.isSdkError(error);
+    },
+    isApiError: (error) => {
+        return error_1.ApiError.isApiError(error);
+    },
+    init: (config) => {
+        return (0, commercelayer_1.default)(config);
+    },
+    get schemaVersion() { return commercelayer_1.OPEN_API_SCHEMA_VERSION; }
+};

package/lib/cjs/util.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import type { ObjectType } from "../src/common";
+declare const sleep: (ms: number) => Promise<NodeJS.Timeout>;
+declare const sortObjectFields: (obj: ObjectType) => ObjectType;
+export { sleep, sortObjectFields };

package/lib/cjs/util.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortObjectFields = exports.sleep = void 0;
+const sleep = async (ms) => {
+    return new Promise(resolve => setTimeout(resolve, ms));
+};
+exports.sleep = sleep;
+const sortObjectFields = (obj) => {
+    const sorted = Object.keys(obj).sort().reduce((accumulator, key) => {
+        accumulator[key] = obj[key];
+        return accumulator;
+    }, {});
+    return sorted;
+};
+exports.sortObjectFields = sortObjectFields;

package/lib/esm/api.d.ts

@@ -0,0 +1,41 @@
+import type { Resource, ResourceRel } from './resource';
+import type { VersionType } from './resources/versions';
+/**
+ * ©2023 Commerce Layer Inc.
+ **/
+export { default as ApiCredentials } from './resources/api_credentials';
+export { default as Memberships } from './resources/memberships';
+export { default as Organizations } from './resources/organizations';
+export { default as Permissions } from './resources/permissions';
+export { default as Roles } from './resources/roles';
+export { default as Users } from './resources/user';
+export { default as Versions } from './resources/versions';
+export type ResourceTypeLock = 'api_credentials' | 'memberships' | 'organizations' | 'permissions' | 'roles' | 'user' | 'versions';
+export declare const resourceList: readonly ["api_credentials", "memberships", "organizations", "permissions", "roles", "user", "versions"];
+export type RetrievableResourceType = ResourceTypeLock;
+export type RetrievableResource = Resource & {
+    type: RetrievableResourceType;
+};
+export type ListableResourceType = Exclude<ResourceTypeLock, 'user'>;
+export type ListableResource = Resource & {
+    type: ListableResourceType;
+};
+export type CreatableResourceType = 'api_credentials' | 'memberships' | 'organizations' | 'permissions' | 'roles';
+export type CreatableResource = Resource & {
+    type: CreatableResourceType;
+};
+export type UpdatableResourceType = 'api_credentials' | 'memberships' | 'organizations' | 'permissions' | 'roles';
+export type UpdatableResource = Resource & {
+    type: UpdatableResourceType;
+};
+export type DeletableResourceType = 'api_credentials' | 'memberships';
+export type DeletableResource = Resource & {
+    type: DeletableResourceType;
+};
+export type VersionableResourceType = 'memberships' | 'permissions' | 'roles';
+export type VersionableResource = Resource & {
+    type: VersionableResourceType;
+    versions?: Array<ResourceRel & {
+        type: VersionType;
+    }> | null;
+};

package/lib/esm/api.js

@@ -0,0 +1,24 @@
+// ##__API_RESOURCES_START__##
+// ##__API_RESOURCES_TEMPLATE:: export { default as ##__RESOURCE_CLASS__## } from './resources/##__RESOURCE_TYPE__##'
+/**
+ * ©2023 Commerce Layer Inc.
+ **/
+export { default as ApiCredentials } from './resources/api_credentials';
+export { default as Memberships } from './resources/memberships';
+export { default as Organizations } from './resources/organizations';
+export { default as Permissions } from './resources/permissions';
+export { default as Roles } from './resources/roles';
+export { default as Users } from './resources/user';
+export { default as Versions } from './resources/versions';
+// ##__API_RESOURCE_TYPES_STOP__##
+export const resourceList = [
+    // ##__API_RESOURCE_LIST_START__##
+    'api_credentials',
+    'memberships',
+    'organizations',
+    'permissions',
+    'roles',
+    'user',
+    'versions'
+    // ##__API_RESOURCE_LIST_STOP__##
+];

package/lib/esm/client.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import type { AxiosAdapter, AxiosProxyConfig, Method } from 'axios';
+import type { InterceptorManager } from './interceptor';
+import type { Agent as HttpAgent } from 'http';
+import type { Agent as HttpsAgent } from 'https';
+type ProxyConfig = AxiosProxyConfig | false;
+type Adapter = AxiosAdapter;
+type RequestParams = Record<string, string | number | boolean>;
+type RequestHeaders = Record<string, string>;
+type RequestConfig = {
+    timeout?: number;
+    params?: RequestParams;
+    httpAgent?: HttpAgent;
+    httpsAgent?: HttpsAgent;
+    proxy?: ProxyConfig;
+    headers?: RequestHeaders;
+};
+type ApiConfig = {
+    domain?: string;
+    accessToken: string;
+};
+type ApiClientInitConfig = ApiConfig & RequestConfig & {
+    adapter?: Adapter;
+};
+type ApiClientConfig = Partial<ApiClientInitConfig>;
+declare class ApiClient {
+    #private;
+    static create(options: ApiClientInitConfig): ApiClient;
+    baseUrl: string;
+    interceptors: InterceptorManager;
+    private constructor();
+    config(config: ApiClientConfig): ApiClient;
+    adapter(adapter: Adapter): ApiClient;
+    request(method: Method, path: string, body?: any, options?: ApiClientConfig): Promise<any>;
+    private customHeaders;
+}
+export default ApiClient;
+export type { ApiClientInitConfig, ApiClientConfig, RequestConfig };

package/lib/esm/client.js

@@ -0,0 +1,116 @@
+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 _ApiClient_accessToken, _ApiClient_client;
+import axios from 'axios';
+import { SdkError, handleError } from './error';
+import config from './config';
+import Debug from './debug';
+const debug = Debug('client');
+const baseURL = (domain) => {
+    return `https://provisioning.${domain || config.default.domain}/api`;
+};
+class ApiClient {
+    static create(options) {
+        for (const attr of config.client.requiredAttributes)
+            if (!options || !options[attr])
+                throw new SdkError({ message: `Undefined '${attr}' parameter` });
+        return new ApiClient(options);
+    }
+    constructor(options) {
+        _ApiClient_accessToken.set(this, void 0);
+        _ApiClient_client.set(this, void 0);
+        debug('new client instance %O', options);
+        this.baseUrl = baseURL(options.domain);
+        __classPrivateFieldSet(this, _ApiClient_accessToken, options.accessToken, "f");
+        const axiosConfig = {
+            timeout: options.timeout || config.client.timeout,
+            proxy: options.proxy,
+            httpAgent: options.httpAgent,
+            httpsAgent: options.httpsAgent,
+        };
+        // Set custom headers
+        const customHeaders = this.customHeaders(options.headers);
+        const axiosOptions = {
+            baseURL: this.baseUrl,
+            timeout: config.client.timeout,
+            headers: {
+                ...customHeaders,
+                'Accept': 'application/vnd.api+json',
+                'Content-Type': 'application/vnd.api+json',
+                'Authorization': 'Bearer ' + __classPrivateFieldGet(this, _ApiClient_accessToken, "f")
+            },
+            ...axiosConfig
+        };
+        if (options.adapter)
+            axiosOptions.adapter = options.adapter;
+        debug('axios options: %O', axiosOptions);
+        __classPrivateFieldSet(this, _ApiClient_client, axios.create(axiosOptions), "f");
+        this.interceptors = __classPrivateFieldGet(this, _ApiClient_client, "f").interceptors;
+    }
+    config(config) {
+        debug('config %o', config);
+        const def = __classPrivateFieldGet(this, _ApiClient_client, "f").defaults;
+        // Axios config
+        if (config.timeout)
+            def.timeout = config.timeout;
+        if (config.proxy)
+            def.proxy = config.proxy;
+        if (config.httpAgent)
+            def.httpAgent = config.httpAgent;
+        if (config.httpsAgent)
+            def.httpsAgent = config.httpsAgent;
+        // API Client config
+        if (config.accessToken) {
+            __classPrivateFieldSet(this, _ApiClient_accessToken, config.accessToken, "f");
+            def.headers.common.Authorization = 'Bearer ' + __classPrivateFieldGet(this, _ApiClient_accessToken, "f");
+        }
+        if (config.headers)
+            def.headers.common = this.customHeaders(config.headers);
+        if (config.adapter)
+            this.adapter(config.adapter);
+        return this;
+    }
+    adapter(adapter) {
+        if (adapter)
+            __classPrivateFieldGet(this, _ApiClient_client, "f").defaults.adapter = adapter;
+        return this;
+    }
+    async request(method, path, body, options) {
+        debug('request %s %s, %O, %O', method, path, body || {}, options || {});
+        const data = body ? { data: body } : undefined;
+        const url = path;
+        // Runtime request parameters
+        // const baseUrl = options?.organization ? baseURL(options.organization, options.domain) : undefined
+        const accessToken = (options === null || options === void 0 ? void 0 : options.accessToken) || __classPrivateFieldGet(this, _ApiClient_accessToken, "f");
+        const headers = this.customHeaders(options === null || options === void 0 ? void 0 : options.headers);
+        if (accessToken)
+            headers.Authorization = 'Bearer ' + accessToken;
+        const requestParams = { method, url, data, ...options, headers };
+        debug('request params: %O', requestParams);
+        // const start = Date.now()
+        return __classPrivateFieldGet(this, _ApiClient_client, "f").request(requestParams)
+            .then(response => response.data)
+            .catch(error => handleError(error));
+        // .finally(() => console.log(`<<-- ${method} ${path} ${Date.now() - start}`))
+    }
+    customHeaders(headers) {
+        const customHeaders = {};
+        if (headers) {
+            for (const [name, value] of Object.entries(headers))
+                if (!['accept', 'content-type', 'authorization'].includes(name.toLowerCase()))
+                    customHeaders[name] = value;
+        }
+        return customHeaders;
+    }
+}
+_ApiClient_accessToken = new WeakMap(), _ApiClient_client = new WeakMap();
+export default ApiClient;

package/lib/esm/commercelayer.d.ts

@@ -0,0 +1,36 @@
+import * as api from './api';
+import type { ApiError } from './error';
+import type { ErrorInterceptor, InterceptorType, RawResponseReader, RequestInterceptor, ResponseInterceptor } from './interceptor';
+import { type ResourcesInitConfig } from './resource';
+declare const OPEN_API_SCHEMA_VERSION = "1.0.0";
+export { OPEN_API_SCHEMA_VERSION };
+type SdkConfig = {};
+type CommerceLayerInitConfig = SdkConfig & ResourcesInitConfig;
+type CommerceLayerConfig = Partial<CommerceLayerInitConfig>;
+declare class CommerceLayerProvisioningClient {
+    #private;
+    readonly openApiSchemaVersion = "1.0.0";
+    api_credentials: api.ApiCredentials;
+    memberships: api.Memberships;
+    organizations: api.Organizations;
+    permissions: api.Permissions;
+    roles: api.Roles;
+    user: api.Users;
+    versions: api.Versions;
+    constructor(config: CommerceLayerInitConfig);
+    private localConfig;
+    config(config: CommerceLayerConfig): CommerceLayerProvisioningClient;
+    resources(): readonly string[];
+    isApiError(error: any): error is ApiError;
+    addRequestInterceptor(onFulfilled?: RequestInterceptor, onRejected?: ErrorInterceptor): number;
+    addResponseInterceptor(onFulfilled?: ResponseInterceptor, onRejected?: ErrorInterceptor): number;
+    removeInterceptor(type: InterceptorType, id: number): void;
+    addRawResponseReader(options?: {
+        headers: boolean;
+    }): RawResponseReader;
+    removeRawResponseReader(reader: number | RawResponseReader): void;
+}
+declare const CommerceLayerProvisioning: (config: CommerceLayerInitConfig) => CommerceLayerProvisioningClient;
+export default CommerceLayerProvisioning;
+export { CommerceLayerProvisioning };
+export type { CommerceLayerProvisioningClient, CommerceLayerConfig, CommerceLayerInitConfig };

package/lib/esm/commercelayer.js

@@ -0,0 +1,97 @@
+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 _CommerceLayerProvisioningClient_adapter;
+import * as api from './api';
+import { CommerceLayerProvisioningStatic } from './static';
+import ResourceAdapter from './resource';
+import Debug from './debug';
+const debug = Debug('commercelayer');
+// Autogenerated schema version number, do not remove this line
+const OPEN_API_SCHEMA_VERSION = '1.0.0';
+export { OPEN_API_SCHEMA_VERSION };
+class CommerceLayerProvisioningClient {
+    // ##__CL_RESOURCES_DEF_STOP__##
+    constructor(config) {
+        // static get openApiSchemaVersion(): string { return OPEN_API_SCHEMA_VERSION }
+        this.openApiSchemaVersion = OPEN_API_SCHEMA_VERSION;
+        _CommerceLayerProvisioningClient_adapter.set(this, void 0);
+        debug('new commercelayer provisioning instance %O', config);
+        __classPrivateFieldSet(this, _CommerceLayerProvisioningClient_adapter, new ResourceAdapter(config), "f");
+        // this.#environment = 'test'
+        // ##__CL_RESOURCES_INIT_START__##
+        // ##__CL_RESOURCES_INIT_TEMPLATE:: ##__TAB__####__TAB__##this.##__RESOURCE_TYPE__## = new api.##__RESOURCE_CLASS__##(this.#adapter)
+        this.api_credentials = new api.ApiCredentials(__classPrivateFieldGet(this, _CommerceLayerProvisioningClient_adapter, "f"));
+        this.memberships = new api.Memberships(__classPrivateFieldGet(this, _CommerceLayerProvisioningClient_adapter, "f"));
+        this.organizations = new api.Organizations(__classPrivateFieldGet(this, _CommerceLayerProvisioningClient_adapter, "f"));
+        this.permissions = new api.Permissions(__classPrivateFieldGet(this, _CommerceLayerProvisioningClient_adapter, "f"));
+        this.roles = new api.Roles(__classPrivateFieldGet(this, _CommerceLayerProvisioningClient_adapter, "f"));
+        this.user = new api.Users(__classPrivateFieldGet(this, _CommerceLayerProvisioningClient_adapter, "f"));
+        this.versions = new api.Versions(__classPrivateFieldGet(this, _CommerceLayerProvisioningClient_adapter, "f"));
+        // ##__CL_RESOURCES_INIT_STOP__##
+    }
+    // get environment(): ApiMode { return this.#environment }
+    localConfig(config /* & { organization?: string } */) {
+    }
+    config(config) {
+        debug('config %o', config);
+        // CommerceLayer config
+        this.localConfig(config);
+        // ResourceAdapter config
+        // To rebuild baseUrl in client in case only the domain is defined
+        // if (!config.organization) config.organization = this.currentOrganization
+        __classPrivateFieldGet(this, _CommerceLayerProvisioningClient_adapter, "f").config(config);
+        return this;
+    }
+    resources() {
+        return CommerceLayerProvisioningStatic.resources();
+    }
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+    isApiError(error) {
+        return CommerceLayerProvisioningStatic.isApiError(error);
+    }
+    addRequestInterceptor(onFulfilled, onRejected) {
+        return __classPrivateFieldGet(this, _CommerceLayerProvisioningClient_adapter, "f").interceptors.request.use(onFulfilled, onRejected);
+    }
+    addResponseInterceptor(onFulfilled, onRejected) {
+        return __classPrivateFieldGet(this, _CommerceLayerProvisioningClient_adapter, "f").interceptors.response.use(onFulfilled, onRejected);
+    }
+    removeInterceptor(type, id) {
+        __classPrivateFieldGet(this, _CommerceLayerProvisioningClient_adapter, "f").interceptors[type].eject(id);
+    }
+    addRawResponseReader(options) {
+        const reader = {
+            id: undefined,
+            rawResponse: undefined,
+            headers: undefined,
+        };
+        function rawResponseInterceptor(response) {
+            reader.rawResponse = response === null || response === void 0 ? void 0 : response.data;
+            if (options === null || options === void 0 ? void 0 : options.headers)
+                reader.headers = response.headers;
+            return response;
+        }
+        const interceptor = this.addResponseInterceptor(rawResponseInterceptor);
+        reader.id = interceptor;
+        return reader;
+    }
+    removeRawResponseReader(reader) {
+        const id = (typeof reader === 'number') ? reader : reader === null || reader === void 0 ? void 0 : reader.id;
+        if (id && (id >= 0))
+            this.removeInterceptor('response', id);
+    }
+}
+_CommerceLayerProvisioningClient_adapter = new WeakMap();
+const CommerceLayerProvisioning = (config) => {
+    return new CommerceLayerProvisioningClient(config);
+};
+export default CommerceLayerProvisioning;
+export { CommerceLayerProvisioning };

package/lib/esm/common.d.ts

@@ -0,0 +1,5 @@
+import type { ResourceId, ResourceType } from './resource';
+declare const isResourceId: (resource: any) => resource is ResourceId;
+declare const isResourceType: (resource: any) => resource is ResourceType;
+export { isResourceId, isResourceType };
+export type ObjectType = Record<string, any>;

package/lib/esm/common.js

@@ -0,0 +1,8 @@
+import { resourceList } from './api';
+const isResourceId = (resource) => {
+    return ((resource === null || resource === void 0 ? void 0 : resource.type) && resource.id) && resourceList.includes(resource.type);
+};
+const isResourceType = (resource) => {
+    return resource && (typeof resource.type !== 'undefined') && resource.type && resourceList.includes(resource.type);
+};
+export { isResourceId, isResourceType };

package/lib/esm/config.d.ts

@@ -0,0 +1,12 @@
+declare const config: {
+    readonly default: {
+        readonly domain: "commercelayer.io";
+        readonly pageNumber: 1;
+        readonly pageSize: 10;
+    };
+    readonly client: {
+        readonly timeout: 15000;
+        readonly requiredAttributes: readonly ["accessToken"];
+    };
+};
+export default config;