@commercelayer/provisioning-sdk 1.0.4 → 2.0.0-beta.1

package/lib/index.d.mts

@@ -0,0 +1,665 @@
+import { DocWithData } from 'jsonapi-typescript';
+
+type Fetch = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+type FetchResponse = DocWithData;
+type FetchRequestOptions = RequestInit;
+declare class FetchError extends Error {
+    #private;
+    static isFetchError: (error: any) => error is FetchError;
+    constructor(status: number, statusText: string, body?: any);
+    get errors(): any[] | undefined;
+    get status(): number;
+    get statusText(): string;
+}
+
+type InterceptorEventManager<S extends (RequestInterceptor | ResponseInterceptor), F extends (ErrorInterceptor | ResponseInterceptor)> = {
+    onSuccess?: S;
+    onFailure?: F;
+};
+type RequestEventManager = InterceptorEventManager<RequestInterceptor, ErrorInterceptor>;
+type ResponseEventManager = InterceptorEventManager<ResponseInterceptor, ErrorInterceptor>;
+type ErrorEventManager = InterceptorEventManager<ResponseInterceptor, ResponseInterceptor>;
+type InterceptorManager = {
+    request?: RequestEventManager;
+    response?: ResponseEventManager;
+    rawReader?: ErrorEventManager;
+};
+type RequestObj = {
+    url: URL;
+    options: FetchRequestOptions;
+};
+type RequestInterceptor = (request: RequestObj) => RequestObj | Promise<RequestObj>;
+type ResponseObj = Response;
+type ResponseInterceptor = (response: ResponseObj) => ResponseObj | Promise<ResponseObj>;
+type ApiHeadersList = 'x-ratelimit-limit' | 'x-ratelimit-count' | 'x-ratelimit-period' | 'x-ratelimit-interval' | 'x-ratelimit-remaining';
+type ApiHeaders = {
+    [key in ApiHeadersList]: string | number | boolean;
+};
+type HeadersObj = Record<string, string> | ApiHeaders;
+type ErrorObj = FetchError;
+type ErrorInterceptor = (error: ErrorObj) => ErrorObj | Promise<ErrorObj>;
+type InterceptorType = 'request' | 'response';
+
+type RawResponseReader = {
+    id: number;
+    rawResponse?: any;
+    headers?: HeadersObj;
+    ok: boolean;
+};
+
+type RequestParams = Record<string, string | number | boolean>;
+type RequestHeaders = Record<string, string>;
+type RequestConfig = {
+    timeout?: number;
+    params?: RequestParams;
+    headers?: RequestHeaders;
+    userAgent?: string;
+    fetch?: Fetch;
+};
+type ApiConfig = {
+    domain?: string;
+    accessToken: string;
+};
+type ApiClientInitConfig = ApiConfig & RequestConfig;
+type ApiClientConfig = Partial<ApiClientInitConfig>;
+type Method = 'GET' | 'DELETE' | 'POST' | 'PUT' | 'PATCH';
+declare class ApiClient {
+    #private;
+    static create(options: ApiClientInitConfig): ApiClient;
+    private constructor();
+    get interceptors(): InterceptorManager;
+    get requestHeaders(): RequestHeaders;
+    config(config: ApiClientConfig): this;
+    userAgent(userAgent: string): this;
+    request(method: Method, path: string, body?: any, options?: ApiClientConfig): Promise<FetchResponse>;
+    private customHeaders;
+}
+
+type Nullable<T> = T | null;
+type CreateArrayWithLengthX<LENGTH extends number, ACC extends unknown[] = []> = ACC['length'] extends LENGTH ? ACC : CreateArrayWithLengthX<LENGTH, [...ACC, 1]>;
+type NumericNumberRange<START_ARR extends number[], END extends number, ACC extends number = never> = START_ARR['length'] extends END ? ACC | END : NumericNumberRange<[...START_ARR, 1], END, ACC | START_ARR['length']>;
+type PositiveNumberRange<MAX extends number> = NumericNumberRange<CreateArrayWithLengthX<1>, MAX>;
+type StringKey<T> = Extract<keyof T, string>;
+
+type QueryResType<T extends Resource> = T['type'];
+type QueryInclude = string[];
+type QueryResourceFields<R extends ResourceTypeLock> = keyof ResourceFields[R];
+type QueryArrayFields<R extends Resource> = Array<QueryResourceFields<QueryResType<R>>>;
+type QueryRecordFields = {
+    [key in keyof ResourceFields]?: Array<(QueryResourceFields<key>)>;
+};
+interface QueryParamsRetrieve<R extends Resource = Resource> {
+    include?: QueryInclude;
+    fields?: QueryArrayFields<R> | QueryRecordFields;
+}
+type QuerySortType = 'asc' | 'desc';
+type QueryResourceSortable<R extends Resource> = ResourceSortFields[QueryResType<R>];
+type QueryResourceSortableFields<R extends Resource> = StringKey<QueryResourceSortable<R>>;
+type QueryArraySortable<R extends Resource> = Array<QueryResourceSortableFields<R> | `-${QueryResourceSortableFields<R>}`>;
+type QueryRecordSortable<R extends Resource> = Partial<Record<keyof QueryResourceSortable<R>, QuerySortType>>;
+type QueryFilter = Record<string, string | number | boolean | object | Array<string | number>>;
+type QueryPageNumber = number;
+type QueryPageSize = PositiveNumberRange<25>;
+interface QueryParamsList<R extends Resource = Resource> extends QueryParamsRetrieve<R> {
+    sort?: QueryArraySortable<R> | QueryRecordSortable<R>;
+    filters?: QueryFilter;
+    pageNumber?: QueryPageNumber;
+    pageSize?: QueryPageSize;
+}
+type QueryParams<R extends Resource> = QueryParamsRetrieve<R> | QueryParamsList<R>;
+
+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?: Nullable<string>;
+    reference_origin?: Nullable<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;
+}
+
+type ResourceSort = Pick<Resource, 'id' | 'reference' | 'reference_origin' | 'created_at' | 'updated_at'>;
+type ResourceAdapterConfig = {};
+type ResourcesInitConfig = ResourceAdapterConfig & ApiClientInitConfig;
+type ResourcesConfig = Partial<ResourcesInitConfig>;
+declare class ResourceAdapter {
+    #private;
+    constructor(config: ResourcesInitConfig);
+    private localConfig;
+    config(config: ResourcesConfig): this;
+    get client(): Readonly<ApiClient>;
+    retrieve<R extends Resource>(resource: ResourceId | ResourceType, 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<R>, 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<R>, options?: ResourcesConfig): Promise<R | ListResponse<R>>;
+    action(cmd: Extract<Method, 'POST' | 'PATCH'>, path: string, payload?: any, options?: ResourcesConfig): Promise<void>;
+}
+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;
+    protected relationshipOneToOne<RR extends ResourceRel>(id: string | ResourceId | null): RR;
+    protected relationshipOneToMany<RR extends ResourceRel>(...ids: string[]): RR[];
+    abstract type(): ResourceTypeLock;
+    parse(resource: string): 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>;
+}
+
+type VersionType = 'versions';
+type VersionRel = ResourceRel & {
+    type: VersionType;
+};
+type VersionSort = Pick<Version, 'id'> & ResourceSort;
+interface Version extends Resource {
+    readonly type: VersionType;
+    resource_type: string;
+    resource_id: string;
+    event: string;
+    changes: Record<string, any>;
+    who: Record<string, any>;
+}
+declare class Versions extends ApiResource<Version> {
+    static readonly TYPE: VersionType;
+    isVersion(resource: any): resource is Version;
+    relationship(id: string | ResourceId | null): VersionRel;
+    relationshipToMany(...ids: string[]): VersionRel[];
+    type(): VersionType;
+}
+
+type PermissionType = 'permissions';
+type PermissionRel = ResourceRel & {
+    type: PermissionType;
+};
+type RoleRel$4 = ResourceRel & {
+    type: RoleType;
+};
+type PermissionSort = Pick<Permission, 'id'> & ResourceSort;
+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>;
+    organization?: Nullable<Organization>;
+    role?: Nullable<Role>;
+    versions?: Nullable<Version[]>;
+}
+interface PermissionCreate extends ResourceCreate {
+    can_create: boolean;
+    can_read: boolean;
+    can_update: boolean;
+    can_destroy: boolean;
+    subject: string;
+    role: RoleRel$4;
+}
+interface PermissionUpdate extends ResourceUpdate {
+    can_create?: Nullable<boolean>;
+    can_read?: Nullable<boolean>;
+    can_update?: Nullable<boolean>;
+    can_destroy?: Nullable<boolean>;
+}
+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<Organization>, options?: ResourcesConfig): Promise<Organization>;
+    role(permissionId: string | Permission, params?: QueryParamsRetrieve<Role>, options?: ResourcesConfig): Promise<Role>;
+    versions(permissionId: string | Permission, params?: QueryParamsList<Version>, options?: ResourcesConfig): Promise<ListResponse<Version>>;
+    isPermission(resource: any): resource is Permission;
+    relationship(id: string | ResourceId | null): PermissionRel;
+    relationshipToMany(...ids: string[]): PermissionRel[];
+    type(): PermissionType;
+}
+
+type RoleType = 'roles';
+type RoleRel$3 = ResourceRel & {
+    type: RoleType;
+};
+type OrganizationRel$4 = ResourceRel & {
+    type: OrganizationType;
+};
+type RoleSort = Pick<Role, 'id'> & ResourceSort;
+interface Role extends Resource {
+    readonly type: RoleType;
+    name: string;
+    kind: string;
+    organization?: Nullable<Organization>;
+    permissions?: Nullable<Permission[]>;
+    memberships?: Nullable<Membership[]>;
+    api_credentials?: Nullable<ApiCredential[]>;
+    versions?: Nullable<Version[]>;
+}
+interface RoleCreate extends ResourceCreate {
+    name: string;
+    organization: OrganizationRel$4;
+}
+interface RoleUpdate extends ResourceUpdate {
+    name?: Nullable<string>;
+}
+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<Organization>, options?: ResourcesConfig): Promise<Organization>;
+    permissions(roleId: string | Role, params?: QueryParamsList<Permission>, options?: ResourcesConfig): Promise<ListResponse<Permission>>;
+    memberships(roleId: string | Role, params?: QueryParamsList<Membership>, options?: ResourcesConfig): Promise<ListResponse<Membership>>;
+    api_credentials(roleId: string | Role, params?: QueryParamsList<ApiCredential>, options?: ResourcesConfig): Promise<ListResponse<ApiCredential>>;
+    versions(roleId: string | Role, params?: QueryParamsList<Version>, options?: ResourcesConfig): Promise<ListResponse<Version>>;
+    isRole(resource: any): resource is Role;
+    relationship(id: string | ResourceId | null): RoleRel$3;
+    relationshipToMany(...ids: string[]): RoleRel$3[];
+    type(): RoleType;
+}
+
+type ApplicationMembershipType = 'application_memberships';
+type ApplicationMembershipRel$1 = ResourceRel & {
+    type: ApplicationMembershipType;
+};
+type ApiCredentialRel$1 = ResourceRel & {
+    type: ApiCredentialType;
+};
+type MembershipRel$1 = ResourceRel & {
+    type: MembershipType;
+};
+type OrganizationRel$3 = ResourceRel & {
+    type: OrganizationType;
+};
+type RoleRel$2 = ResourceRel & {
+    type: RoleType;
+};
+type ApplicationMembershipSort = Pick<ApplicationMembership, 'id'> & ResourceSort;
+interface ApplicationMembership extends Resource {
+    readonly type: ApplicationMembershipType;
+    filters?: Nullable<Record<string, any>>;
+    api_credential?: Nullable<ApiCredential>;
+    membership?: Nullable<Membership>;
+    organization?: Nullable<Organization>;
+    role?: Nullable<Role>;
+}
+interface ApplicationMembershipCreate extends ResourceCreate {
+    filters?: Nullable<Record<string, any>>;
+    api_credential: ApiCredentialRel$1;
+    membership: MembershipRel$1;
+    organization: OrganizationRel$3;
+    role: RoleRel$2;
+}
+interface ApplicationMembershipUpdate extends ResourceUpdate {
+    filters?: Nullable<Record<string, any>>;
+    role?: Nullable<RoleRel$2>;
+}
+declare class ApplicationMemberships extends ApiResource<ApplicationMembership> {
+    static readonly TYPE: ApplicationMembershipType;
+    create(resource: ApplicationMembershipCreate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<ApplicationMembership>;
+    update(resource: ApplicationMembershipUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<ApplicationMembership>;
+    delete(id: string | ResourceId, options?: ResourcesConfig): Promise<void>;
+    api_credential(applicationMembershipId: string | ApplicationMembership, params?: QueryParamsRetrieve<ApiCredential>, options?: ResourcesConfig): Promise<ApiCredential>;
+    membership(applicationMembershipId: string | ApplicationMembership, params?: QueryParamsRetrieve<Membership>, options?: ResourcesConfig): Promise<Membership>;
+    organization(applicationMembershipId: string | ApplicationMembership, params?: QueryParamsRetrieve<Organization>, options?: ResourcesConfig): Promise<Organization>;
+    role(applicationMembershipId: string | ApplicationMembership, params?: QueryParamsRetrieve<Role>, options?: ResourcesConfig): Promise<Role>;
+    isApplicationMembership(resource: any): resource is ApplicationMembership;
+    relationship(id: string | ResourceId | null): ApplicationMembershipRel$1;
+    relationshipToMany(...ids: string[]): ApplicationMembershipRel$1[];
+    type(): ApplicationMembershipType;
+}
+
+type MembershipType = 'memberships';
+type MembershipRel = ResourceRel & {
+    type: MembershipType;
+};
+type OrganizationRel$2 = ResourceRel & {
+    type: OrganizationType;
+};
+type RoleRel$1 = ResourceRel & {
+    type: RoleType;
+};
+type ApplicationMembershipRel = ResourceRel & {
+    type: ApplicationMembershipType;
+};
+type MembershipSort = Pick<Membership, 'id'> & ResourceSort;
+interface Membership extends Resource {
+    readonly type: MembershipType;
+    user_email: string;
+    user_first_name: string;
+    user_last_name: string;
+    status: 'pending' | 'active';
+    owner: boolean;
+    organization?: Nullable<Organization>;
+    role?: Nullable<Role>;
+    application_memberships?: Nullable<ApplicationMembership[]>;
+    versions?: Nullable<Version[]>;
+}
+interface MembershipCreate extends ResourceCreate {
+    user_email: string;
+    organization: OrganizationRel$2;
+    role: RoleRel$1;
+    application_memberships?: Nullable<ApplicationMembershipRel[]>;
+}
+interface MembershipUpdate extends ResourceUpdate {
+    role?: Nullable<RoleRel$1>;
+    application_memberships?: Nullable<ApplicationMembershipRel[]>;
+}
+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>;
+    resend(membershipId: string | Membership, options?: ResourcesConfig): Promise<void>;
+    organization(membershipId: string | Membership, params?: QueryParamsRetrieve<Organization>, options?: ResourcesConfig): Promise<Organization>;
+    role(membershipId: string | Membership, params?: QueryParamsRetrieve<Role>, options?: ResourcesConfig): Promise<Role>;
+    application_memberships(membershipId: string | Membership, params?: QueryParamsList<ApplicationMembership>, options?: ResourcesConfig): Promise<ListResponse<ApplicationMembership>>;
+    versions(membershipId: string | Membership, params?: QueryParamsList<Version>, options?: ResourcesConfig): Promise<ListResponse<Version>>;
+    isMembership(resource: any): resource is Membership;
+    relationship(id: string | ResourceId | null): MembershipRel;
+    relationshipToMany(...ids: string[]): MembershipRel[];
+    type(): MembershipType;
+}
+
+type OrganizationType = 'organizations';
+type OrganizationRel$1 = ResourceRel & {
+    type: OrganizationType;
+};
+type OrganizationSort = Pick<Organization, 'id'> & ResourceSort;
+interface Organization extends Resource {
+    readonly type: OrganizationType;
+    name: string;
+    slug: string;
+    domain: string;
+    config?: Nullable<Record<string, any>>;
+    support_phone?: Nullable<string>;
+    support_email?: Nullable<string>;
+    logo_url?: Nullable<string>;
+    favicon_url?: Nullable<string>;
+    primary_color?: Nullable<string>;
+    contrast_color?: Nullable<string>;
+    gtm_id?: Nullable<string>;
+    gtm_id_test?: Nullable<string>;
+    discount_disabled?: Nullable<boolean>;
+    account_disabled?: Nullable<boolean>;
+    acceptance_disabled?: Nullable<boolean>;
+    max_concurrent_promotions: number;
+    max_concurrent_imports: number;
+    region?: Nullable<string>;
+    can_switch_live: boolean;
+    subscription_info: Record<string, any>;
+    memberships?: Nullable<Membership[]>;
+    roles?: Nullable<Role[]>;
+    permissions?: Nullable<Permission[]>;
+    api_credentials?: Nullable<ApiCredential[]>;
+}
+interface OrganizationCreate extends ResourceCreate {
+    name: string;
+    config?: Nullable<Record<string, any>>;
+    support_phone?: Nullable<string>;
+    support_email?: Nullable<string>;
+    logo_url?: Nullable<string>;
+    favicon_url?: Nullable<string>;
+    primary_color?: Nullable<string>;
+    contrast_color?: Nullable<string>;
+    gtm_id?: Nullable<string>;
+    gtm_id_test?: Nullable<string>;
+    discount_disabled?: Nullable<boolean>;
+    account_disabled?: Nullable<boolean>;
+    acceptance_disabled?: Nullable<boolean>;
+    region?: Nullable<string>;
+}
+interface OrganizationUpdate extends ResourceUpdate {
+    name?: Nullable<string>;
+    config?: Nullable<Record<string, any>>;
+    support_phone?: Nullable<string>;
+    support_email?: Nullable<string>;
+    logo_url?: Nullable<string>;
+    favicon_url?: Nullable<string>;
+    primary_color?: Nullable<string>;
+    contrast_color?: Nullable<string>;
+    gtm_id?: Nullable<string>;
+    gtm_id_test?: Nullable<string>;
+    discount_disabled?: Nullable<boolean>;
+    account_disabled?: Nullable<boolean>;
+    acceptance_disabled?: Nullable<boolean>;
+}
+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>;
+    transfer_ownership(organizationId: string | Organization, payload: TransferOwnershipDataType, options?: ResourcesConfig): Promise<void>;
+    memberships(organizationId: string | Organization, params?: QueryParamsList<Membership>, options?: ResourcesConfig): Promise<ListResponse<Membership>>;
+    roles(organizationId: string | Organization, params?: QueryParamsList<Role>, options?: ResourcesConfig): Promise<ListResponse<Role>>;
+    permissions(organizationId: string | Organization, params?: QueryParamsList<Permission>, options?: ResourcesConfig): Promise<ListResponse<Permission>>;
+    api_credentials(organizationId: string | Organization, params?: QueryParamsList<ApiCredential>, options?: ResourcesConfig): Promise<ListResponse<ApiCredential>>;
+    isOrganization(resource: any): resource is Organization;
+    relationship(id: string | ResourceId | null): OrganizationRel$1;
+    relationshipToMany(...ids: string[]): OrganizationRel$1[];
+    type(): OrganizationType;
+}
+
+type TransferOwnershipDataType = {
+    type: 'organizations';
+    id: string;
+    new_owner_email: string;
+};
+
+type ApiCredentialType = 'api_credentials';
+type ApiCredentialRel = ResourceRel & {
+    type: ApiCredentialType;
+};
+type OrganizationRel = ResourceRel & {
+    type: OrganizationType;
+};
+type RoleRel = ResourceRel & {
+    type: RoleType;
+};
+type ApiCredentialSort = Pick<ApiCredential, 'id' | 'mode'> & ResourceSort;
+interface ApiCredential extends Resource {
+    readonly type: ApiCredentialType;
+    name: string;
+    kind: string;
+    confidential: boolean;
+    redirect_uri?: Nullable<string>;
+    client_id: string;
+    client_secret: string;
+    scopes: string;
+    expires_in?: Nullable<number>;
+    mode?: Nullable<string>;
+    custom?: Nullable<boolean>;
+    organization?: Nullable<Organization>;
+    role?: Nullable<Role>;
+}
+interface ApiCredentialCreate extends ResourceCreate {
+    name: string;
+    kind: string;
+    redirect_uri?: Nullable<string>;
+    expires_in?: Nullable<number>;
+    mode?: Nullable<string>;
+    custom?: Nullable<boolean>;
+    organization: OrganizationRel;
+    role?: Nullable<RoleRel>;
+}
+interface ApiCredentialUpdate extends ResourceUpdate {
+    name?: Nullable<string>;
+    redirect_uri?: Nullable<string>;
+    expires_in?: Nullable<number>;
+    role?: Nullable<RoleRel>;
+}
+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<Organization>, options?: ResourcesConfig): Promise<Organization>;
+    role(apiCredentialId: string | ApiCredential, params?: QueryParamsRetrieve<Role>, options?: ResourcesConfig): Promise<Role>;
+    isApiCredential(resource: any): resource is ApiCredential;
+    relationship(id: string | ResourceId | null): ApiCredentialRel;
+    relationshipToMany(...ids: string[]): ApiCredentialRel[];
+    type(): ApiCredentialType;
+}
+
+type UserType = 'user';
+type UserRel = ResourceRel & {
+    type: UserType;
+};
+type UserSort = Pick<User, 'id'> & ResourceSort;
+interface User extends Resource {
+    readonly type: UserType;
+    email: string;
+    first_name: string;
+    last_name: string;
+    time_zone?: Nullable<string>;
+    otp_required_for_login: boolean;
+}
+interface UserUpdate extends ResourceUpdate {
+    email?: Nullable<string>;
+    first_name?: Nullable<string>;
+    last_name?: Nullable<string>;
+    time_zone?: Nullable<string>;
+}
+declare class Users extends ApiSingleton<User> {
+    static readonly TYPE: UserType;
+    update(resource: UserUpdate, params?: QueryParamsRetrieve, options?: ResourcesConfig): Promise<User>;
+    isUser(resource: any): resource is User;
+    relationship(id: string | ResourceId | null): UserRel;
+    relationshipToMany(...ids: string[]): UserRel[];
+    type(): UserType;
+}
+
+type ResourceTypeLock = 'api_credentials' | 'application_memberships' | 'memberships' | 'organizations' | 'permissions' | 'roles' | 'user' | 'versions';
+type ResourceFields = {
+    api_credentials: ApiCredential;
+    application_memberships: ApplicationMembership;
+    memberships: Membership;
+    organizations: Organization;
+    permissions: Permission;
+    roles: Role;
+    user: User;
+    versions: Version;
+};
+type ResourceSortFields = {
+    api_credentials: ApiCredentialSort;
+    application_memberships: ApplicationMembershipSort;
+    memberships: MembershipSort;
+    organizations: OrganizationSort;
+    permissions: PermissionSort;
+    roles: RoleSort;
+    user: UserSort;
+    versions: VersionSort;
+};
+
+declare enum ErrorType {
+    CLIENT = "client",
+    REQUEST = "request",
+    RESPONSE = "response",
+    CANCEL = "cancel",
+    PARSE = "parse",
+    TIMEOUT = "timeout"
+}
+declare class SdkError extends Error {
+    static NAME: string;
+    static isSdkError(error: any): error is SdkError;
+    type: ErrorType;
+    code?: string;
+    source?: Error;
+    constructor(error: {
+        message: string;
+        type?: ErrorType;
+    });
+}
+declare class ApiError extends SdkError {
+    static NAME: string;
+    static isApiError(error: any): error is ApiError;
+    errors: any[];
+    status?: number;
+    statusText?: string;
+    constructor(error: SdkError);
+    first(): any;
+}
+
+type SdkConfig = {};
+type CommerceLayerInitConfig = SdkConfig & ResourcesInitConfig;
+type CommerceLayerConfig = Partial<CommerceLayerInitConfig>;
+declare class CommerceLayerProvisioningClient {
+    #private;
+    readonly openApiSchemaVersion = "1.0.4";
+    constructor(config: CommerceLayerInitConfig);
+    get api_credentials(): ApiCredentials;
+    get application_memberships(): ApplicationMemberships;
+    get memberships(): Memberships;
+    get organizations(): Organizations;
+    get permissions(): Permissions;
+    get roles(): Roles;
+    get user(): Users;
+    get versions(): Versions;
+    private get interceptors();
+    private localConfig;
+    config(config: CommerceLayerConfig): this;
+    resources(): readonly string[];
+    singletons(): readonly string[];
+    isSingleton(resource: ResourceTypeLock): boolean;
+    isApiError(error: any): error is ApiError;
+    addRequestInterceptor(onSuccess?: RequestInterceptor, onFailure?: ErrorInterceptor): number;
+    addResponseInterceptor(onSuccess?: ResponseInterceptor, onFailure?: ErrorInterceptor): number;
+    removeInterceptor(type: InterceptorType, id?: number): void;
+    addRawResponseReader(options?: {
+        headers: boolean;
+    }): RawResponseReader;
+    removeRawResponseReader(reader?: number | RawResponseReader): void;
+}
+declare const CommerceLayerProvisioning: (config: CommerceLayerInitConfig) => CommerceLayerProvisioningClient;
+
+declare const CommerceLayerProvisioningStatic: {
+    resources: (sort?: boolean) => readonly string[];
+    singletons: (sort?: boolean) => readonly string[];
+    isSingleton: (resource: ResourceTypeLock) => boolean;
+    isSdkError: (error: unknown) => error is SdkError;
+    isApiError: (error: unknown) => error is ApiError;
+    init: (config: CommerceLayerInitConfig) => CommerceLayerProvisioningClient;
+    readonly schemaVersion: string;
+};
+
+export { type ApiCredential, type ApiCredentialCreate, type ApiCredentialSort, type ApiCredentialUpdate, ApiError, type ApplicationMembership, type ApplicationMembershipCreate, type ApplicationMembershipSort, type ApplicationMembershipUpdate, CommerceLayerProvisioning, CommerceLayerProvisioningClient, CommerceLayerProvisioningStatic, type ErrorObj, ErrorType, type HeadersObj, type Membership, type MembershipCreate, type MembershipSort, type MembershipUpdate, type Organization, type OrganizationCreate, type OrganizationSort, type OrganizationUpdate, type Permission, type PermissionCreate, type PermissionSort, type PermissionUpdate, type QueryParams, type QueryParamsList, type QueryParamsRetrieve, type RequestObj, type ResponseObj, type Role, type RoleCreate, type RoleSort, type RoleUpdate, SdkError, type User, type UserSort, type UserUpdate, type Version, type VersionSort, CommerceLayerProvisioning as default };