@commercetools/ts-client 0.0.0-beta.9 → 1.1.0

package/dist/declarations/src/client/builder.d.ts

@@ -0,0 +1,31 @@
+import { AuthMiddlewareOptions, Client, CorrelationIdMiddlewareOptions, Credentials, ErrorMiddlewareOptions, ExistingTokenMiddlewareOptions, HttpMiddlewareOptions, HttpUserAgentOptions, LoggerMiddlewareOptions, Middleware, PasswordAuthMiddlewareOptions, QueueMiddlewareOptions, RefreshAuthMiddlewareOptions } from '../types/types';
+export default class ClientBuilder {
+    private projectKey;
+    private authMiddleware;
+    private httpMiddleware;
+    private userAgentMiddleware;
+    private correlationIdMiddleware;
+    private loggerMiddleware;
+    private queueMiddleware;
+    private concurrentMiddleware;
+    private errorMiddleware;
+    private middlewares;
+    constructor();
+    withProjectKey(key: string): ClientBuilder;
+    defaultClient(baseUri: string, credentials: Credentials, oauthUri?: string, projectKey?: string, scopes?: Array<string>, httpClient?: Function): ClientBuilder;
+    private withAuthMiddleware;
+    withMiddleware(middleware: Middleware): ClientBuilder;
+    withClientCredentialsFlow(options: AuthMiddlewareOptions): ClientBuilder;
+    withPasswordFlow(options: PasswordAuthMiddlewareOptions): ClientBuilder;
+    withAnonymousSessionFlow(options: AuthMiddlewareOptions): ClientBuilder;
+    withRefreshTokenFlow(options: RefreshAuthMiddlewareOptions): ClientBuilder;
+    withExistingTokenFlow(authorization: string, options?: ExistingTokenMiddlewareOptions): ClientBuilder;
+    withHttpMiddleware(options: HttpMiddlewareOptions): ClientBuilder;
+    withUserAgentMiddleware(options?: HttpUserAgentOptions): ClientBuilder;
+    withQueueMiddleware(options?: QueueMiddlewareOptions): ClientBuilder;
+    withLoggerMiddleware(options?: LoggerMiddlewareOptions): this;
+    withCorrelationIdMiddleware(options?: CorrelationIdMiddlewareOptions): ClientBuilder;
+    withConcurrentModificationMiddleware(): ClientBuilder;
+    withErrorMiddleware(options?: ErrorMiddlewareOptions): ClientBuilder;
+    build(): Client;
+}

package/dist/declarations/src/client/client.d.ts

@@ -0,0 +1,3 @@
+import { Client, ClientOptions, ClientRequest, ProcessFn, ProcessOptions } from '../types/types';
+export declare function process(request: ClientRequest, fn: ProcessFn, processOpt?: ProcessOptions): Promise<Array<ClientRequest>>;
+export default function createClient(middlewares: ClientOptions): Client;

package/dist/declarations/src/client/index.d.ts

@@ -0,0 +1,2 @@
+export { default as ClientBuilder } from './builder';
+export { default as createClient, process as Process } from './client';

package/dist/declarations/src/index.d.ts

@@ -0,0 +1,3 @@
+export { ClientBuilder, createClient, Process } from './client';
+export { createAuthMiddlewareForAnonymousSessionFlow, createAuthMiddlewareForClientCredentialsFlow, createAuthMiddlewareForExistingTokenFlow, createAuthMiddlewareForPasswordFlow, createAuthMiddlewareForRefreshTokenFlow, createCorrelationIdMiddleware, createHttpMiddleware, createLoggerMiddleware, createQueueMiddleware, createUserAgentMiddleware, } from './middleware';
+export * from './types/types.d';

package/dist/declarations/src/middleware/auth-middleware/anonymous-session-flow.d.ts

@@ -0,0 +1,2 @@
+import { AuthMiddlewareOptions, Middleware } from '../../types/types';
+export default function createAuthMiddlewareForAnonymousSessionFlow(options: AuthMiddlewareOptions): Middleware;

package/dist/declarations/src/middleware/auth-middleware/auth-request-builder.d.ts

@@ -0,0 +1,24 @@
+import { AuthMiddlewareOptions, IBuiltRequestParams, PasswordAuthMiddlewareOptions, RefreshAuthMiddlewareOptions } from '../../types/types';
+/**
+ *
+ * @param {AuthMiddlewareOptions} options
+ * @returns { IBuiltRequestParams } *
+ */
+export declare function buildRequestForClientCredentialsFlow(options: AuthMiddlewareOptions): IBuiltRequestParams;
+/**
+ *
+ * @param {AuthMiddlewareOptions} options
+ * @returns {IBuiltRequestParams} *
+ */
+export declare function buildRequestForAnonymousSessionFlow(options: AuthMiddlewareOptions): IBuiltRequestParams;
+/**
+ *
+ * @param {RefreshAuthMiddlewareOptions} options
+ * @returns {IBuiltRequestParams}
+ */
+export declare function buildRequestForRefreshTokenFlow(options: RefreshAuthMiddlewareOptions): IBuiltRequestParams;
+/**
+ * @param {PasswordAuthMiddlewareOptions} options
+ * @returns {IBuiltRequestParams}
+ */
+export declare function buildRequestForPasswordFlow(options: PasswordAuthMiddlewareOptions): IBuiltRequestParams;

package/dist/declarations/src/middleware/auth-middleware/auth-request-executor.d.ts

@@ -0,0 +1,2 @@
+import { ClientRequest, executeRequestOptions } from '../../types/types';
+export declare function executeRequest(options: executeRequestOptions): Promise<ClientRequest>;

package/dist/declarations/src/middleware/auth-middleware/client-credentials-flow.d.ts

@@ -0,0 +1,2 @@
+import { AuthMiddlewareOptions, Middleware } from '../../types/types';
+export default function createAuthMiddlewareForClientCredentialsFlow(options: AuthMiddlewareOptions): Middleware;

package/dist/declarations/src/middleware/auth-middleware/existing-token-flow.d.ts

@@ -0,0 +1,2 @@
+import { ExistingTokenMiddlewareOptions, Middleware } from '../../types/types';
+export default function createAuthMiddlewareForExistingTokenFlow(authorization: string, options?: ExistingTokenMiddlewareOptions): Middleware;

package/dist/declarations/src/middleware/auth-middleware/index.d.ts

@@ -0,0 +1,6 @@
+import createAuthMiddlewareForAnonymousSessionFlow from './anonymous-session-flow';
+import createAuthMiddlewareForClientCredentialsFlow from './client-credentials-flow';
+import createAuthMiddlewareForExistingTokenFlow from './existing-token-flow';
+import createAuthMiddlewareForPasswordFlow from './password-flow';
+import createAuthMiddlewareForRefreshTokenFlow from './refresh-token-flow';
+export { createAuthMiddlewareForPasswordFlow, createAuthMiddlewareForAnonymousSessionFlow, createAuthMiddlewareForClientCredentialsFlow, createAuthMiddlewareForRefreshTokenFlow, createAuthMiddlewareForExistingTokenFlow };

package/dist/declarations/src/middleware/auth-middleware/password-flow.d.ts

@@ -0,0 +1,2 @@
+import { Middleware, PasswordAuthMiddlewareOptions } from '../../types/types';
+export default function createAuthMiddlewareForPasswordFlow(options: PasswordAuthMiddlewareOptions): Middleware;

package/dist/declarations/src/middleware/auth-middleware/refresh-token-flow.d.ts

@@ -0,0 +1,2 @@
+import { Middleware, RefreshAuthMiddlewareOptions } from '../../types/types';
+export default function createAuthMiddlewareForRefreshTokenFlow(options: RefreshAuthMiddlewareOptions): Middleware;

package/dist/declarations/src/middleware/create-concurrent-modification-middleware.d.ts

@@ -0,0 +1,2 @@
+import { Middleware } from '../types/types';
+export default function createConcurrentModificationMiddleware(): Middleware;

package/dist/declarations/src/middleware/create-correlation-id-middleware.d.ts

@@ -0,0 +1,2 @@
+import { CorrelationIdMiddlewareOptions, Middleware } from '../types/types';
+export default function createCorrelationIdMiddleware(options?: CorrelationIdMiddlewareOptions): Middleware;

package/dist/declarations/src/middleware/create-error-middleware.d.ts

@@ -0,0 +1,2 @@
+import { ErrorMiddlewareOptions, Middleware } from '../types/types';
+export default function createErrorMiddleware(options?: ErrorMiddlewareOptions): Middleware;

package/dist/declarations/src/middleware/create-http-middleware.d.ts

@@ -0,0 +1,2 @@
+import { HttpMiddlewareOptions, Middleware } from '../types/types';
+export default function createHttpMiddleware(options: HttpMiddlewareOptions): Middleware;

package/dist/declarations/src/middleware/create-logger-middleware.d.ts

@@ -0,0 +1,2 @@
+import { LoggerMiddlewareOptions, Middleware } from '../types/types';
+export default function createLoggerMiddleware(options?: LoggerMiddlewareOptions): Middleware;

package/dist/declarations/src/middleware/create-queue-middleware.d.ts

@@ -0,0 +1,2 @@
+import { Middleware, QueueMiddlewareOptions } from '../types/types';
+export default function createQueueMiddleware({ concurrency, }: QueueMiddlewareOptions): Middleware;

package/dist/declarations/src/middleware/create-user-agent-middleware.d.ts

@@ -0,0 +1,2 @@
+import { HttpUserAgentOptions, Middleware } from '../types/types';
+export default function createUserAgentMiddleware(options?: HttpUserAgentOptions): Middleware;

package/dist/declarations/src/middleware/index.d.ts

@@ -0,0 +1,8 @@
+export { createAuthMiddlewareForAnonymousSessionFlow, createAuthMiddlewareForClientCredentialsFlow, createAuthMiddlewareForExistingTokenFlow, createAuthMiddlewareForPasswordFlow, createAuthMiddlewareForRefreshTokenFlow } from './auth-middleware';
+export { default as createConcurrentModificationMiddleware } from './create-concurrent-modification-middleware';
+export { default as createCorrelationIdMiddleware } from './create-correlation-id-middleware';
+export { default as createErrorMiddleware } from './create-error-middleware';
+export { default as createHttpMiddleware } from './create-http-middleware';
+export { default as createLoggerMiddleware } from './create-logger-middleware';
+export { default as createQueueMiddleware } from './create-queue-middleware';
+export { default as createUserAgentMiddleware } from './create-user-agent-middleware';

package/dist/declarations/src/types/types.d.ts

@@ -0,0 +1,329 @@
+import AbortController from 'abort-controller'
+import { Buffer } from 'buffer/'
+
+export type Nullable<T> = T | null
+export type Keys = string | number | symbol
+export type JsonObject<T = unknown> = { [key in Keys]: T }
+export type MiddlewareRequest = ClientRequest
+export type Optional = { [k in Keys]: any }
+
+export type Middleware = (next: Next) => (request: MiddlewareRequest) => Promise<MiddlewareResponse>
+
+export type MiddlewareResponse<T = unknown> = {
+  resolve: Function;
+  reject: Function;
+  body: T;
+  error?: HttpErrorType;
+  statusCode: number;
+  headers?: Record<string, any>
+  request?: MiddlewareRequest;
+}
+
+export type HttpErrorType = {
+  name?: string
+  message: string
+  code?: number
+  status?: number
+  method: MethodType
+  statusCode: number
+  originalRequest?: ClientRequest
+  body: JsonObject
+  retryCount?: number
+  headers?: Record<string, any>
+  [key: string]: any
+}
+
+export interface ClientRequest {
+  baseUri?: string
+  uri?: string
+  headers?: Record<string, any>
+  method: MethodType
+  uriTemplate?: string
+  pathVariables?: VariableMap
+  queryParams?: VariableMap
+  body?: string | Buffer
+  response?: ClientResponse
+  resolve?: Function;
+  reject?: Function;
+  [key: string]: any
+}
+
+export type Next = (request: MiddlewareRequest) => Promise<MiddlewareResponse>
+
+export type MethodType =
+  | 'GET'
+  | 'HEAD'
+  | 'POST'
+  | 'PUT'
+  | 'PATCH'
+  | 'DELETE'
+  | 'CONNECT'
+  | 'OPTIONS'
+  | 'TRACE'
+
+export type QueryParam =
+  | string
+  | string[]
+  | number
+  | number[]
+  | boolean
+  | boolean[]
+  | undefined
+
+export type VariableMap = {
+  [key: string]: QueryParam
+}
+
+export type ClientResponse<T = any> = {
+  body: T
+  code?: number
+  statusCode?: number
+  headers?: Record<string, any>
+  error?: HttpErrorType
+  retryCount?: number
+}
+
+export type ClientResult = ClientResponse
+export type ClientOptions = { middlewares: Array<Middleware> }
+
+export type Credentials = {
+  clientId: string
+  clientSecret: string
+  anonymousId?: string
+}
+
+export type AuthMiddlewareOptions = {
+  host: string
+  projectKey: string
+  credentials: Credentials
+  scopes?: Array<string>
+  // For internal usage only
+  oauthUri?: string
+  httpClient?: Function
+  tokenCache?: TokenCache
+}
+
+export type TokenCacheOptions = {
+  clientId: string
+  projectKey: string
+  host: string
+}
+
+export type TokenStore = {
+  token: string
+  expirationTime?: number
+  refreshToken?: string
+  tokenCacheKey?: TokenCacheOptions
+}
+
+export type TokenCache = {
+  get: (tokenCacheOptions?: TokenCacheOptions) => TokenStore
+  set: (cache: TokenStore, tokenCacheOptions?: TokenCacheOptions) => void
+}
+
+export type IBuiltRequestParams = {
+  basicAuth: string
+  url: string
+  body: string
+  data?: string
+}
+
+export type RefreshAuthMiddlewareOptions = {
+  host: string
+  projectKey: string
+  credentials: {
+    clientId: string
+    clientSecret: string
+  }
+  refreshToken: string
+  tokenCache?: TokenCache,
+  // For internal usage only
+  oauthUri?: string
+  httpClient?: Function
+}
+
+export type RequestStateStore = {
+  get: () => RequestState
+  set: (requestState: RequestState) => void
+}
+
+/* Request */
+type requestBaseOptions = {
+  url: string
+  body: string
+  basicAuth: string
+  request: MiddlewareRequest
+  tokenCache: TokenCache,
+  requestState: RequestStateStore,
+  pendingTasks: Array<Task>,
+  tokenCacheKey?: TokenCacheOptions,
+}
+
+export type executeRequestOptions = requestBaseOptions & {
+  next: Next
+  httpClient: Function
+  userOption?: AuthMiddlewareOptions | PasswordAuthMiddlewareOptions
+}
+
+export type AuthMiddlewareBaseOptions = requestBaseOptions & {
+  request: MiddlewareRequest
+  httpClient?: Function
+}
+
+export type RequestState = boolean
+
+export type Task = {
+  request: MiddlewareRequest
+  next?: Next
+}
+
+export type UserAuthOptions = {
+  username: string
+  password: string
+}
+
+export type PasswordAuthMiddlewareOptions = {
+  host: string
+  projectKey: string
+  credentials: {
+    clientId: string
+    clientSecret: string
+    user: UserAuthOptions
+  }
+  scopes?: Array<string>
+  tokenCache?: TokenCache,
+  // For internal usage only
+  oauthUri?: string
+  httpClient?: Function
+}
+
+export type TokenInfo = {
+  refresh_token: string
+  access_token: string
+  expires_at: number
+  expires_in: number // since this will always be used to calculate the expiration time, it shouldn't be made optional
+  scope?: string
+  token_type?: string
+}
+
+export type Dispatch = (next: Next) => (request: MiddlewareRequest) => Promise<MiddlewareResponse>
+
+export type CredentialsMode = 'omit' | 'same-origin' | 'include'
+
+export type HttpMiddlewareOptions = {
+  host: string
+  credentialsMode?: CredentialsMode
+  includeResponseHeaders?: boolean
+  includeOriginalRequest?: boolean
+  includeRequestInErrorResponse?: boolean
+  maskSensitiveHeaderData?: boolean
+  timeout?: number
+  enableRetry?: boolean
+  retryConfig?: RetryOptions
+  httpClient: Function
+  getAbortController?: () => AbortController
+  httpClientOptions?: object
+}
+
+export type RetryOptions = RetryMiddlewareOptions
+
+export type HttpOptions = {
+  url: string
+  clientOptions: HttpClientOptions
+  httpClient: Function
+}
+
+export type LogLevel = 'INFO' | 'ERROR'
+
+export type LoggerMiddlewareOptions = {
+  logLevel?: LogLevel
+  maskSensitiveHeaderData?: boolean
+  includeOriginalRequest?: boolean
+  includeResponseHeaders?: boolean
+  includeRequestInErrorResponse?: boolean
+  loggerFn?: (options: MiddlewareResponse) => void
+}
+
+export type RetryMiddlewareOptions = {
+  backoff?: boolean
+  maxRetries?: number
+  retryDelay?: number
+  maxDelay?: typeof Infinity
+  retryCodes?: Array<number | string>
+}
+
+export type CorrelationIdMiddlewareOptions = {
+  generate?: () => string
+}
+
+/* HTTP User Agent */
+export type HttpUserAgentOptions = {
+  name?: string
+  version?: string
+  libraryName?: string
+  libraryVersion?: string
+  contactUrl?: string
+  contactEmail?: string
+  customAgent?: string
+}
+
+export type QueueMiddlewareOptions = {
+  concurrency?: number
+}
+
+export type ExistingTokenMiddlewareOptions = {
+  force: boolean
+}
+
+export type IClientOptions = {
+  method: MethodType;
+  headers: Record<string, any>
+  credentialsMode?: CredentialsMode;
+  body?: string | Buffer
+  timeout?: number
+  abortController?: AbortController
+  includeOriginalRequest?: boolean
+  enableRetry?: boolean
+  retryConfig?: RetryOptions
+  maskSensitiveHeaderData?: boolean
+}
+
+export type HttpClientOptions = IClientOptions & Optional
+
+export type HttpClientConfig = IClientOptions & {
+  url: string
+  httpClient: Function
+}
+
+type TResponse = {
+  data: Record<string, any>
+  message?: string
+  statusCode: number
+  retryCount: number
+  headers: Record<string, any>
+}
+
+export type Client = {
+  execute(request: ClientRequest): Promise<ClientResult>
+  process: (
+    request: ClientRequest,
+    fn: ProcessFn,
+    processOpt?: ProcessOptions
+  ) => Promise<unknown>
+}
+
+export type ProcessFn = (result: ClientResult) => Promise<unknown>
+export type ProcessOptions = { accumulate?: boolean; total?: number }
+export type ErrorMiddlewareOptions = {}
+export type SuccessResult = {
+  body: {
+    results: Record<string | number, Record<string, any>>;
+    count: number;
+  };
+  statusCode: number;
+  headers?: JsonObject<string>;
+}
+
+export type IResponse = Response & { statusCode?: number; data?: object } 
+
+export type executeRequest = (request: ClientRequest) => Promise<ClientResponse>

package/dist/declarations/src/utils/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const HEADERS_CONTENT_TYPES: string[];
+export declare const CONCURRENCT_REQUEST = 20;
+export declare const CTP_API_URL = "https://api.europe-west1.gcp.commercetools.com";
+export declare const CTP_AUTH_URL = "https://auth.europe-west1.gcp.commercetools.com";
+export declare const DEFAULT_HEADERS: string[];

package/dist/declarations/src/utils/createError.d.ts

@@ -0,0 +1,8 @@
+import { HttpErrorType } from '../types/types';
+type ErrorType = ErrorArgs & Partial<HttpErrorType>;
+type ErrorArgs = {
+    statusCode: number;
+    message: string;
+};
+declare function createError({ statusCode, message, ...rest }: ErrorType): HttpErrorType;
+export default createError;

package/dist/declarations/src/utils/errors.d.ts

@@ -0,0 +1,10 @@
+export declare function NetworkError(...args: Array<unknown>): void;
+export declare function HttpError(...args: Array<unknown>): void;
+export declare function BadRequest(...args: Array<unknown>): void;
+export declare function Unauthorized(...args: Array<unknown>): void;
+export declare function Forbidden(...args: Array<unknown>): void;
+export declare function NotFound(...args: Array<unknown>): void;
+export declare function ConcurrentModification(...args: Array<unknown>): void;
+export declare function InternalServerError(...args: Array<unknown>): void;
+export declare function ServiceUnavailable(...args: Array<unknown>): void;
+export default function getErrorByCode(code: number): typeof NetworkError;

package/dist/declarations/src/utils/executor.d.ts

@@ -0,0 +1,2 @@
+import { HttpClientConfig, TResponse } from '../types/types';
+export default function executor(request: HttpClientConfig): Promise<TResponse>;

package/dist/declarations/src/utils/generateID.d.ts

@@ -0,0 +1 @@
+export default function generateID(): string;

package/dist/declarations/src/utils/headers.d.ts

@@ -0,0 +1,2 @@
+import { JsonObject } from '../types/types';
+export default function getHeaders(headers: JsonObject<any>): JsonObject<string>;

package/dist/declarations/src/utils/index.d.ts

@@ -0,0 +1,18 @@
+export * as constants from './constants';
+export { default as createError } from './createError';
+export { NetworkError } from './errors';
+export { default as executor } from './executor';
+export { default as generate } from './generateID';
+export { default as getHeaders } from './headers';
+export { default as isBuffer } from './isBuffer';
+export { default as maskAuthData } from './maskAuthData';
+export { default as mergeAuthHeader } from './mergeAuthHeader';
+export { default as METHODS } from './methods';
+export { default as calculateRetryDelay } from './retryDelay';
+export { default as sleep } from './sleep';
+export { default as buildTokenCacheKey } from './tokenCacheKey';
+export { default as calculateExpirationTime } from './tokenExpirationTime';
+export { default as store } from './tokenStore';
+export { default as userAgent } from './userAgent';
+export { stringifyURLString, parseURLString } from './url';
+export { validate, validateClient, validateHttpOptions, validateRetryCodes } from './validate';

package/dist/declarations/src/utils/isBuffer.d.ts

@@ -0,0 +1 @@
+export default function isBuffer(obj: any): boolean;

package/dist/declarations/src/utils/maskAuthData.d.ts

@@ -0,0 +1,2 @@
+import { MiddlewareRequest } from '../types/types';
+export default function maskAuthData(request: MiddlewareRequest): import("../types/types").ClientRequest;

package/dist/declarations/src/utils/mergeAuthHeader.d.ts

@@ -0,0 +1,2 @@
+import { MiddlewareRequest } from '../types/types';
+export default function mergeAuthHeader(token: string, req: MiddlewareRequest): MiddlewareRequest;

package/dist/declarations/src/utils/methods.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string[];
+export default _default;

package/dist/declarations/src/utils/retryDelay.d.ts

@@ -0,0 +1,8 @@
+export type TRetryPolicy = {
+    retryCount: number;
+    retryDelay: number;
+    maxRetries: number;
+    backoff: boolean;
+    maxDelay: number;
+};
+export default function calculateRetryDelay({ retryCount, retryDelay, backoff, maxDelay, }: TRetryPolicy): number;

package/dist/declarations/src/utils/sleep.d.ts

@@ -0,0 +1 @@
+export default function sleep(ms: number): Promise<void>;

package/dist/declarations/src/utils/tokenCacheKey.d.ts

@@ -0,0 +1,2 @@
+import { AuthMiddlewareOptions, TokenCacheOptions } from '../types/types';
+export default function buildTokenCacheKey(options: AuthMiddlewareOptions): TokenCacheOptions;

package/dist/declarations/src/utils/tokenExpirationTime.d.ts

@@ -0,0 +1 @@
+export default function calculateExpirationTime(expiresIn: number): number;

package/dist/declarations/src/utils/tokenStore.d.ts

@@ -0,0 +1,2 @@
+import { TokenCacheOptions } from '../types/types';
+export default function store<T, V, S = TokenCacheOptions>(initVal: T): V;

package/dist/declarations/src/utils/url.d.ts

@@ -0,0 +1,2 @@
+export declare function parseURLString<T>(url: string | URLSearchParams, parser?: <T>(url: string | URLSearchParams) => T): T;
+export declare function stringifyURLString(object: string | Record<string, any> | Array<Array<string>>, stringifier?: (object: string | Record<string, any> | Array<Array<string>> | URLSearchParams) => string): string;

package/dist/declarations/src/utils/userAgent.d.ts

@@ -0,0 +1,2 @@
+import { HttpUserAgentOptions } from '../types/types';
+export default function createUserAgent(options: HttpUserAgentOptions): string;

package/dist/declarations/src/utils/validate.d.ts

@@ -0,0 +1,25 @@
+import { ClientRequest, HttpMiddlewareOptions, Middleware } from '../types/types';
+/**
+ * validate some essential http options
+ * @param options
+ */
+export declare function validateHttpOptions(options: HttpMiddlewareOptions): void;
+/**
+ *
+ * @param retryCodes
+ * @example
+ * const retryCodes = [500, 504, "ETIMEDOUT"]
+ */
+export declare function validateRetryCodes(retryCodes: Array<string | number>): void;
+/**
+ * @param options
+ */
+export declare function validateClient(options: {
+    middlewares: Array<Middleware>;
+}): void;
+/**
+ * @param options
+ */
+export declare function validate(funcName: string, request: ClientRequest, options?: {
+    allowedMethods: Array<string>;
+}): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@commercetools/ts-client",
-  "version": "0.0.0-beta.9",
+  "version": "1.1.0",
   "engines": {
     "node": ">=14"
   },
@@ -33,9 +33,9 @@
     "url": "https://github.com/commercetools/commercetools-sdk-typescript/issues"
   },
   "dependencies": {
+    "abort-controller": "3.0.0",
     "buffer": "^6.0.3",
-    "node-fetch": "^2.6.1",
-    "querystring": "^0.2.1"
+    "node-fetch": "^2.6.1"
   },
   "files": ["dist", "CHANGELOG.md"],
   "author": "Chukwuemeka Ajima <meeky.ae@gmail.com>",
@@ -46,10 +46,9 @@
     "./dist/commercetools-ts-client.esm.js": "./dist/commercetools-ts-client.browser.esm.js"
   },
   "devDependencies": {
-    "abort-controller": "3.0.0",
     "common-tags": "1.8.2",
-    "dotenv": "16.0.2",
-    "jest": "29.0.3",
+    "dotenv": "16.0.3",
+    "jest": "29.5.0",
     "nock": "12.0.3",
     "organize-imports-cli": "0.10.0"
   },