///
///
import { Context, EnvOptions, expect, NockScope, Plugin } from 'fancy-test';
import { Options } from './options';
export declare const test: {
it: {
(expectation: string, cb?: ((context: Context) => any) | undefined): void;
(cb?: ((context: Context) => any) | undefined): void;
};
end: {
(expectation: string, cb?: ((context: Context) => any) | undefined): void;
(cb?: ((context: Context) => any) | undefined): void;
};
add(key: K, cb: (context: Context) => O | Promise): any & {
skip: (arg1?: {} | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
only: (arg1?: {} | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
catch: (arg1?: string | RegExp | ((err: Error) => any) | undefined, arg2?: {
raiseIfNotThrown?: boolean | undefined;
} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
env: (arg1?: {
[k: string]: string | undefined;
} | undefined, arg2?: EnvOptions | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
stub: (arg1?: any, arg2?: string | undefined, arg3?: any, arg4?: {} | undefined) => any & any;
nock: (arg1?: string | undefined, arg2?: ((nock: NockScope) => any) | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
stderr: (arg1?: {
print?: boolean | undefined;
stripColor?: boolean | undefined;
} | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
stdout: (arg1?: {
print?: boolean | undefined;
stripColor?: boolean | undefined;
} | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
command: (arg1?: string | string[] | undefined, arg2?: Options | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
exit: (arg1?: number | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
hook: (arg1?: string | undefined, arg2?: object | undefined, arg3?: Options | undefined, arg4?: {} | undefined) => any & any;
};
do(cb: (context: Context) => any): any & {
skip: (arg1?: {} | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
only: (arg1?: {} | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
catch: (arg1?: string | RegExp | ((err: Error) => any) | undefined, arg2?: {
raiseIfNotThrown?: boolean | undefined;
} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
env: (arg1?: {
[k: string]: string | undefined;
} | undefined, arg2?: EnvOptions | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
stub: (arg1?: any, arg2?: string | undefined, arg3?: any, arg4?: {} | undefined) => any & any;
nock: (arg1?: string | undefined, arg2?: ((nock: NockScope) => any) | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
stderr: (arg1?: {
print?: boolean | undefined;
stripColor?: boolean | undefined;
} | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
stdout: (arg1?: {
print?: boolean | undefined;
stripColor?: boolean | undefined;
} | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
command: (arg1?: string | string[] | undefined, arg2?: Options | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
exit: (arg1?: number | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
hook: (arg1?: string | undefined, arg2?: object | undefined, arg3?: Options | undefined, arg4?: {} | undefined) => any & any;
};
register(key: K, plugin: (arg1?: A1 | undefined, arg2?: A2 | undefined, arg3?: A3 | undefined, arg4?: A4 | undefined) => Plugin): any & {
skip: (arg1?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["skip"][1] | undefined, arg2?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["skip"][2] | undefined, arg3?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["skip"][3] | undefined, arg4?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["skip"][4] | undefined) => any & any;
only: (arg1?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["only"][1] | undefined, arg2?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["only"][2] | undefined, arg3?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["only"][3] | undefined, arg4?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["only"][4] | undefined) => any & any;
catch: (arg1?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["catch"][1] | undefined, arg2?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["catch"][2] | undefined, arg3?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["catch"][3] | undefined, arg4?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["catch"][4] | undefined) => any & any;
env: (arg1?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["env"][1] | undefined, arg2?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["env"][2] | undefined, arg3?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["env"][3] | undefined, arg4?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["env"][4] | undefined) => any & any;
stub: (arg1?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["stub"][1] | undefined, arg2?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["stub"][2] | undefined, arg3?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["stub"][3] | undefined, arg4?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["stub"][4] | undefined) => any & any;
nock: (arg1?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["nock"][1] | undefined, arg2?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["nock"][2] | undefined, arg3?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["nock"][3] | undefined, arg4?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["nock"][4] | undefined) => any & any;
stderr: (arg1?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["stderr"][1] | undefined, arg2?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["stderr"][2] | undefined, arg3?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["stderr"][3] | undefined, arg4?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["stderr"][4] | undefined) => any & any;
stdout: (arg1?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["stdout"][1] | undefined, arg2?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["stdout"][2] | undefined, arg3?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["stdout"][3] | undefined, arg4?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["stdout"][4] | undefined) => any & any;
command: (arg1?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["command"][1] | undefined, arg2?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["command"][2] | undefined, arg3?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["command"][3] | undefined, arg4?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["command"][4] | undefined) => any & any;
exit: (arg1?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["exit"][1] | undefined, arg2?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["exit"][2] | undefined, arg3?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["exit"][3] | undefined, arg4?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["exit"][4] | undefined) => any & any;
hook: (arg1?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["hook"][1] | undefined, arg2?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["hook"][2] | undefined, arg3?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["hook"][3] | undefined, arg4?: ({
skip: [{}, {}, {}, {}, {}];
} & {
only: [{}, {}, {}, {}, {}];
} & {
catch: [{
error: Error;
}, string | RegExp | ((err: Error) => any), {
raiseIfNotThrown?: boolean | undefined;
}, {}, {}];
} & {
env: [{
envs: NodeJS.ProcessEnv[];
}, {
[k: string]: string | undefined;
}, EnvOptions, {}, {}];
} & {
stub: [{
stubs: any[];
}, any, string, any, {}];
} & {
nock: [{
nock: number;
}, string, (nock: NockScope) => any, {}, {}];
} & {
stderr: [{
readonly stderr: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
stdout: [{
readonly stdout: string;
}, {
print?: boolean | undefined;
stripColor?: boolean | undefined;
}, {}, {}, {}];
} & {
command: [{
expectation: string;
}, string | string[], Options, {}, {}];
} & {
exit: [{
error: any;
}, number, {}, {}, {}];
} & {
hook: [{
expectation: string;
}, string, object, Options, {}];
} & {
[P in K]: [O, A1, A2, A3, A4];
})["hook"][4] | undefined) => any & any;
};
} & {
skip: (arg1?: {} | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => {
it: {
(expectation: string, cb?: ((context: Context) => any) | undefined): void;
(cb?: ((context: Context) => any) | undefined): void;
};
end: {
(expectation: string, cb?: ((context: Context) => any) | undefined): void;
(cb?: ((context: Context) => any) | undefined): void;
};
add(key: K, cb: (context: Context) => O | Promise): any & any;
do(cb: (context: Context) => any): any & any;
register(key: K, plugin: (arg1?: A1 | undefined, arg2?: A2 | undefined, arg3?: A3 | undefined, arg4?: A4 | undefined) => Plugin): any & any;
} & any;
only: (arg1?: {} | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => {
it: {
(expectation: string, cb?: ((context: Context) => any) | undefined): void;
(cb?: ((context: Context) => any) | undefined): void;
};
end: {
(expectation: string, cb?: ((context: Context) => any) | undefined): void;
(cb?: ((context: Context) => any) | undefined): void;
};
add(key: K, cb: (context: Context) => O | Promise): any & any;
do(cb: (context: Context) => any): any & any;
register(key: K, plugin: (arg1?: A1 | undefined, arg2?: A2 | undefined, arg3?: A3 | undefined, arg4?: A4 | undefined) => Plugin): any & any;
} & any;
catch: (arg1?: string | RegExp | ((err: Error) => any) | undefined, arg2?: {
raiseIfNotThrown?: boolean | undefined;
} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => {
it: {
(expectation: string, cb?: ((context: {
error: Error;
} & Context) => any) | undefined): void;
(cb?: ((context: {
error: Error;
} & Context) => any) | undefined): void;
};
end: {
(expectation: string, cb?: ((context: {
error: Error;
} & Context) => any) | undefined): void;
(cb?: ((context: {
error: Error;
} & Context) => any) | undefined): void;
};
add(key: K, cb: (context: {
error: Error;
} & Context) => O | Promise): any & any;
do(cb: (context: {
error: Error;
} & Context) => any): any & any;
register(key: K, plugin: (arg1?: A1 | undefined, arg2?: A2 | undefined, arg3?: A3 | undefined, arg4?: A4 | undefined) => Plugin): any & any;
} & any;
env: (arg1?: {
[k: string]: string | undefined;
} | undefined, arg2?: EnvOptions | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => {
it: {
(expectation: string, cb?: ((context: {
envs: NodeJS.ProcessEnv[];
} & Context) => any) | undefined): void;
(cb?: ((context: {
envs: NodeJS.ProcessEnv[];
} & Context) => any) | undefined): void;
};
end: {
(expectation: string, cb?: ((context: {
envs: NodeJS.ProcessEnv[];
} & Context) => any) | undefined): void;
(cb?: ((context: {
envs: NodeJS.ProcessEnv[];
} & Context) => any) | undefined): void;
};
add(key: K, cb: (context: {
envs: NodeJS.ProcessEnv[];
} & Context) => O | Promise): any & any;
do(cb: (context: {
envs: NodeJS.ProcessEnv[];
} & Context) => any): any & any;
register(key: K, plugin: (arg1?: A1 | undefined, arg2?: A2 | undefined, arg3?: A3 | undefined, arg4?: A4 | undefined) => Plugin): any & any;
} & any;
stub: (arg1?: any, arg2?: string | undefined, arg3?: any, arg4?: {} | undefined) => {
it: {
(expectation: string, cb?: ((context: {
stubs: any[];
} & Context) => any) | undefined): void;
(cb?: ((context: {
stubs: any[];
} & Context) => any) | undefined): void;
};
end: {
(expectation: string, cb?: ((context: {
stubs: any[];
} & Context) => any) | undefined): void;
(cb?: ((context: {
stubs: any[];
} & Context) => any) | undefined): void;
};
add(key: K, cb: (context: {
stubs: any[];
} & Context) => O | Promise): any & any;
do(cb: (context: {
stubs: any[];
} & Context) => any): any & any;
register(key: K, plugin: (arg1?: A1 | undefined, arg2?: A2 | undefined, arg3?: A3 | undefined, arg4?: A4 | undefined) => Plugin): any & any;
} & any;
nock: (arg1?: string | undefined, arg2?: ((nock: NockScope) => any) | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => {
it: {
(expectation: string, cb?: ((context: {
nock: number;
} & Context) => any) | undefined): void;
(cb?: ((context: {
nock: number;
} & Context) => any) | undefined): void;
};
end: {
(expectation: string, cb?: ((context: {
nock: number;
} & Context) => any) | undefined): void;
(cb?: ((context: {
nock: number;
} & Context) => any) | undefined): void;
};
add(key: K, cb: (context: {
nock: number;
} & Context) => O | Promise): any & any;
do(cb: (context: {
nock: number;
} & Context) => any): any & any;
register(key: K, plugin: (arg1?: A1 | undefined, arg2?: A2 | undefined, arg3?: A3 | undefined, arg4?: A4 | undefined) => Plugin): any & any;
} & any;
stderr: (arg1?: {
print?: boolean | undefined;
stripColor?: boolean | undefined;
} | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => {
it: {
(expectation: string, cb?: ((context: {
readonly stderr: string;
} & Context) => any) | undefined): void;
(cb?: ((context: {
readonly stderr: string;
} & Context) => any) | undefined): void;
};
end: {
(expectation: string, cb?: ((context: {
readonly stderr: string;
} & Context) => any) | undefined): void;
(cb?: ((context: {
readonly stderr: string;
} & Context) => any) | undefined): void;
};
add(key: K, cb: (context: {
readonly stderr: string;
} & Context) => O | Promise): any & any;
do(cb: (context: {
readonly stderr: string;
} & Context) => any): any & any;
register(key: K, plugin: (arg1?: A1 | undefined, arg2?: A2 | undefined, arg3?: A3 | undefined, arg4?: A4 | undefined) => Plugin): any & any;
} & any;
stdout: (arg1?: {
print?: boolean | undefined;
stripColor?: boolean | undefined;
} | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => {
it: {
(expectation: string, cb?: ((context: {
readonly stdout: string;
} & Context) => any) | undefined): void;
(cb?: ((context: {
readonly stdout: string;
} & Context) => any) | undefined): void;
};
end: {
(expectation: string, cb?: ((context: {
readonly stdout: string;
} & Context) => any) | undefined): void;
(cb?: ((context: {
readonly stdout: string;
} & Context) => any) | undefined): void;
};
add(key: K, cb: (context: {
readonly stdout: string;
} & Context) => O | Promise): any & any;
do(cb: (context: {
readonly stdout: string;
} & Context) => any): any & any;
register(key: K, plugin: (arg1?: A1 | undefined, arg2?: A2 | undefined, arg3?: A3 | undefined, arg4?: A4 | undefined) => Plugin): any & any;
} & any;
command: (arg1?: string | string[] | undefined, arg2?: Options | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => {
it: {
(expectation: string, cb?: ((context: {
expectation: string;
} & Context) => any) | undefined): void;
(cb?: ((context: {
expectation: string;
} & Context) => any) | undefined): void;
};
end: {
(expectation: string, cb?: ((context: {
expectation: string;
} & Context) => any) | undefined): void;
(cb?: ((context: {
expectation: string;
} & Context) => any) | undefined): void;
};
add(key: K, cb: (context: {
expectation: string;
} & Context) => O | Promise): any & any;
do(cb: (context: {
expectation: string;
} & Context) => any): any & any;
register(key: K, plugin: (arg1?: A1 | undefined, arg2?: A2 | undefined, arg3?: A3 | undefined, arg4?: A4 | undefined) => Plugin): any & any;
} & any;
exit: (arg1?: number | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => {
it: {
(expectation: string, cb?: ((context: {
error: any;
} & Context) => any) | undefined): void;
(cb?: ((context: {
error: any;
} & Context) => any) | undefined): void;
};
end: {
(expectation: string, cb?: ((context: {
error: any;
} & Context) => any) | undefined): void;
(cb?: ((context: {
error: any;
} & Context) => any) | undefined): void;
};
add(key: K, cb: (context: {
error: any;
} & Context) => O | Promise): any & any;
do(cb: (context: {
error: any;
} & Context) => any): any & any;
register(key: K, plugin: (arg1?: A1 | undefined, arg2?: A2 | undefined, arg3?: A3 | undefined, arg4?: A4 | undefined) => Plugin): any & any;
} & any;
hook: (arg1?: string | undefined, arg2?: object | undefined, arg3?: Options | undefined, arg4?: {} | undefined) => {
it: {
(expectation: string, cb?: ((context: {
expectation: string;
} & Context) => any) | undefined): void;
(cb?: ((context: {
expectation: string;
} & Context) => any) | undefined): void;
};
end: {
(expectation: string, cb?: ((context: {
expectation: string;
} & Context) => any) | undefined): void;
(cb?: ((context: {
expectation: string;
} & Context) => any) | undefined): void;
};
add(key: K, cb: (context: {
expectation: string;
} & Context) => O | Promise): any & any;
do(cb: (context: {
expectation: string;
} & Context) => any): any & any;
register(key: K, plugin: (arg1?: A1 | undefined, arg2?: A2 | undefined, arg3?: A3 | undefined, arg4?: A4 | undefined) => Plugin): any & any;
} & any;
};
export default test;
export { Context, EnvOptions, NockScope, Options, Plugin, expect };