@commercelayer/provisioning-sdk 1.0.0-beta.1

package/lib/cjs/resource.d.ts

@@ -0,0 +1,86 @@
+import { type ApiClientInitConfig } from './client';
+import type { QueryParamsRetrieve, QueryParamsList, QueryFilter, QueryParams } from './query';
+import type { ResourceTypeLock } from './api';
+import type { InterceptorManager } from './interceptor';
+type ResourceNull = {
+    id: null;
+} & ResourceType;
+type ResourceRel = ResourceId | ResourceNull;
+type Metadata = Record<string, any>;
+interface ResourceType {
+    readonly type: ResourceTypeLock;
+}
+interface ResourceId extends ResourceType {
+    readonly id: string;
+}
+interface ResourceBase {
+    reference?: string | null;
+    reference_origin?: string | null;
+    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, ListMeta, 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): ResourceAdapter;
+    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;
+    parse(resource: any): R | R[];
+    update(resource: ResourceUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<R>;
+}
+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>>;
+    count(filter?: QueryFilter | QueryParamsList, options?: ResourcesConfig): Promise<number>;
+}
+declare abstract class ApiSingleton<R extends Resource> extends ApiResourceBase<R> {
+    retrieve(params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<R>;
+}
+export default ResourceAdapter;
+export { ApiResource, ApiSingleton };
+export type { ResourcesConfig, ResourcesInitConfig };

package/lib/cjs/resource.js

@@ -0,0 +1,191 @@
+"use strict";
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _ResourceAdapter_client, _ResourceAdapter_config;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiSingleton = exports.ApiResource = void 0;
+const client_1 = __importDefault(require("./client"));
+const jsonapi_1 = require("./jsonapi");
+const query_1 = require("./query");
+const config_1 = __importDefault(require("./config"));
+const debug_1 = __importDefault(require("./debug"));
+const error_1 = require("./error");
+const debug = (0, debug_1.default)('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, client_1.default.create(config), "f");
+        this.localConfig(config);
+    }
+    get interceptors() { return __classPrivateFieldGet(this, _ResourceAdapter_client, "f").interceptors; }
+    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);
+        return this;
+    }
+    /*
+    get clientInstance(): ApiClient {
+        return this.#client
+    }
+    */
+    async singleton(resource, params, options) {
+        debug('singleton: %o, %O, %O', resource, params || {}, options || {});
+        const queryParams = (0, query_1.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 = (0, jsonapi_1.denormalize)(res);
+        return r;
+    }
+    async retrieve(resource, params, options) {
+        debug('retrieve: %o, %O, %O', resource, params || {}, options || {});
+        const queryParams = (0, query_1.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 = (0, jsonapi_1.denormalize)(res);
+        return r;
+    }
+    async list(resource, params, options) {
+        var _a, _b;
+        debug('list: %o, %O, %O', resource, params || {}, options || {});
+        const queryParams = (0, query_1.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 = (0, jsonapi_1.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_1.default.default.pageNumber,
+            recordsPerPage: (params === null || params === void 0 ? void 0 : params.pageSize) || config_1.default.default.pageSize
+        };
+        return new ListResponse(meta, r);
+    }
+    async create(resource, params, options) {
+        debug('create: %o, %O, %O', resource, params || {}, options || {});
+        const queryParams = (0, query_1.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 = (0, jsonapi_1.normalize)(resource);
+        const res = await __classPrivateFieldGet(this, _ResourceAdapter_client, "f").request('post', resource.type, data, { ...options, params: queryParams });
+        const r = (0, jsonapi_1.denormalize)(res);
+        return r;
+    }
+    async update(resource, params, options) {
+        debug('update: %o, %O, %O', resource, params || {}, options || {});
+        const queryParams = (0, query_1.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 = (0, jsonapi_1.normalize)(resource);
+        const res = await __classPrivateFieldGet(this, _ResourceAdapter_client, "f").request('patch', `${resource.type}/${resource.id}`, data, { ...options, params: queryParams });
+        const r = (0, jsonapi_1.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 = (0, query_1.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 = (0, jsonapi_1.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_1.default.default.pageNumber,
+                recordsPerPage: (p === null || p === void 0 ? void 0 : p.pageSize) || config_1.default.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;
+    }
+    parse(resource) {
+        var _a, _b;
+        try {
+            const res = JSON.parse(resource);
+            if (((_a = res.data) === null || _a === void 0 ? void 0 : _a.type) !== this.type())
+                throw new error_1.SdkError({ message: `Invalid resource type [${(_b = res.data) === null || _b === void 0 ? void 0 : _b.type}]`, type: error_1.ErrorType.PARSE });
+            return (0, jsonapi_1.denormalize)(res);
+        }
+        catch (error) {
+            if (error_1.SdkError.isSdkError(error))
+                throw error;
+            else
+                throw new error_1.SdkError({ message: `Payload parse error [${error.message}]`, type: error_1.ErrorType.PARSE });
+        }
+    }
+    // reference, reference_origin and metadata attributes are always updatable
+    async update(resource, params, options) {
+        return this.resources.update({ ...resource, type: this.type() }, params, options);
+    }
+}
+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);
+    }
+    async count(filter, options) {
+        const params = { filters: (0, query_1.isParamsList)(filter) ? filter.filters : filter, pageNumber: 1, pageSize: 1 };
+        const response = await this.list(params, options);
+        return Promise.resolve(response.meta.recordCount);
+    }
+}
+exports.ApiResource = ApiResource;
+class ApiSingleton extends ApiResourceBase {
+    async retrieve(params, options) {
+        return this.resources.singleton({ type: this.type() }, params, options);
+    }
+}
+exports.ApiSingleton = ApiSingleton;
+exports.default = ResourceAdapter;

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

@@ -0,0 +1,55 @@
+import { ApiResource } from '../resource';
+import type { Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel } from '../resource';
+import type { QueryParamsRetrieve } from '../query';
+import type { Organization, OrganizationType } from './organizations';
+import type { Role, RoleType } from './roles';
+type ApiCredentialType = 'api_credentials';
+type ApiCredentialRel = ResourceRel & {
+    type: ApiCredentialType;
+};
+type OrganizationRel = ResourceRel & {
+    type: OrganizationType;
+};
+type RoleRel = ResourceRel & {
+    type: RoleType;
+};
+interface ApiCredential extends Resource {
+    readonly type: ApiCredentialType;
+    name: string;
+    kind: string;
+    confidential?: boolean | null;
+    redirect_uri?: string | null;
+    client_id?: string | null;
+    client_secret?: string | null;
+    scopes?: string | null;
+    expires_in?: number | null;
+    organization?: Organization | null;
+    role?: Role | null;
+}
+interface ApiCredentialCreate extends ResourceCreate {
+    name: string;
+    kind: string;
+    redirect_uri?: string | null;
+    expires_in?: number | null;
+    organization: OrganizationRel;
+    role?: RoleRel | null;
+}
+interface ApiCredentialUpdate extends ResourceUpdate {
+    name?: string | null;
+    redirect_uri?: string | null;
+    expires_in?: number | null;
+    role?: RoleRel | null;
+}
+declare class ApiCredentials extends ApiResource<ApiCredential> {
+    static readonly TYPE: ApiCredentialType;
+    create(resource: ApiCredentialCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<ApiCredential>;
+    update(resource: ApiCredentialUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<ApiCredential>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    organization(apiCredentialId: string | ApiCredential, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Organization>;
+    role(apiCredentialId: string | ApiCredential, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Role>;
+    isApiCredential(resource: any): resource is ApiCredential;
+    relationship(id: string | ResourceId | null): ApiCredentialRel;
+    type(): ApiCredentialType;
+}
+export default ApiCredentials;
+export type { ApiCredential, ApiCredentialCreate, ApiCredentialUpdate, ApiCredentialType };

package/lib/cjs/resources/api_credentials.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resource_1 = require("../resource");
+class ApiCredentials extends resource_1.ApiResource {
+    async create(resource, params, options) {
+        return this.resources.create({ ...resource, type: ApiCredentials.TYPE }, params, options);
+    }
+    async update(resource, params, options) {
+        return this.resources.update({ ...resource, type: ApiCredentials.TYPE }, params, options);
+    }
+    async delete(id, options) {
+        await this.resources.delete((typeof id === 'string') ? { id, type: ApiCredentials.TYPE } : id, options);
+    }
+    async organization(apiCredentialId, params, options) {
+        const _apiCredentialId = apiCredentialId.id || apiCredentialId;
+        return this.resources.fetch({ type: 'organizations' }, `api_credentials/${_apiCredentialId}/organization`, params, options);
+    }
+    async role(apiCredentialId, params, options) {
+        const _apiCredentialId = apiCredentialId.id || apiCredentialId;
+        return this.resources.fetch({ type: 'roles' }, `api_credentials/${_apiCredentialId}/role`, params, options);
+    }
+    isApiCredential(resource) {
+        return resource.type && (resource.type === ApiCredentials.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: ApiCredentials.TYPE } : { id: id.id, type: ApiCredentials.TYPE };
+    }
+    type() {
+        return ApiCredentials.TYPE;
+    }
+}
+ApiCredentials.TYPE = 'api_credentials';
+exports.default = ApiCredentials;

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

@@ -0,0 +1,46 @@
+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 { Role, RoleType } from './roles';
+import type { Version } from './versions';
+type MembershipType = 'memberships';
+type MembershipRel = ResourceRel & {
+    type: MembershipType;
+};
+type OrganizationRel = ResourceRel & {
+    type: OrganizationType;
+};
+type RoleRel = ResourceRel & {
+    type: RoleType;
+};
+interface Membership extends Resource {
+    readonly type: MembershipType;
+    user_email: string;
+    status: 'pending' | 'active';
+    organization?: Organization | null;
+    role?: Role | null;
+    versions?: Version[] | null;
+}
+interface MembershipCreate extends ResourceCreate {
+    user_email: string;
+    organization: OrganizationRel;
+    role: RoleRel;
+}
+interface MembershipUpdate extends ResourceUpdate {
+    role?: RoleRel | null;
+}
+declare class Memberships extends ApiResource<Membership> {
+    static readonly TYPE: MembershipType;
+    create(resource: MembershipCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Membership>;
+    update(resource: MembershipUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Membership>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    organization(membershipId: string | Membership, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Organization>;
+    role(membershipId: string | Membership, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Role>;
+    versions(membershipId: string | Membership, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
+    isMembership(resource: any): resource is Membership;
+    relationship(id: string | ResourceId | null): MembershipRel;
+    type(): MembershipType;
+}
+export default Memberships;
+export type { Membership, MembershipCreate, MembershipUpdate, MembershipType };

package/lib/cjs/resources/memberships.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const resource_1 = require("../resource");
+class Memberships extends resource_1.ApiResource {
+    async create(resource, params, options) {
+        return this.resources.create({ ...resource, type: Memberships.TYPE }, params, options);
+    }
+    async update(resource, params, options) {
+        return this.resources.update({ ...resource, type: Memberships.TYPE }, params, options);
+    }
+    async delete(id, options) {
+        await this.resources.delete((typeof id === 'string') ? { id, type: Memberships.TYPE } : id, options);
+    }
+    async organization(membershipId, params, options) {
+        const _membershipId = membershipId.id || membershipId;
+        return this.resources.fetch({ type: 'organizations' }, `memberships/${_membershipId}/organization`, params, options);
+    }
+    async role(membershipId, params, options) {
+        const _membershipId = membershipId.id || membershipId;
+        return this.resources.fetch({ type: 'roles' }, `memberships/${_membershipId}/role`, params, options);
+    }
+    async versions(membershipId, params, options) {
+        const _membershipId = membershipId.id || membershipId;
+        return this.resources.fetch({ type: 'versions' }, `memberships/${_membershipId}/versions`, params, options);
+    }
+    isMembership(resource) {
+        return resource.type && (resource.type === Memberships.TYPE);
+    }
+    relationship(id) {
+        return ((id === null) || (typeof id === 'string')) ? { id, type: Memberships.TYPE } : { id: id.id, type: Memberships.TYPE };
+    }
+    type() {
+        return Memberships.TYPE;
+    }
+}
+Memberships.TYPE = 'memberships';
+exports.default = Memberships;

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

@@ -0,0 +1,78 @@
+import { ApiResource } from '../resource';
+import type { Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsRetrieve, QueryParamsList } from '../query';
+import type { Membership } from './memberships';
+import type { Role } from './roles';
+import type { Permission } from './permissions';
+import type { ApiCredential } from './api_credentials';
+type OrganizationType = 'organizations';
+type OrganizationRel = ResourceRel & {
+    type: OrganizationType;
+};
+interface Organization extends Resource {
+    readonly type: OrganizationType;
+    name: string;
+    slug?: string | null;
+    domain?: string | null;
+    support_phone?: string | null;
+    support_email?: string | null;
+    logo_url?: string | null;
+    favicon_url?: string | null;
+    primary_color?: string | null;
+    contrast_color?: string | null;
+    gtm_id?: string | null;
+    gtm_id_test?: string | null;
+    discount_disabled?: boolean | null;
+    account_disabled?: boolean | null;
+    acceptance_disabled?: boolean | null;
+    max_concurrent_promotions?: number | null;
+    max_concurrent_imports?: number | null;
+    associated_markets?: Record<string, any> | null;
+    region?: string | null;
+    memberships?: Membership[] | null;
+    roles?: Role[] | null;
+    permissions?: Permission[] | null;
+    api_credentials?: ApiCredential[] | null;
+}
+interface OrganizationCreate extends ResourceCreate {
+    name: string;
+    support_phone?: string | null;
+    support_email?: string | null;
+    logo_url?: string | null;
+    favicon_url?: string | null;
+    primary_color?: string | null;
+    contrast_color?: string | null;
+    gtm_id?: string | null;
+    gtm_id_test?: string | null;
+    discount_disabled?: boolean | null;
+    account_disabled?: boolean | null;
+    acceptance_disabled?: boolean | null;
+    region?: string | null;
+}
+interface OrganizationUpdate extends ResourceUpdate {
+    name?: string | null;
+    support_phone?: string | null;
+    support_email?: string | null;
+    logo_url?: string | null;
+    favicon_url?: string | null;
+    primary_color?: string | null;
+    contrast_color?: string | null;
+    gtm_id?: string | null;
+    gtm_id_test?: string | null;
+    discount_disabled?: boolean | null;
+    account_disabled?: boolean | null;
+    acceptance_disabled?: boolean | null;
+}
+declare class Organizations extends ApiResource<Organization> {
+    static readonly TYPE: OrganizationType;
+    create(resource: OrganizationCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Organization>;
+    update(resource: OrganizationUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Organization>;
+    memberships(organizationId: string | Organization, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Membership>>;
+    roles(organizationId: string | Organization, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Role>>;
+    permissions(organizationId: string | Organization, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Permission>>;
+    isOrganization(resource: any): resource is Organization;
+    relationship(id: string | ResourceId | null): OrganizationRel;
+    type(): OrganizationType;
+}
+export default Organizations;
+export type { Organization, OrganizationCreate, OrganizationUpdate, OrganizationType };

package/lib/cjs/resources/organizations.js

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

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

@@ -0,0 +1,52 @@
+import { ApiResource } from '../resource';
+import type { Resource, ResourceCreate, ResourceUpdate, ResourceId, ResourcesConfig, ResourceRel, ListResponse } from '../resource';
+import type { QueryParamsRetrieve, QueryParamsList } from '../query';
+import type { Organization } from './organizations';
+import type { Role, RoleType } from './roles';
+import type { Version } from './versions';
+type PermissionType = 'permissions';
+type PermissionRel = ResourceRel & {
+    type: PermissionType;
+};
+type RoleRel = ResourceRel & {
+    type: RoleType;
+};
+interface Permission extends Resource {
+    readonly type: PermissionType;
+    can_create: boolean;
+    can_read: boolean;
+    can_update: boolean;
+    can_destroy: boolean;
+    subject: string;
+    restrictions?: Record<string, any> | null;
+    organization?: Organization | null;
+    role?: Role | null;
+    versions?: Version[] | null;
+}
+interface PermissionCreate extends ResourceCreate {
+    can_create: boolean;
+    can_read: boolean;
+    can_update: boolean;
+    can_destroy: boolean;
+    subject: string;
+    role: RoleRel;
+}
+interface PermissionUpdate extends ResourceUpdate {
+    can_create?: boolean | null;
+    can_read?: boolean | null;
+    can_update?: boolean | null;
+    can_destroy?: boolean | null;
+}
+declare class Permissions extends ApiResource<Permission> {
+    static readonly TYPE: PermissionType;
+    create(resource: PermissionCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Permission>;
+    update(resource: PermissionUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Permission>;
+    organization(permissionId: string | Permission, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Organization>;
+    role(permissionId: string | Permission, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<Role>;
+    versions(permissionId: string | Permission, params?: QueryParamsList, options?: ResourcesConfig): Promise<ListResponse<Version>>;
+    isPermission(resource: any): resource is Permission;
+    relationship(id: string | ResourceId | null): PermissionRel;
+    type(): PermissionType;
+}
+export default Permissions;
+export type { Permission, PermissionCreate, PermissionUpdate, PermissionType };

package/lib/cjs/resources/permissions.js

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