@gradientedge/commercetools-utils 4.11.2 → 4.12.1

package/dist/typings/api/CommercetoolsApi.d.ts

@@ -0,0 +1,436 @@
+import { AxiosInstance } from 'axios';
+import { CommercetoolsApiConfig, CommercetoolsRetryConfig } from './types';
+import { CommercetoolsAuth } from '../';
+import { RegionEndpoints } from '../types';
+import type { Cart, CartDiscount, CartDiscountPagedQueryResponse, CartDraft, CartPagedQueryResponse, CartUpdateAction, Category, CategoryDraft, CategoryPagedQueryResponse, CategoryUpdate, Channel, ChannelPagedQueryResponse, Customer, CustomerCreatePasswordResetToken, CustomerDraft, CustomerGroup, CustomerGroupDraft, CustomerGroupPagedQueryResponse, CustomerGroupUpdate, CustomerPagedQueryResponse, CustomerResetPassword, CustomerSignin, CustomerSignInResult, CustomerToken, CustomerUpdate, CustomObject, CustomObjectDraft, DiscountCode, GraphQLRequest, GraphQLResponse, MyCartDraft, MyCustomerDraft, MyPayment, MyPaymentDraft, MyPaymentPagedQueryResponse, MyPaymentUpdate, Order, OrderImportDraft, OrderPagedQueryResponse, OrderUpdate, Payment, PaymentPagedQueryResponse, PaymentUpdate, Product, ProductDraft, ProductProjection, ProductProjectionPagedQueryResponse, ProductsInStorePagedQueryResponse, ProductSelection, ProductSelectionDraft, ProductSelectionPagedQueryResponse, ProductSelectionUpdateAction, ProductType, ProductUpdate, ShippingMethod, ShippingMethodPagedQueryResponse, Store, StoreDraft, StorePagedQueryResponse, StoreUpdate, Type } from '../models';
+export interface FetchOptions<T = Record<string, any>> {
+    path: string;
+    headers?: Record<string, string>;
+    method: 'GET' | 'POST' | 'DELETE' | 'HEAD';
+    params?: Record<string, any>;
+    data?: T;
+    accessToken?: string;
+    correlationId?: string;
+    retry?: CommercetoolsRetryConfig;
+}
+export interface CommonRequestOptions {
+    correlationId?: string;
+    params?: Record<string, any>;
+    retry?: CommercetoolsRetryConfig;
+}
+export interface CommonStoreEnabledRequestOptions extends CommonRequestOptions {
+    storeKey?: string;
+}
+export declare class CommercetoolsApi {
+    readonly auth: CommercetoolsAuth;
+    readonly config: CommercetoolsApiConfig;
+    readonly endpoints: RegionEndpoints;
+    private readonly userAgent;
+    private readonly axios;
+    private readonly retry;
+    constructor(config: CommercetoolsApiConfig);
+    createAxiosInstance(): AxiosInstance;
+    getStoreById(options: CommonRequestOptions & {
+        id: string;
+    }): Promise<Store>;
+    getStoreByKey(options: CommonRequestOptions & {
+        key: string;
+    }): Promise<Store>;
+    queryStores(options?: CommonRequestOptions): Promise<StorePagedQueryResponse>;
+    createStore(options: CommonRequestOptions & {
+        data: StoreDraft;
+    }): Promise<Store>;
+    updateStoreById(options: CommonRequestOptions & {
+        id: string;
+        data: StoreUpdate;
+    }): Promise<Store>;
+    updateStoreByKey(options: CommonRequestOptions & {
+        key: string;
+        data: StoreUpdate;
+    }): Promise<Store>;
+    deleteStoreById(options: CommonRequestOptions & {
+        id: string;
+        version: number;
+    }): Promise<Store>;
+    deleteStoreByKey(options: CommonRequestOptions & {
+        key: string;
+        version: number;
+    }): Promise<Store>;
+    getCategoryById(options: CommonRequestOptions & {
+        id: string;
+    }): Promise<Category>;
+    getCategoryByKey(options: CommonRequestOptions & {
+        key: string;
+    }): Promise<Category>;
+    queryChannels(options?: CommonRequestOptions): Promise<ChannelPagedQueryResponse>;
+    importOrder(options: CommonRequestOptions & {
+        data: OrderImportDraft;
+    }): Promise<Order>;
+    getChannelById(options: CommonRequestOptions & {
+        id: string;
+    }): Promise<Channel>;
+    getCategory(options: CommonRequestOptions & {
+        id?: string;
+        key?: string;
+    }): Promise<Category>;
+    getCategoryBySlug(options: CommonRequestOptions & {
+        slug: string;
+        languageCode?: string;
+        languageCodes?: string[];
+    }): Promise<Category>;
+    queryCategories(options?: CommonRequestOptions): Promise<CategoryPagedQueryResponse>;
+    getCategoryParents(options: CommonRequestOptions & {
+        id?: string;
+        key?: string;
+    }): Promise<Array<Category>>;
+    getProductById(options: CommonRequestOptions & {
+        id: string;
+    }): Promise<Product>;
+    getProductByKey(options: CommonRequestOptions & {
+        key: string;
+    }): Promise<Product>;
+    getProductProjectionById(options: CommonStoreEnabledRequestOptions & {
+        id: string;
+    }): Promise<ProductProjection>;
+    getProductProjectionByKey(options: CommonStoreEnabledRequestOptions & {
+        key: string;
+    }): Promise<ProductProjection>;
+    getProductProjectionBySlug(options: CommonRequestOptions & {
+        slug: string;
+        languageCode?: string;
+        languageCodes?: string[];
+    }): Promise<ProductProjection>;
+    queryProductProjections(options?: CommonRequestOptions): Promise<ProductProjectionPagedQueryResponse>;
+    searchProductProjections(options: CommonStoreEnabledRequestOptions): Promise<ProductProjectionPagedQueryResponse>;
+    getProductSelectionById(options: CommonStoreEnabledRequestOptions & {
+        id: string;
+    }): Promise<ProductSelection>;
+    getProductSelectionByKey(options: CommonStoreEnabledRequestOptions & {
+        key: string;
+    }): Promise<ProductSelection>;
+    queryProductSelections(options?: CommonStoreEnabledRequestOptions): Promise<ProductSelectionPagedQueryResponse>;
+    createProductSelection(options: CommonStoreEnabledRequestOptions & {
+        data: ProductSelectionDraft;
+    }): Promise<ProductSelection>;
+    updateProductSelectionByKey(options: CommonStoreEnabledRequestOptions & {
+        key: string;
+        version: number;
+        actions: ProductSelectionUpdateAction[];
+    }): Promise<ProductSelection>;
+    deleteProductSelectionByKey(options: CommonStoreEnabledRequestOptions & {
+        key: string;
+        version: number;
+    }): Promise<ProductSelection>;
+    queryProductsInStore(options: CommonStoreEnabledRequestOptions): Promise<ProductsInStorePagedQueryResponse>;
+    getCartById(options: CommonStoreEnabledRequestOptions & {
+        id: string;
+    }): Promise<Cart>;
+    queryCarts(options?: CommonStoreEnabledRequestOptions): Promise<CartPagedQueryResponse>;
+    queryMyCarts(options: CommonStoreEnabledRequestOptions & {
+        accessToken: string;
+    }): Promise<CartPagedQueryResponse>;
+    createCart(options: CommonStoreEnabledRequestOptions & {
+        data: CartDraft;
+    }): Promise<Cart>;
+    updateCartById(options: CommonStoreEnabledRequestOptions & {
+        id: string;
+        version: number;
+        actions: CartUpdateAction[];
+    }): Promise<Cart>;
+    getMyActiveCart(options: CommonStoreEnabledRequestOptions & {
+        accessToken: string;
+    }): Promise<Cart>;
+    getMyCartById(options: CommonStoreEnabledRequestOptions & {
+        accessToken: string;
+        cartId: string;
+    }): Promise<Cart>;
+    createMyCart(options: CommonStoreEnabledRequestOptions & {
+        accessToken: string;
+        data: MyCartDraft;
+    }): Promise<Cart>;
+    deleteMyActiveCart(options: CommonStoreEnabledRequestOptions & {
+        accessToken: string;
+    }): Promise<Cart>;
+    deleteMyCartById(options: CommonStoreEnabledRequestOptions & {
+        accessToken: string;
+        cartId: string;
+    }): Promise<Cart>;
+    updateMyActiveCart(options: CommonStoreEnabledRequestOptions & {
+        accessToken: string;
+        actions: CartUpdateAction[];
+    }): Promise<Cart>;
+    createMyOrderFromActiveCart(options: CommonStoreEnabledRequestOptions & {
+        accessToken: string;
+    }): Promise<Order>;
+    deleteCartById(options: CommonStoreEnabledRequestOptions & {
+        id: string;
+        version: number;
+    }): Promise<Cart>;
+    createPayment(options: CommonRequestOptions & {
+        data: MyPaymentDraft;
+    }): Promise<Payment>;
+    deletePaymentById(options: CommonRequestOptions & {
+        id: string;
+        version: number;
+    }): Promise<Payment>;
+    updatePaymentById(options: CommonRequestOptions & {
+        id: string;
+        data: PaymentUpdate;
+    }): Promise<Payment>;
+    getPaymentById(options: CommonRequestOptions & {
+        id: string;
+    }): Promise<Payment>;
+    queryPayments(options: CommonRequestOptions): Promise<PaymentPagedQueryResponse>;
+    createMyPayment(options: CommonRequestOptions & {
+        data: MyPaymentDraft;
+        accessToken: string;
+    }): Promise<MyPayment>;
+    updateMyPaymentById(options: CommonRequestOptions & {
+        id: string;
+        data: MyPaymentUpdate;
+        accessToken: string;
+    }): Promise<MyPayment>;
+    getMyPaymentById(options: CommonRequestOptions & {
+        id: string;
+        accessToken: string;
+    }): Promise<MyPayment>;
+    queryMyPayments(options: CommonRequestOptions & {
+        accessToken: string;
+    }): Promise<MyPaymentPagedQueryResponse>;
+    getMyOrderById(options: CommonStoreEnabledRequestOptions & {
+        id: string;
+        accessToken: string;
+    }): Promise<Order>;
+    queryMyOrders(options: CommonStoreEnabledRequestOptions & {
+        accessToken: string;
+    }): Promise<OrderPagedQueryResponse>;
+    updateOrderById(options: CommonStoreEnabledRequestOptions & {
+        id: string;
+        data: OrderUpdate;
+    }): Promise<Order>;
+    updateOrderByOrderNumber(options: CommonStoreEnabledRequestOptions & {
+        orderNumber: string;
+        data: OrderUpdate;
+    }): Promise<Order>;
+    getOrderById(options: CommonStoreEnabledRequestOptions & {
+        id: string;
+    }): Promise<Order>;
+    getOrderByOrderNumber(options: CommonStoreEnabledRequestOptions & {
+        orderNumber: string;
+    }): Promise<Order>;
+    deleteOrderById(options: CommonStoreEnabledRequestOptions & {
+        id: string;
+        version: number;
+        dataErasure?: boolean;
+    }): Promise<Order>;
+    deleteOrderByOrderNumber(options: CommonStoreEnabledRequestOptions & {
+        orderNo: string;
+        version: number;
+        dataErasure?: boolean;
+    }): Promise<Order>;
+    queryOrders(options: CommonStoreEnabledRequestOptions): Promise<OrderPagedQueryResponse>;
+    createProduct(options: CommonRequestOptions & {
+        data: ProductDraft;
+    }): Promise<Product>;
+    updateProductByKey(options: CommonRequestOptions & {
+        key: string;
+        data: ProductUpdate;
+    }): Promise<Product>;
+    updateProductById(options: CommonRequestOptions & {
+        id: string;
+        data: ProductUpdate;
+    }): Promise<Product>;
+    deleteProductById(options: CommonRequestOptions & {
+        id: string;
+        version: number;
+        unpublish?: boolean;
+    }): Promise<Product>;
+    deleteProductByKey(options: CommonRequestOptions & {
+        key: string;
+        version: number;
+        unpublish?: boolean;
+    }): Promise<Product>;
+    unpublishProductByKey(options: CommonRequestOptions & {
+        key: string;
+        version: number;
+    }): Promise<Product>;
+    unpublishProductById(options: CommonRequestOptions & {
+        id: string;
+        version: number;
+    }): Promise<Product>;
+    createCategory(options: CommonRequestOptions & {
+        data: CategoryDraft;
+    }): Promise<Category>;
+    updateCategoryByKey(options: CommonRequestOptions & {
+        key: string;
+        data: CategoryUpdate;
+    }): Promise<Category>;
+    updateCategoryById(options: CommonRequestOptions & {
+        id: string;
+        data: CategoryUpdate;
+    }): Promise<Category>;
+    deleteCategoryById(options: CommonRequestOptions & {
+        id: string;
+        version: number;
+    }): Promise<Category>;
+    deleteCategoryByKey(options: CommonRequestOptions & {
+        key: string;
+        version: number;
+    }): Promise<Category>;
+    createAccount(options: CommonStoreEnabledRequestOptions & {
+        data: CustomerDraft;
+    }): Promise<CustomerSignInResult>;
+    deleteCustomerById(options: CommonStoreEnabledRequestOptions & {
+        id: string;
+        version: number;
+        dataErasure?: boolean;
+    }): Promise<Customer>;
+    deleteCustomerByKey(options: CommonStoreEnabledRequestOptions & {
+        key: string;
+        version: number;
+        dataErasure?: boolean;
+    }): Promise<Customer>;
+    createMyAccount(options: CommonStoreEnabledRequestOptions & {
+        accessToken?: string;
+        data: MyCustomerDraft;
+    }): Promise<CustomerSignInResult>;
+    loginMyAccount(options: CommonStoreEnabledRequestOptions & {
+        accessToken?: string;
+        data: CustomerSignin;
+    }): Promise<CustomerSignInResult>;
+    login(options: CommonStoreEnabledRequestOptions & {
+        data: CustomerSignin;
+    }): Promise<CustomerSignInResult>;
+    getMyAccount(options: CommonStoreEnabledRequestOptions & {
+        accessToken: string;
+    }): Promise<Customer>;
+    updateMyAccount(options: CommonStoreEnabledRequestOptions & {
+        accessToken: string;
+        data: CustomerUpdate;
+    }): Promise<Customer>;
+    changeMyPassword(options: CommonStoreEnabledRequestOptions & {
+        accessToken: string;
+        data: {
+            version: number;
+            currentPassword: string;
+            newPassword: string;
+        };
+    }): Promise<Customer>;
+    resetMyPassword(options: CommonStoreEnabledRequestOptions & {
+        accessToken: string;
+        data: CustomerResetPassword;
+    }): Promise<Customer>;
+    getPasswordResetToken(options: CommonStoreEnabledRequestOptions & {
+        data: CustomerCreatePasswordResetToken;
+    }): Promise<CustomerToken>;
+    getCustomerById(options: CommonStoreEnabledRequestOptions & {
+        id: string;
+    }): Promise<Customer>;
+    getCustomerByKey(options: CommonStoreEnabledRequestOptions & {
+        key: string;
+    }): Promise<Customer>;
+    getCustomerByPasswordToken(options: CommonStoreEnabledRequestOptions & {
+        token: string;
+    }): Promise<Customer>;
+    queryCustomers(options: CommonStoreEnabledRequestOptions): Promise<CustomerPagedQueryResponse>;
+    updateCustomerById(options: CommonStoreEnabledRequestOptions & {
+        id: string;
+        data: CustomerUpdate;
+    }): Promise<Customer>;
+    updateCustomerByKey(options: CommonStoreEnabledRequestOptions & {
+        key: string;
+        data: CustomerUpdate;
+    }): Promise<Customer>;
+    getProductTypeById(options: CommonRequestOptions & {
+        id: string;
+    }): Promise<ProductType>;
+    getProductTypeByKey(options: CommonRequestOptions & {
+        key: string;
+    }): Promise<ProductType>;
+    getTypeById(options: CommonRequestOptions & {
+        id: string;
+    }): Promise<Type>;
+    getTypeByKey(options: CommonRequestOptions & {
+        key: string;
+    }): Promise<Type>;
+    getDiscountCodeById(options: CommonRequestOptions & {
+        id: string;
+    }): Promise<DiscountCode>;
+    getCartDiscountById(options: CommonRequestOptions & {
+        id: string;
+    }): Promise<CartDiscount>;
+    getCartDiscountByKey(options: CommonRequestOptions & {
+        key: string;
+    }): Promise<CartDiscount>;
+    queryCartDiscounts(options?: CommonRequestOptions): Promise<CartDiscountPagedQueryResponse>;
+    getCustomObject(options: CommonRequestOptions & {
+        container: string;
+        key: string;
+    }): Promise<CustomObject>;
+    getCustomObjectById(options: CommonRequestOptions & {
+        id: string;
+    }): Promise<CustomObject>;
+    saveCustomObject(options: CommonRequestOptions & {
+        data: CustomObjectDraft;
+    }): Promise<CustomObject>;
+    deleteCustomObject(options: CommonRequestOptions & {
+        container: string;
+        key: string;
+    }): Promise<CustomObject>;
+    getShippingMethodById(options: CommonRequestOptions & {
+        id: string;
+    }): Promise<ShippingMethod>;
+    getShippingMethodByKey(options: CommonRequestOptions & {
+        key: string;
+    }): Promise<ShippingMethod>;
+    getShippingMethodsForLocation(options: CommonRequestOptions & {
+        accessToken?: string;
+        country: string;
+        state?: string;
+        currency?: string;
+    }): Promise<ShippingMethodPagedQueryResponse>;
+    getShippingMethodsForCart(options: CommonStoreEnabledRequestOptions & {
+        accessToken?: string;
+        cartId: string;
+    }): Promise<ShippingMethodPagedQueryResponse>;
+    queryShippingMethods(options?: CommonRequestOptions): Promise<ShippingMethodPagedQueryResponse>;
+    getCustomerGroupById(options: CommonRequestOptions & {
+        id: string;
+    }): Promise<CustomerGroup>;
+    getCustomerGroupByKey(options: CommonRequestOptions & {
+        key: string;
+    }): Promise<CustomerGroup>;
+    queryCustomerGroups(options?: CommonRequestOptions): Promise<CustomerGroupPagedQueryResponse>;
+    createCustomerGroup(options: CommonRequestOptions & {
+        data: CustomerGroupDraft;
+    }): Promise<CustomerGroup>;
+    updateCustomerGroupByKey(options: CommonRequestOptions & {
+        key: string;
+        data: CustomerGroupUpdate;
+    }): Promise<CustomerGroup>;
+    updateCustomerGroupById(options: CommonRequestOptions & {
+        id: string;
+        data: CustomerGroupUpdate;
+    }): Promise<CustomerGroup>;
+    deleteCustomerGroupById(options: CommonRequestOptions & {
+        id: string;
+        version: number;
+    }): Promise<CustomerGroup>;
+    deleteCustomerGroupByKey(options: CommonRequestOptions & {
+        key: string;
+        version: number;
+    }): Promise<CustomerGroup>;
+    graphql(options: CommonRequestOptions & {
+        accessToken?: string;
+        data: GraphQLRequest;
+    }): Promise<GraphQLResponse>;
+    request<T = any, R = any>(options: FetchOptions<T>): Promise<R>;
+    getRetryConfig(methodRetryConfig?: CommercetoolsRetryConfig): CommercetoolsRetryConfig;
+    getRequestOptions(options: FetchOptions): Promise<any>;
+    calculateDelay(retryCount: number, retryConfig?: CommercetoolsRetryConfig): number;
+    isRetryableError(error: any): boolean;
+    extractCommonRequestOptions(options?: CommonRequestOptions): CommonRequestOptions;
+    applyStore(path: string, storeKey: string | undefined | null): string;
+    transformError(lastError: any): any;
+    static validateConfig(config: any): void;
+}

package/dist/{api → typings/api}/index.d.ts

@@ -1,3 +1,2 @@
 export * from './CommercetoolsApi';
 export * from './types';
-//# sourceMappingURL=index.d.ts.map

package/dist/typings/api/types.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import * as https from 'https';
+import { CommercetoolsAuthConfig } from '../auth';
+export interface CommercetoolsApiConfig extends CommercetoolsAuthConfig {
+    retry?: CommercetoolsRetryConfig;
+    httpsAgent?: https.Agent;
+}
+export interface CommercetoolsRetryConfig {
+    delayMs: number;
+    maxRetries: number;
+    jitter?: boolean;
+}

package/dist/typings/auth/CommercetoolsAuth.d.ts

@@ -0,0 +1,22 @@
+import { AnonymousGrantOptions, CommercetoolsAuthConfig, LoginOptions, LogoutOptions, RevokeTokenOptions } from './types';
+import { CommercetoolsGrant } from './CommercetoolsGrant';
+interface Config extends CommercetoolsAuthConfig {
+    clientScopes: string[];
+    refreshIfWithinSecs: number;
+    timeoutMs: number;
+    storeKey?: string;
+}
+export declare class CommercetoolsAuth {
+    readonly config: Config;
+    private grant?;
+    private grantPromise;
+    private api;
+    constructor(config: CommercetoolsAuthConfig);
+    getClientGrant(): Promise<CommercetoolsGrant>;
+    refreshCustomerGrant(refreshToken: string): Promise<CommercetoolsGrant>;
+    login(options: LoginOptions): Promise<CommercetoolsGrant>;
+    getAnonymousGrant(options?: AnonymousGrantOptions): Promise<CommercetoolsGrant>;
+    logout(options: LogoutOptions): Promise<void>;
+    revokeToken(options: RevokeTokenOptions): Promise<void>;
+}
+export {};

package/dist/typings/auth/CommercetoolsAuthApi.d.ts

@@ -0,0 +1,21 @@
+import { CommercetoolsAuthApiConfig, CommercetoolsGrantResponse, LoginOptions, LogoutOptions, RevokeTokenOptions } from './types';
+import { RegionEndpoints } from '../types';
+export declare class CommercetoolsAuthApi {
+    readonly config: CommercetoolsAuthApiConfig;
+    readonly endpoints: RegionEndpoints;
+    private readonly userAgent;
+    constructor(config: CommercetoolsAuthApiConfig);
+    getClientGrant(scopes: string[]): Promise<CommercetoolsGrantResponse>;
+    refreshGrant(refreshToken: string): Promise<CommercetoolsGrantResponse>;
+    login(options: LoginOptions & {
+        scopes: string[];
+    }): Promise<CommercetoolsGrantResponse>;
+    revokeToken(options: RevokeTokenOptions): Promise<void>;
+    logout(options: LogoutOptions): Promise<void>;
+    getAnonymousGrant(options?: {
+        anonymousId?: string;
+        scopes: string[];
+    }): Promise<CommercetoolsGrantResponse>;
+    post(path: string, body: Record<string, any>): Promise<CommercetoolsGrantResponse>;
+    applyStore(path: string, storeKey: string | undefined | null): string;
+}

package/dist/typings/auth/CommercetoolsGrant.d.ts

@@ -0,0 +1,13 @@
+import { CommercetoolsGrantResponse } from './types';
+export declare class CommercetoolsGrant {
+    accessToken: string;
+    refreshToken?: string;
+    expiresIn: number;
+    expiresAt: Date;
+    scopes: string[];
+    anonymousId?: string;
+    customerId?: string;
+    constructor(data: CommercetoolsGrantResponse);
+    expiresWithin(refreshIfWithinSecs: number): boolean;
+    extractKeyFromScope(key: string, scope: string): string | undefined;
+}

package/dist/{auth → typings/auth}/constants.d.ts

@@ -1,7 +1,3 @@
 import { Region, RegionEndpoints } from '../types';
-/**
- * Commercetools regions and cloud providers - https://docs.commercetools.com/api/general-concepts#hosts
- */
 export declare const REGION_URLS: Record<Region, RegionEndpoints>;
 export declare const INVALID_SCOPES: string[];
-//# sourceMappingURL=constants.d.ts.map

package/dist/{auth → typings/auth}/index.d.ts

@@ -1,4 +1,3 @@
 export * from './CommercetoolsAuth';
 export * from './CommercetoolsGrant';
 export type { CommercetoolsAuthConfig, AnonymousGrantOptions, GrantType, LoginOptions } from './types';
-//# sourceMappingURL=index.d.ts.map

package/dist/typings/auth/scopes.d.ts

@@ -0,0 +1,2 @@
+export declare function scopeArrayToRequestString(scopes: string[], projectKey: string): string;
+export declare function scopeRequestStringToArray(scopes: string): string[];

package/dist/typings/auth/types.d.ts

@@ -0,0 +1,43 @@
+import { CommercetoolsBaseConfig, Region } from '../types';
+export interface CommercetoolsAuthConfig extends CommercetoolsBaseConfig {
+    refreshIfWithinSecs?: number;
+    customerScopes?: string[];
+}
+export interface CommercetoolsAuthApiConfig {
+    projectKey: string;
+    clientId: string;
+    clientSecret: string;
+    region: Region;
+    timeoutMs?: number;
+    systemIdentifier?: string;
+    storeKey?: string;
+}
+export interface CommercetoolsGrantResponse {
+    access_token: string;
+    refresh_token?: string;
+    expires_in: number;
+    scope: string;
+}
+export interface LoginOptions {
+    username: string;
+    password: string;
+    scopes?: string[];
+    storeKey?: string;
+}
+export interface RevokeTokenOptions {
+    tokenType: 'access_token' | 'refresh_token';
+    tokenValue: string;
+}
+export interface LogoutOptions {
+    accessToken: string;
+    refreshToken: string;
+}
+export interface AnonymousGrantOptions {
+    scopes?: string[];
+    anonymousId?: string;
+}
+export declare enum GrantType {
+    CLIENT_CREDENTIALS = "client_credentials",
+    REFRESH_TOKEN = "refresh_token",
+    PASSWORD = "password"
+}

package/dist/{auth → typings/auth}/utils.d.ts

@@ -1,2 +1 @@
 export declare function base64EncodeForBasicAuth(username: string, password: string): string;
-//# sourceMappingURL=utils.d.ts.map

package/dist/typings/constants.d.ts

@@ -0,0 +1 @@
+export declare const DEFAULT_REQUEST_TIMEOUT_MS = 5000;

package/dist/typings/error/CommercetoolsError.d.ts

@@ -0,0 +1,16 @@
+import { AxiosError, AxiosRequestConfig } from 'axios';
+export declare class CommercetoolsError extends Error {
+    readonly data?: any;
+    readonly status: number | undefined;
+    readonly isCommercetoolsError = true;
+    constructor(message: string, data?: any, status?: number);
+    static fromAxiosError(e: AxiosError): CommercetoolsError;
+    static parseRequestData(config: AxiosRequestConfig): any;
+    toJSON(): {
+        status: number | undefined;
+        message: string;
+        data: any;
+        isCommercetoolsError: boolean;
+    };
+    toString(): string;
+}

package/dist/{error → typings/error}/index.d.ts

@@ -1,2 +1 @@
 export * from './CommercetoolsError';
-//# sourceMappingURL=index.d.ts.map

package/dist/typings/index.d.ts

@@ -0,0 +1,6 @@
+export * from './error';
+export * from './auth';
+export * from './api';
+export { Region, RegionEndpoints } from './types';
+export * from './utils';
+export * from './models';