// Type definitions for nock v0.54.0
// Project: https://github.com/pgte/nock
// Definitions by: bonnici <https://github.com/bonnici>
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped

// Imported from: https://github.com/soywiz/typescript-node-definitions/nock.d.ts

export = nock;

declare function nock(host: string, options?: nock.Options): nock.Scope;

declare namespace nock {
    export function cleanAll(): void;

    export function disableNetConnect(): void;
    export function enableNetConnect(): void;
    export function enableNetConnect(regex: RegExp): void;
    export function enableNetConnect(domain: string): void;

    export function load(path: string): Object[];
    export function restore(): void;

    export var recorder: Recorder;

    export interface Scope {
        get(path: string, data?: string): Scope;
        get(path: RegExp, data?: string): Scope;

        post(path: string, data?: string): Scope;
        post(path: string, data?: Object): Scope;
        post(path: string, regex?: RegExp): Scope;
        post(path: RegExp, data?: string): Scope;
        post(path: RegExp, data?: Object): Scope;
        post(path: RegExp, regex?: RegExp): Scope;

        patch(path: string, data?: string): Scope;
        patch(path: string, data?: Object): Scope;
        patch(path: string, regex?: RegExp): Scope;
        patch(path: RegExp, data?: string): Scope;
        patch(path: RegExp, data?: Object): Scope;
        patch(path: RegExp, regex?: RegExp): Scope;

        put(path: string, data?: string): Scope;
        put(path: string, data?: Object): Scope;
        put(path: string, regex?: RegExp): Scope;
        put(path: RegExp, data?: string): Scope;
        put(path: RegExp, data?: Object): Scope;
        put(path: RegExp, regex?: RegExp): Scope;

        head(path: string): Scope;
        head(path: RegExp): Scope;

        delete(path: string, data?: string): Scope;
        delete(path: string, data?: Object): Scope;
        delete(path: string, regex?: RegExp): Scope;
        delete(path: RegExp, data?: string): Scope;
        delete(path: RegExp, data?: Object): Scope;
        delete(path: RegExp, regex?: RegExp): Scope;

        merge(path: string, data?: string): Scope;
        merge(path: string, data?: Object): Scope;
        merge(path: string, regex?: RegExp): Scope;
        merge(path: RegExp, data?: string): Scope;
        merge(path: RegExp, data?: Object): Scope;
        merge(path: RegExp, regex?: RegExp): Scope;

        query(params: any): Scope;
        query(acceptAnyParams: boolean): Scope;

        intercept(path: string, verb: string, body?: string, options?: any): Scope;
        intercept(path: string, verb: string, body?: Object, options?: any): Scope;
        intercept(path: string, verb: string, body?: RegExp, options?: any): Scope;
        intercept(path: RegExp, verb: string, body?: string, options?: any): Scope;
        intercept(path: RegExp, verb: string, body?: Object, options?: any): Scope;
        intercept(path: RegExp, verb: string, body?: RegExp, options?: any): Scope;

        reply(responseCode: number, body?: string, headers?: Object): Scope;
        reply(responseCode: number, body?: Object, headers?: Object): Scope;
        reply(responseCode: number, callback: (uri: string, body: string) => string, headers?: Object): Scope;
        replyWithFile(responseCode: number, fileName: string): Scope;
        replyWithError(errorMessage: string): Scope;

        defaultReplyHeaders(headers: Object): Scope;

        matchHeader(name: string, value: string): Scope;
        matchHeader(name: string, regex: RegExp): Scope;
        matchHeader(name: string, fn: (value: string) => boolean): Scope;

        filteringPath(regex: RegExp, replace: string): Scope;
        filteringPath(fn: (path: string) => string): Scope;
        filteringRequestBody(regex: RegExp, replace: string): Scope;
        filteringRequestBody(fn: (path: string) => string): Scope;

        persist(): Scope;
        log(out: () => void): Scope;

        delay(timeMs: number): Scope;
        delayConnection(timeMs: number): Scope;

        times(repeats: number): Scope;
        once(): Scope;
        twice(): Scope;
        thrice(): Scope;

        done(): void;
        isDone(): boolean;
        restore(): void;
        pendingMocks(): Object[];
    }

    export interface Recorder {
        rec(capture?: boolean): void;
        rec(options?: RecorderOptions): void;
        play(): any[];
    }

    export interface Options {
        allowUnmocked?: boolean;
    }

    export interface RecorderOptions {
        dont_print?: boolean;
        output_objects?: boolean;
        enable_reqheaders_recording?: boolean;
    }
}