@commercetools/ts-client 0.0.0-beta.0

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

@@ -0,0 +1,33 @@
+import { Client, AuthMiddlewareOptions, CorrelationIdMiddlewareOptions, Credentials, ExistingTokenMiddlewareOptions, HttpMiddlewareOptions, HttpUserAgentOptions, Middleware, PasswordAuthMiddlewareOptions, QueueMiddlewareOptions, RefreshAuthMiddlewareOptions, LoggerMiddlewareOptions, RetryMiddlewareOptions, ErrorMiddlewareOptions } from '../types/types';
+export default class ClientBuilder {
+    private projectKey;
+    private authMiddleware;
+    private httpMiddleware;
+    private userAgentMiddleware;
+    private correlationIdMiddleware;
+    private loggerMiddleware;
+    private queueMiddleware;
+    private retryMiddleware;
+    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;
+    withRetryMiddleware(options: RetryMiddlewareOptions): 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,6 @@
+import { ClientResult, ClientRequest, ClientOptions, ProcessFn, ProcessOptions } from '../types/types';
+export declare function process(request: ClientRequest, fn: ProcessFn, processOpt?: ProcessOptions): Promise<Array<ClientRequest>>;
+export default function createClient(middlewares: ClientOptions): {
+    process: typeof process;
+    execute(request: ClientRequest): Promise<ClientResult>;
+};

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

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

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

@@ -0,0 +1,12 @@
+export { ClientBuilder, createClient, Process } from './client';
+export { createAuthMiddlewareForAnonymousSessionFlow } from './middleware';
+export { createAuthMiddlewareForClientCredentialsFlow } from './middleware';
+export { createAuthMiddlewareForExistingTokenFlow } from './middleware';
+export { createAuthMiddlewareForPasswordFlow } from './middleware';
+export { createAuthMiddlewareForRefreshTokenFlow } from './middleware';
+export { createCorrelationIdMiddleware } from './middleware';
+export { createHttpMiddleware } from './middleware';
+export { createLoggerMiddleware } from './middleware';
+export { createQueueMiddleware } from './middleware';
+export { 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 { Middleware, AuthMiddlewareOptions } 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 { IBuiltRequestParams, AuthMiddlewareOptions, RefreshAuthMiddlewareOptions, PasswordAuthMiddlewareOptions } 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 { Middleware, AuthMiddlewareOptions } 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 { Middleware, ExistingTokenMiddlewareOptions } 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 createAuthMiddlewareForPasswordFlow from './password-flow';
+import createAuthMiddlewareForAnonymousSessionFlow from './anonymous-session-flow';
+import createAuthMiddlewareForClientCredentialsFlow from './client-credentials-flow';
+import createAuthMiddlewareForRefreshTokenFlow from './refresh-token-flow';
+import createAuthMiddlewareForExistingTokenFlow from './existing-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 { Middleware, CorrelationIdMiddlewareOptions } 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 { Middleware, ErrorMiddlewareOptions } 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 { Middleware, HttpMiddlewareOptions } 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 { Middleware, LoggerMiddlewareOptions } 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-retry-middleware.d.ts

@@ -0,0 +1,2 @@
+import { Middleware, RetryMiddlewareOptions } from '../types/types';
+export default function createRetryMiddleware(options: RetryMiddlewareOptions): 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,9 @@
+export { default as createCorrelationIdMiddleware } from './create-correlation-id-middleware';
+export { default as createHttpMiddleware } from './create-http-middleware';
+export { default as createQueueMiddleware } from './create-queue-middleware';
+export { default as createRetryMiddleware } from './create-retry-middleware';
+export { default as createLoggerMiddleware } from './create-logger-middleware';
+export { default as createUserAgentMiddleware } from './create-user-agent-middleware';
+export { default as createConcurrentModificationMiddleware } from './create-concurrent-modification-middleware';
+export { default as createErrorMiddleware } from './create-error-middleware';
+export { createAuthMiddlewareForPasswordFlow, createAuthMiddlewareForClientCredentialsFlow, createAuthMiddlewareForAnonymousSessionFlow, createAuthMiddlewareForExistingTokenFlow, createAuthMiddlewareForRefreshTokenFlow } from './auth-middleware';

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

@@ -0,0 +1,336 @@
+import { Buffer } from 'buffer/'
+import fetch from 'node-fetch'
+import axios from 'axios'
+
+export type Nullable<T> = T | null
+export type JsonObject<T = unknown> = { [key: string]: T }
+export type MiddlewareRequest = ClientRequest
+
+export type Middleware = (next: Next) => (request: MiddlewareRequest) => Promise<MiddlewareResponse>
+
+export type MiddlewareResponse = {
+  resolve(response: JsonObject): void;
+  reject(error: JsonObject): void;
+  body?: JsonObject;
+  error?: HttpErrorType;
+  statusCode: number;
+  // headers?: JsonObject<string>;
+  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?: JsonObject<QueryParam>
+  headers?: Record<string, any>
+  [key: string]: any
+}
+
+export interface ClientRequest {
+  baseUri?: string
+  uri?: string
+  // headers?: VariableMap
+  headers?: Record<string, any>
+  method: MethodType
+  uriTemplate?: string
+  pathVariables?: VariableMap
+  queryParams?: VariableMap
+  body?: string | Buffer
+  response?: ClientResponse
+  resolve?: (response: JsonObject) => void;
+  reject?: (error: JsonObject) => void;
+  [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
+  statusCode?: number
+  // headers?: JsonObject<string>
+  headers?: Record<string, any>
+  error?: HttpErrorType
+  // request?: Object
+}
+
+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?: fetch | typeof axios
+  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?: any
+}
+
+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: any
+  userOption?: AuthMiddlewareOptions | PasswordAuthMiddlewareOptions
+}
+
+export type AuthMiddlewareBaseOptions = requestBaseOptions & {
+  request: MiddlewareRequest
+  httpClient?: any
+}
+
+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?: any
+}
+
+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
+  includeHeaders?: boolean
+  includeResponseHeaders?: boolean
+  includeOriginalRequest?: boolean
+  includeRequestInErrorResponse?: boolean
+  // maskSensitiveHeaderData?: boolean
+  timeout?: number
+  // enableRetry?: boolean
+  // retryConfig?: {
+  //   maxRetries?: number
+  //   retryDelay?: number
+  //   backoff?: boolean
+  //   maxDelay?: number
+  //   retryCodes?: Array<number | string>,
+  // }
+  httpClient: Function
+  getAbortController?: () => AbortController
+  httpClientOptions?: object
+}
+
+export type HttpOptions = {
+  url: string
+  clientOptions: IClientOptions
+  httpClient: any
+}
+
+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: JsonObject<QueryParam>;
+  headers: Record<string, any>
+  credentialsMode?: CredentialsMode;
+  body?: string | Buffer
+  timeout?: number
+  abortController?: AbortController
+  [k: string | number | symbol]: unknown
+}
+
+export type HttpClientConfig = IClientOptions & {
+  url: string
+  httpClient: Function
+}
+
+export type TResponse = {
+  statusCode: number
+  // headers: JsonObject<QueryParam>
+  headers: Record<string, any>
+  data: {
+    statusCode?: number
+    errors?: any
+    error?: string
+    message: string
+    [k: string | number | symbol]: any
+  }
+  [k: string | number | symbol]: 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 | symbol, Record<string, any>>;
+    count: number;
+  };
+  statusCode: number;
+  headers?: JsonObject<string>;
+}
+
+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/executor.d.ts

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

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,16 @@
+export { default as logger } from './logger';
+export { default as getHeaders } from './headers';
+export { default as isBuffer } from './isBuffer';
+export { default as calculateRetryDelay } from './retryDelay';
+export { default as generate } from './generateID';
+export { default as userAgent } from './userAgent';
+export { default as maskAuthData } from './maskAuthData';
+export { default as calculateExpirationTime } from './tokenExpirationTime';
+export { default as buildTokenCacheKey } from './tokenCacheKey';
+export { default as store } from './tokenStore';
+export { default as mergeAuthHeader } from './mergeAuthHeader';
+export { default as executor } from './executor';
+export * as constants from './constants';
+export { default as sleep } from './sleep';
+export { default as METHODS } from './methods';
+export { validateRetryCodes, validateHttpOptions, validateUserAgentOptions, validateClient, validate } 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/logger.d.ts

@@ -0,0 +1,2 @@
+import { ClientResponse } from '../types/types';
+export default function logger(res: ClientResponse): void;

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

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

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 declare 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/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,30 @@
+import { ClientRequest, HttpMiddlewareOptions, HttpUserAgentOptions, 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 validateUserAgentOptions(options: HttpUserAgentOptions): 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;