nock

currentMode: BackMode;

fixtures: string;

setMode: (mode: BackMode) => void;

(fixtureName: string, nockedFn: (nockDone: () => void) => void): void;

(
    fixtureName: string,
    options: BackOptions,
    nockedFn: (nockDone: () => void) => void
): void;

(fixtureName: string, options?: BackOptions): Promise<{
    nockDone: () => void;
    context: BackContext;
}>;

isLoaded: boolean;

query: InterceptorSurface[];

scopes: Scope[];

assertScopesFinished: () => void;

after?: (scope: Scope) => void;

afterRecord?: (defs: Definition[]) => Definition[] | string;

before?: (def: Definition) => void;

recorder?: RecorderOptions;

[key: string]: DataMatcher;

body?: RequestBodyMatcher;

headers?: ReplyHeaders;

method?: string;

options?: Options;

path: string | RegExp;

port?: number | string;

reqheaders?: Record<string, RequestHeaderMatcher>;

response?: ReplyBody;

scope: string | RegExp;

status?: number;

basicAuth: (options: { user: string; pass?: string }) => this;

delay: {
    (opts: number): this;
    (opts: { head?: number; body?: number }): this;
    (opts: number | { head?: number; body?: number }): this;
};

delayBody: (timeMs: number) => this;

delayConnection: (timeMs: number) => this;

matchHeader: (name: string, value: RequestHeaderMatcher) => this;

once: () => this;

optionally: (flag?: boolean) => this;

query: (matcher: any) => this;

reply: {
    (
        replyFnWithCallback: (
            this: ReplyFnContext,
            uri: string,
            body: Body,
            callback: (
                err: NodeJS.ErrnoException | null,
                result: ReplyFnResult
            ) => void
        ) => void
    ): Scope;
    (
        replyFn: (
            this: ReplyFnContext,
            uri: string,
            body: Body
        ) => ReplyFnResult | Promise<ReplyFnResult>
    ): Scope;
    (
        statusCode: number,
        replyBodyFnWithCallback: (
            this: ReplyFnContext,
            uri: string,
            body: Body,
            callback: (err: any, result: any) => void
        ) => void,
        headers?: ReplyHeaders
    ): Scope;
    (
        statusCode: number,
        replyBodyFn: (this: ReplyFnContext, uri: string, body: Body) => any,
        headers?: ReplyHeaders
    ): Scope;
    (responseCode?: number, body?: Body, headers?: ReplyHeaders): Scope;
};

replyWithError: (errorMessage: string | object) => Scope;

replyWithFile: (
    statusCode: StatusCode,
    fileName: string,
    headers?: ReplyHeaders
) => Scope;

thrice: () => this;

times: (newCounter: number) => this;

twice: () => this;

basePath: string;

body: string;

counter: number;

method: string;

optional: boolean;

path: string;

queries?: string;

statusCode: number;

uri: string;

allowUnmocked?: boolean;

badheaders?: string[];

encodedQueryParams?: boolean;

filteringScope?: { (scope: string): boolean };

reqheaders?: Record<string, RequestHeaderMatcher>;

clear: () => void;

play: () => string[] | Definition[];

rec: (options?: boolean | RecorderOptions) => void;

dont_print?: boolean;

enable_reqheaders_recording?: boolean;

logging?: (content: string) => void;

output_objects?: boolean;

use_separator?: boolean;

req: ClientRequest & {
    headers: Record<string, string>;
};

delete: InterceptFunction;

get: InterceptFunction;

head: InterceptFunction;

intercept: (
    uri: string | RegExp | { (uri: string): boolean },
    method: string,
    requestBody?: RequestBodyMatcher,
    options?: Options
) => Interceptor;

merge: InterceptFunction;

options: InterceptFunction;

patch: InterceptFunction;

post: InterceptFunction;

put: InterceptFunction;

activeMocks: () => string[];

defaultReplyHeaders: (headers: ReplyHeaders) => this;

done: () => void;

filteringPath: {
    (regex: RegExp, replace: string): this;
    (fn: (path: string) => string): this;
};

filteringRequestBody: {
    (regex: RegExp, replace: string): this;
    (fn: (body: string, recordedBody: string) => string): this;
};

isDone: () => boolean;

matchHeader: (name: string, value: RequestHeaderMatcher) => this;

pendingMocks: () => string[];

persist: (flag?: boolean) => this;

replyContentLength: () => this;

replyDate: (d?: Date) => this;