UNPKG

87.1 kBTypeScriptView Raw
1/// <reference types="nock" />
2/// <reference types="node" />
3import { Context, EnvOptions, expect, NockScope, Plugin } from 'fancy-test';
4import { Options } from './options';
5export declare const test: {
6 it: {
7 (expectation: string, cb?: ((context: Context) => any) | undefined): void;
8 (cb?: ((context: Context) => any) | undefined): void;
9 };
10 end: {
11 (expectation: string, cb?: ((context: Context) => any) | undefined): void;
12 (cb?: ((context: Context) => any) | undefined): void;
13 };
14 add<K extends string, O>(key: K, cb: (context: Context) => O | Promise<O>): any & {
15 skip: (arg1?: {} | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
16 only: (arg1?: {} | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
17 catch: (arg1?: string | RegExp | ((err: Error) => any) | undefined, arg2?: {
18 raiseIfNotThrown?: boolean | undefined;
19 } | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
20 env: (arg1?: {
21 [k: string]: string | undefined;
22 } | undefined, arg2?: EnvOptions | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
23 stub: (arg1?: any, arg2?: string | undefined, arg3?: any, arg4?: {} | undefined) => any & any;
24 nock: (arg1?: string | undefined, arg2?: ((nock: NockScope) => any) | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
25 stderr: (arg1?: {
26 print?: boolean | undefined;
27 stripColor?: boolean | undefined;
28 } | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
29 stdout: (arg1?: {
30 print?: boolean | undefined;
31 stripColor?: boolean | undefined;
32 } | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
33 command: (arg1?: string | string[] | undefined, arg2?: Options | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
34 exit: (arg1?: number | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
35 hook: (arg1?: string | undefined, arg2?: object | undefined, arg3?: Options | undefined, arg4?: {} | undefined) => any & any;
36 };
37 do(cb: (context: Context) => any): any & {
38 skip: (arg1?: {} | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
39 only: (arg1?: {} | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
40 catch: (arg1?: string | RegExp | ((err: Error) => any) | undefined, arg2?: {
41 raiseIfNotThrown?: boolean | undefined;
42 } | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
43 env: (arg1?: {
44 [k: string]: string | undefined;
45 } | undefined, arg2?: EnvOptions | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
46 stub: (arg1?: any, arg2?: string | undefined, arg3?: any, arg4?: {} | undefined) => any & any;
47 nock: (arg1?: string | undefined, arg2?: ((nock: NockScope) => any) | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
48 stderr: (arg1?: {
49 print?: boolean | undefined;
50 stripColor?: boolean | undefined;
51 } | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
52 stdout: (arg1?: {
53 print?: boolean | undefined;
54 stripColor?: boolean | undefined;
55 } | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
56 command: (arg1?: string | string[] | undefined, arg2?: Options | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
57 exit: (arg1?: number | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => any & any;
58 hook: (arg1?: string | undefined, arg2?: object | undefined, arg3?: Options | undefined, arg4?: {} | undefined) => any & any;
59 };
60 register<K extends string, O, A1, A2, A3, A4>(key: K, plugin: (arg1?: A1 | undefined, arg2?: A2 | undefined, arg3?: A3 | undefined, arg4?: A4 | undefined) => Plugin<O & Context>): any & {
61 skip: (arg1?: ({
62 skip: [{}, {}, {}, {}, {}];
63 } & {
64 only: [{}, {}, {}, {}, {}];
65 } & {
66 catch: [{
67 error: Error;
68 }, string | RegExp | ((err: Error) => any), {
69 raiseIfNotThrown?: boolean | undefined;
70 }, {}, {}];
71 } & {
72 env: [{
73 envs: NodeJS.ProcessEnv[];
74 }, {
75 [k: string]: string | undefined;
76 }, EnvOptions, {}, {}];
77 } & {
78 stub: [{
79 stubs: any[];
80 }, any, string, any, {}];
81 } & {
82 nock: [{
83 nock: number;
84 }, string, (nock: NockScope) => any, {}, {}];
85 } & {
86 stderr: [{
87 readonly stderr: string;
88 }, {
89 print?: boolean | undefined;
90 stripColor?: boolean | undefined;
91 }, {}, {}, {}];
92 } & {
93 stdout: [{
94 readonly stdout: string;
95 }, {
96 print?: boolean | undefined;
97 stripColor?: boolean | undefined;
98 }, {}, {}, {}];
99 } & {
100 command: [{
101 expectation: string;
102 }, string | string[], Options, {}, {}];
103 } & {
104 exit: [{
105 error: any;
106 }, number, {}, {}, {}];
107 } & {
108 hook: [{
109 expectation: string;
110 }, string, object, Options, {}];
111 } & {
112 [P in K]: [O, A1, A2, A3, A4];
113 })["skip"][1] | undefined, arg2?: ({
114 skip: [{}, {}, {}, {}, {}];
115 } & {
116 only: [{}, {}, {}, {}, {}];
117 } & {
118 catch: [{
119 error: Error;
120 }, string | RegExp | ((err: Error) => any), {
121 raiseIfNotThrown?: boolean | undefined;
122 }, {}, {}];
123 } & {
124 env: [{
125 envs: NodeJS.ProcessEnv[];
126 }, {
127 [k: string]: string | undefined;
128 }, EnvOptions, {}, {}];
129 } & {
130 stub: [{
131 stubs: any[];
132 }, any, string, any, {}];
133 } & {
134 nock: [{
135 nock: number;
136 }, string, (nock: NockScope) => any, {}, {}];
137 } & {
138 stderr: [{
139 readonly stderr: string;
140 }, {
141 print?: boolean | undefined;
142 stripColor?: boolean | undefined;
143 }, {}, {}, {}];
144 } & {
145 stdout: [{
146 readonly stdout: string;
147 }, {
148 print?: boolean | undefined;
149 stripColor?: boolean | undefined;
150 }, {}, {}, {}];
151 } & {
152 command: [{
153 expectation: string;
154 }, string | string[], Options, {}, {}];
155 } & {
156 exit: [{
157 error: any;
158 }, number, {}, {}, {}];
159 } & {
160 hook: [{
161 expectation: string;
162 }, string, object, Options, {}];
163 } & {
164 [P in K]: [O, A1, A2, A3, A4];
165 })["skip"][2] | undefined, arg3?: ({
166 skip: [{}, {}, {}, {}, {}];
167 } & {
168 only: [{}, {}, {}, {}, {}];
169 } & {
170 catch: [{
171 error: Error;
172 }, string | RegExp | ((err: Error) => any), {
173 raiseIfNotThrown?: boolean | undefined;
174 }, {}, {}];
175 } & {
176 env: [{
177 envs: NodeJS.ProcessEnv[];
178 }, {
179 [k: string]: string | undefined;
180 }, EnvOptions, {}, {}];
181 } & {
182 stub: [{
183 stubs: any[];
184 }, any, string, any, {}];
185 } & {
186 nock: [{
187 nock: number;
188 }, string, (nock: NockScope) => any, {}, {}];
189 } & {
190 stderr: [{
191 readonly stderr: string;
192 }, {
193 print?: boolean | undefined;
194 stripColor?: boolean | undefined;
195 }, {}, {}, {}];
196 } & {
197 stdout: [{
198 readonly stdout: string;
199 }, {
200 print?: boolean | undefined;
201 stripColor?: boolean | undefined;
202 }, {}, {}, {}];
203 } & {
204 command: [{
205 expectation: string;
206 }, string | string[], Options, {}, {}];
207 } & {
208 exit: [{
209 error: any;
210 }, number, {}, {}, {}];
211 } & {
212 hook: [{
213 expectation: string;
214 }, string, object, Options, {}];
215 } & {
216 [P in K]: [O, A1, A2, A3, A4];
217 })["skip"][3] | undefined, arg4?: ({
218 skip: [{}, {}, {}, {}, {}];
219 } & {
220 only: [{}, {}, {}, {}, {}];
221 } & {
222 catch: [{
223 error: Error;
224 }, string | RegExp | ((err: Error) => any), {
225 raiseIfNotThrown?: boolean | undefined;
226 }, {}, {}];
227 } & {
228 env: [{
229 envs: NodeJS.ProcessEnv[];
230 }, {
231 [k: string]: string | undefined;
232 }, EnvOptions, {}, {}];
233 } & {
234 stub: [{
235 stubs: any[];
236 }, any, string, any, {}];
237 } & {
238 nock: [{
239 nock: number;
240 }, string, (nock: NockScope) => any, {}, {}];
241 } & {
242 stderr: [{
243 readonly stderr: string;
244 }, {
245 print?: boolean | undefined;
246 stripColor?: boolean | undefined;
247 }, {}, {}, {}];
248 } & {
249 stdout: [{
250 readonly stdout: string;
251 }, {
252 print?: boolean | undefined;
253 stripColor?: boolean | undefined;
254 }, {}, {}, {}];
255 } & {
256 command: [{
257 expectation: string;
258 }, string | string[], Options, {}, {}];
259 } & {
260 exit: [{
261 error: any;
262 }, number, {}, {}, {}];
263 } & {
264 hook: [{
265 expectation: string;
266 }, string, object, Options, {}];
267 } & {
268 [P in K]: [O, A1, A2, A3, A4];
269 })["skip"][4] | undefined) => any & any;
270 only: (arg1?: ({
271 skip: [{}, {}, {}, {}, {}];
272 } & {
273 only: [{}, {}, {}, {}, {}];
274 } & {
275 catch: [{
276 error: Error;
277 }, string | RegExp | ((err: Error) => any), {
278 raiseIfNotThrown?: boolean | undefined;
279 }, {}, {}];
280 } & {
281 env: [{
282 envs: NodeJS.ProcessEnv[];
283 }, {
284 [k: string]: string | undefined;
285 }, EnvOptions, {}, {}];
286 } & {
287 stub: [{
288 stubs: any[];
289 }, any, string, any, {}];
290 } & {
291 nock: [{
292 nock: number;
293 }, string, (nock: NockScope) => any, {}, {}];
294 } & {
295 stderr: [{
296 readonly stderr: string;
297 }, {
298 print?: boolean | undefined;
299 stripColor?: boolean | undefined;
300 }, {}, {}, {}];
301 } & {
302 stdout: [{
303 readonly stdout: string;
304 }, {
305 print?: boolean | undefined;
306 stripColor?: boolean | undefined;
307 }, {}, {}, {}];
308 } & {
309 command: [{
310 expectation: string;
311 }, string | string[], Options, {}, {}];
312 } & {
313 exit: [{
314 error: any;
315 }, number, {}, {}, {}];
316 } & {
317 hook: [{
318 expectation: string;
319 }, string, object, Options, {}];
320 } & {
321 [P in K]: [O, A1, A2, A3, A4];
322 })["only"][1] | undefined, arg2?: ({
323 skip: [{}, {}, {}, {}, {}];
324 } & {
325 only: [{}, {}, {}, {}, {}];
326 } & {
327 catch: [{
328 error: Error;
329 }, string | RegExp | ((err: Error) => any), {
330 raiseIfNotThrown?: boolean | undefined;
331 }, {}, {}];
332 } & {
333 env: [{
334 envs: NodeJS.ProcessEnv[];
335 }, {
336 [k: string]: string | undefined;
337 }, EnvOptions, {}, {}];
338 } & {
339 stub: [{
340 stubs: any[];
341 }, any, string, any, {}];
342 } & {
343 nock: [{
344 nock: number;
345 }, string, (nock: NockScope) => any, {}, {}];
346 } & {
347 stderr: [{
348 readonly stderr: string;
349 }, {
350 print?: boolean | undefined;
351 stripColor?: boolean | undefined;
352 }, {}, {}, {}];
353 } & {
354 stdout: [{
355 readonly stdout: string;
356 }, {
357 print?: boolean | undefined;
358 stripColor?: boolean | undefined;
359 }, {}, {}, {}];
360 } & {
361 command: [{
362 expectation: string;
363 }, string | string[], Options, {}, {}];
364 } & {
365 exit: [{
366 error: any;
367 }, number, {}, {}, {}];
368 } & {
369 hook: [{
370 expectation: string;
371 }, string, object, Options, {}];
372 } & {
373 [P in K]: [O, A1, A2, A3, A4];
374 })["only"][2] | undefined, arg3?: ({
375 skip: [{}, {}, {}, {}, {}];
376 } & {
377 only: [{}, {}, {}, {}, {}];
378 } & {
379 catch: [{
380 error: Error;
381 }, string | RegExp | ((err: Error) => any), {
382 raiseIfNotThrown?: boolean | undefined;
383 }, {}, {}];
384 } & {
385 env: [{
386 envs: NodeJS.ProcessEnv[];
387 }, {
388 [k: string]: string | undefined;
389 }, EnvOptions, {}, {}];
390 } & {
391 stub: [{
392 stubs: any[];
393 }, any, string, any, {}];
394 } & {
395 nock: [{
396 nock: number;
397 }, string, (nock: NockScope) => any, {}, {}];
398 } & {
399 stderr: [{
400 readonly stderr: string;
401 }, {
402 print?: boolean | undefined;
403 stripColor?: boolean | undefined;
404 }, {}, {}, {}];
405 } & {
406 stdout: [{
407 readonly stdout: string;
408 }, {
409 print?: boolean | undefined;
410 stripColor?: boolean | undefined;
411 }, {}, {}, {}];
412 } & {
413 command: [{
414 expectation: string;
415 }, string | string[], Options, {}, {}];
416 } & {
417 exit: [{
418 error: any;
419 }, number, {}, {}, {}];
420 } & {
421 hook: [{
422 expectation: string;
423 }, string, object, Options, {}];
424 } & {
425 [P in K]: [O, A1, A2, A3, A4];
426 })["only"][3] | undefined, arg4?: ({
427 skip: [{}, {}, {}, {}, {}];
428 } & {
429 only: [{}, {}, {}, {}, {}];
430 } & {
431 catch: [{
432 error: Error;
433 }, string | RegExp | ((err: Error) => any), {
434 raiseIfNotThrown?: boolean | undefined;
435 }, {}, {}];
436 } & {
437 env: [{
438 envs: NodeJS.ProcessEnv[];
439 }, {
440 [k: string]: string | undefined;
441 }, EnvOptions, {}, {}];
442 } & {
443 stub: [{
444 stubs: any[];
445 }, any, string, any, {}];
446 } & {
447 nock: [{
448 nock: number;
449 }, string, (nock: NockScope) => any, {}, {}];
450 } & {
451 stderr: [{
452 readonly stderr: string;
453 }, {
454 print?: boolean | undefined;
455 stripColor?: boolean | undefined;
456 }, {}, {}, {}];
457 } & {
458 stdout: [{
459 readonly stdout: string;
460 }, {
461 print?: boolean | undefined;
462 stripColor?: boolean | undefined;
463 }, {}, {}, {}];
464 } & {
465 command: [{
466 expectation: string;
467 }, string | string[], Options, {}, {}];
468 } & {
469 exit: [{
470 error: any;
471 }, number, {}, {}, {}];
472 } & {
473 hook: [{
474 expectation: string;
475 }, string, object, Options, {}];
476 } & {
477 [P in K]: [O, A1, A2, A3, A4];
478 })["only"][4] | undefined) => any & any;
479 catch: (arg1?: ({
480 skip: [{}, {}, {}, {}, {}];
481 } & {
482 only: [{}, {}, {}, {}, {}];
483 } & {
484 catch: [{
485 error: Error;
486 }, string | RegExp | ((err: Error) => any), {
487 raiseIfNotThrown?: boolean | undefined;
488 }, {}, {}];
489 } & {
490 env: [{
491 envs: NodeJS.ProcessEnv[];
492 }, {
493 [k: string]: string | undefined;
494 }, EnvOptions, {}, {}];
495 } & {
496 stub: [{
497 stubs: any[];
498 }, any, string, any, {}];
499 } & {
500 nock: [{
501 nock: number;
502 }, string, (nock: NockScope) => any, {}, {}];
503 } & {
504 stderr: [{
505 readonly stderr: string;
506 }, {
507 print?: boolean | undefined;
508 stripColor?: boolean | undefined;
509 }, {}, {}, {}];
510 } & {
511 stdout: [{
512 readonly stdout: string;
513 }, {
514 print?: boolean | undefined;
515 stripColor?: boolean | undefined;
516 }, {}, {}, {}];
517 } & {
518 command: [{
519 expectation: string;
520 }, string | string[], Options, {}, {}];
521 } & {
522 exit: [{
523 error: any;
524 }, number, {}, {}, {}];
525 } & {
526 hook: [{
527 expectation: string;
528 }, string, object, Options, {}];
529 } & {
530 [P in K]: [O, A1, A2, A3, A4];
531 })["catch"][1] | undefined, arg2?: ({
532 skip: [{}, {}, {}, {}, {}];
533 } & {
534 only: [{}, {}, {}, {}, {}];
535 } & {
536 catch: [{
537 error: Error;
538 }, string | RegExp | ((err: Error) => any), {
539 raiseIfNotThrown?: boolean | undefined;
540 }, {}, {}];
541 } & {
542 env: [{
543 envs: NodeJS.ProcessEnv[];
544 }, {
545 [k: string]: string | undefined;
546 }, EnvOptions, {}, {}];
547 } & {
548 stub: [{
549 stubs: any[];
550 }, any, string, any, {}];
551 } & {
552 nock: [{
553 nock: number;
554 }, string, (nock: NockScope) => any, {}, {}];
555 } & {
556 stderr: [{
557 readonly stderr: string;
558 }, {
559 print?: boolean | undefined;
560 stripColor?: boolean | undefined;
561 }, {}, {}, {}];
562 } & {
563 stdout: [{
564 readonly stdout: string;
565 }, {
566 print?: boolean | undefined;
567 stripColor?: boolean | undefined;
568 }, {}, {}, {}];
569 } & {
570 command: [{
571 expectation: string;
572 }, string | string[], Options, {}, {}];
573 } & {
574 exit: [{
575 error: any;
576 }, number, {}, {}, {}];
577 } & {
578 hook: [{
579 expectation: string;
580 }, string, object, Options, {}];
581 } & {
582 [P in K]: [O, A1, A2, A3, A4];
583 })["catch"][2] | undefined, arg3?: ({
584 skip: [{}, {}, {}, {}, {}];
585 } & {
586 only: [{}, {}, {}, {}, {}];
587 } & {
588 catch: [{
589 error: Error;
590 }, string | RegExp | ((err: Error) => any), {
591 raiseIfNotThrown?: boolean | undefined;
592 }, {}, {}];
593 } & {
594 env: [{
595 envs: NodeJS.ProcessEnv[];
596 }, {
597 [k: string]: string | undefined;
598 }, EnvOptions, {}, {}];
599 } & {
600 stub: [{
601 stubs: any[];
602 }, any, string, any, {}];
603 } & {
604 nock: [{
605 nock: number;
606 }, string, (nock: NockScope) => any, {}, {}];
607 } & {
608 stderr: [{
609 readonly stderr: string;
610 }, {
611 print?: boolean | undefined;
612 stripColor?: boolean | undefined;
613 }, {}, {}, {}];
614 } & {
615 stdout: [{
616 readonly stdout: string;
617 }, {
618 print?: boolean | undefined;
619 stripColor?: boolean | undefined;
620 }, {}, {}, {}];
621 } & {
622 command: [{
623 expectation: string;
624 }, string | string[], Options, {}, {}];
625 } & {
626 exit: [{
627 error: any;
628 }, number, {}, {}, {}];
629 } & {
630 hook: [{
631 expectation: string;
632 }, string, object, Options, {}];
633 } & {
634 [P in K]: [O, A1, A2, A3, A4];
635 })["catch"][3] | undefined, arg4?: ({
636 skip: [{}, {}, {}, {}, {}];
637 } & {
638 only: [{}, {}, {}, {}, {}];
639 } & {
640 catch: [{
641 error: Error;
642 }, string | RegExp | ((err: Error) => any), {
643 raiseIfNotThrown?: boolean | undefined;
644 }, {}, {}];
645 } & {
646 env: [{
647 envs: NodeJS.ProcessEnv[];
648 }, {
649 [k: string]: string | undefined;
650 }, EnvOptions, {}, {}];
651 } & {
652 stub: [{
653 stubs: any[];
654 }, any, string, any, {}];
655 } & {
656 nock: [{
657 nock: number;
658 }, string, (nock: NockScope) => any, {}, {}];
659 } & {
660 stderr: [{
661 readonly stderr: string;
662 }, {
663 print?: boolean | undefined;
664 stripColor?: boolean | undefined;
665 }, {}, {}, {}];
666 } & {
667 stdout: [{
668 readonly stdout: string;
669 }, {
670 print?: boolean | undefined;
671 stripColor?: boolean | undefined;
672 }, {}, {}, {}];
673 } & {
674 command: [{
675 expectation: string;
676 }, string | string[], Options, {}, {}];
677 } & {
678 exit: [{
679 error: any;
680 }, number, {}, {}, {}];
681 } & {
682 hook: [{
683 expectation: string;
684 }, string, object, Options, {}];
685 } & {
686 [P in K]: [O, A1, A2, A3, A4];
687 })["catch"][4] | undefined) => any & any;
688 env: (arg1?: ({
689 skip: [{}, {}, {}, {}, {}];
690 } & {
691 only: [{}, {}, {}, {}, {}];
692 } & {
693 catch: [{
694 error: Error;
695 }, string | RegExp | ((err: Error) => any), {
696 raiseIfNotThrown?: boolean | undefined;
697 }, {}, {}];
698 } & {
699 env: [{
700 envs: NodeJS.ProcessEnv[];
701 }, {
702 [k: string]: string | undefined;
703 }, EnvOptions, {}, {}];
704 } & {
705 stub: [{
706 stubs: any[];
707 }, any, string, any, {}];
708 } & {
709 nock: [{
710 nock: number;
711 }, string, (nock: NockScope) => any, {}, {}];
712 } & {
713 stderr: [{
714 readonly stderr: string;
715 }, {
716 print?: boolean | undefined;
717 stripColor?: boolean | undefined;
718 }, {}, {}, {}];
719 } & {
720 stdout: [{
721 readonly stdout: string;
722 }, {
723 print?: boolean | undefined;
724 stripColor?: boolean | undefined;
725 }, {}, {}, {}];
726 } & {
727 command: [{
728 expectation: string;
729 }, string | string[], Options, {}, {}];
730 } & {
731 exit: [{
732 error: any;
733 }, number, {}, {}, {}];
734 } & {
735 hook: [{
736 expectation: string;
737 }, string, object, Options, {}];
738 } & {
739 [P in K]: [O, A1, A2, A3, A4];
740 })["env"][1] | undefined, arg2?: ({
741 skip: [{}, {}, {}, {}, {}];
742 } & {
743 only: [{}, {}, {}, {}, {}];
744 } & {
745 catch: [{
746 error: Error;
747 }, string | RegExp | ((err: Error) => any), {
748 raiseIfNotThrown?: boolean | undefined;
749 }, {}, {}];
750 } & {
751 env: [{
752 envs: NodeJS.ProcessEnv[];
753 }, {
754 [k: string]: string | undefined;
755 }, EnvOptions, {}, {}];
756 } & {
757 stub: [{
758 stubs: any[];
759 }, any, string, any, {}];
760 } & {
761 nock: [{
762 nock: number;
763 }, string, (nock: NockScope) => any, {}, {}];
764 } & {
765 stderr: [{
766 readonly stderr: string;
767 }, {
768 print?: boolean | undefined;
769 stripColor?: boolean | undefined;
770 }, {}, {}, {}];
771 } & {
772 stdout: [{
773 readonly stdout: string;
774 }, {
775 print?: boolean | undefined;
776 stripColor?: boolean | undefined;
777 }, {}, {}, {}];
778 } & {
779 command: [{
780 expectation: string;
781 }, string | string[], Options, {}, {}];
782 } & {
783 exit: [{
784 error: any;
785 }, number, {}, {}, {}];
786 } & {
787 hook: [{
788 expectation: string;
789 }, string, object, Options, {}];
790 } & {
791 [P in K]: [O, A1, A2, A3, A4];
792 })["env"][2] | undefined, arg3?: ({
793 skip: [{}, {}, {}, {}, {}];
794 } & {
795 only: [{}, {}, {}, {}, {}];
796 } & {
797 catch: [{
798 error: Error;
799 }, string | RegExp | ((err: Error) => any), {
800 raiseIfNotThrown?: boolean | undefined;
801 }, {}, {}];
802 } & {
803 env: [{
804 envs: NodeJS.ProcessEnv[];
805 }, {
806 [k: string]: string | undefined;
807 }, EnvOptions, {}, {}];
808 } & {
809 stub: [{
810 stubs: any[];
811 }, any, string, any, {}];
812 } & {
813 nock: [{
814 nock: number;
815 }, string, (nock: NockScope) => any, {}, {}];
816 } & {
817 stderr: [{
818 readonly stderr: string;
819 }, {
820 print?: boolean | undefined;
821 stripColor?: boolean | undefined;
822 }, {}, {}, {}];
823 } & {
824 stdout: [{
825 readonly stdout: string;
826 }, {
827 print?: boolean | undefined;
828 stripColor?: boolean | undefined;
829 }, {}, {}, {}];
830 } & {
831 command: [{
832 expectation: string;
833 }, string | string[], Options, {}, {}];
834 } & {
835 exit: [{
836 error: any;
837 }, number, {}, {}, {}];
838 } & {
839 hook: [{
840 expectation: string;
841 }, string, object, Options, {}];
842 } & {
843 [P in K]: [O, A1, A2, A3, A4];
844 })["env"][3] | undefined, arg4?: ({
845 skip: [{}, {}, {}, {}, {}];
846 } & {
847 only: [{}, {}, {}, {}, {}];
848 } & {
849 catch: [{
850 error: Error;
851 }, string | RegExp | ((err: Error) => any), {
852 raiseIfNotThrown?: boolean | undefined;
853 }, {}, {}];
854 } & {
855 env: [{
856 envs: NodeJS.ProcessEnv[];
857 }, {
858 [k: string]: string | undefined;
859 }, EnvOptions, {}, {}];
860 } & {
861 stub: [{
862 stubs: any[];
863 }, any, string, any, {}];
864 } & {
865 nock: [{
866 nock: number;
867 }, string, (nock: NockScope) => any, {}, {}];
868 } & {
869 stderr: [{
870 readonly stderr: string;
871 }, {
872 print?: boolean | undefined;
873 stripColor?: boolean | undefined;
874 }, {}, {}, {}];
875 } & {
876 stdout: [{
877 readonly stdout: string;
878 }, {
879 print?: boolean | undefined;
880 stripColor?: boolean | undefined;
881 }, {}, {}, {}];
882 } & {
883 command: [{
884 expectation: string;
885 }, string | string[], Options, {}, {}];
886 } & {
887 exit: [{
888 error: any;
889 }, number, {}, {}, {}];
890 } & {
891 hook: [{
892 expectation: string;
893 }, string, object, Options, {}];
894 } & {
895 [P in K]: [O, A1, A2, A3, A4];
896 })["env"][4] | undefined) => any & any;
897 stub: (arg1?: ({
898 skip: [{}, {}, {}, {}, {}];
899 } & {
900 only: [{}, {}, {}, {}, {}];
901 } & {
902 catch: [{
903 error: Error;
904 }, string | RegExp | ((err: Error) => any), {
905 raiseIfNotThrown?: boolean | undefined;
906 }, {}, {}];
907 } & {
908 env: [{
909 envs: NodeJS.ProcessEnv[];
910 }, {
911 [k: string]: string | undefined;
912 }, EnvOptions, {}, {}];
913 } & {
914 stub: [{
915 stubs: any[];
916 }, any, string, any, {}];
917 } & {
918 nock: [{
919 nock: number;
920 }, string, (nock: NockScope) => any, {}, {}];
921 } & {
922 stderr: [{
923 readonly stderr: string;
924 }, {
925 print?: boolean | undefined;
926 stripColor?: boolean | undefined;
927 }, {}, {}, {}];
928 } & {
929 stdout: [{
930 readonly stdout: string;
931 }, {
932 print?: boolean | undefined;
933 stripColor?: boolean | undefined;
934 }, {}, {}, {}];
935 } & {
936 command: [{
937 expectation: string;
938 }, string | string[], Options, {}, {}];
939 } & {
940 exit: [{
941 error: any;
942 }, number, {}, {}, {}];
943 } & {
944 hook: [{
945 expectation: string;
946 }, string, object, Options, {}];
947 } & {
948 [P in K]: [O, A1, A2, A3, A4];
949 })["stub"][1] | undefined, arg2?: ({
950 skip: [{}, {}, {}, {}, {}];
951 } & {
952 only: [{}, {}, {}, {}, {}];
953 } & {
954 catch: [{
955 error: Error;
956 }, string | RegExp | ((err: Error) => any), {
957 raiseIfNotThrown?: boolean | undefined;
958 }, {}, {}];
959 } & {
960 env: [{
961 envs: NodeJS.ProcessEnv[];
962 }, {
963 [k: string]: string | undefined;
964 }, EnvOptions, {}, {}];
965 } & {
966 stub: [{
967 stubs: any[];
968 }, any, string, any, {}];
969 } & {
970 nock: [{
971 nock: number;
972 }, string, (nock: NockScope) => any, {}, {}];
973 } & {
974 stderr: [{
975 readonly stderr: string;
976 }, {
977 print?: boolean | undefined;
978 stripColor?: boolean | undefined;
979 }, {}, {}, {}];
980 } & {
981 stdout: [{
982 readonly stdout: string;
983 }, {
984 print?: boolean | undefined;
985 stripColor?: boolean | undefined;
986 }, {}, {}, {}];
987 } & {
988 command: [{
989 expectation: string;
990 }, string | string[], Options, {}, {}];
991 } & {
992 exit: [{
993 error: any;
994 }, number, {}, {}, {}];
995 } & {
996 hook: [{
997 expectation: string;
998 }, string, object, Options, {}];
999 } & {
1000 [P in K]: [O, A1, A2, A3, A4];
1001 })["stub"][2] | undefined, arg3?: ({
1002 skip: [{}, {}, {}, {}, {}];
1003 } & {
1004 only: [{}, {}, {}, {}, {}];
1005 } & {
1006 catch: [{
1007 error: Error;
1008 }, string | RegExp | ((err: Error) => any), {
1009 raiseIfNotThrown?: boolean | undefined;
1010 }, {}, {}];
1011 } & {
1012 env: [{
1013 envs: NodeJS.ProcessEnv[];
1014 }, {
1015 [k: string]: string | undefined;
1016 }, EnvOptions, {}, {}];
1017 } & {
1018 stub: [{
1019 stubs: any[];
1020 }, any, string, any, {}];
1021 } & {
1022 nock: [{
1023 nock: number;
1024 }, string, (nock: NockScope) => any, {}, {}];
1025 } & {
1026 stderr: [{
1027 readonly stderr: string;
1028 }, {
1029 print?: boolean | undefined;
1030 stripColor?: boolean | undefined;
1031 }, {}, {}, {}];
1032 } & {
1033 stdout: [{
1034 readonly stdout: string;
1035 }, {
1036 print?: boolean | undefined;
1037 stripColor?: boolean | undefined;
1038 }, {}, {}, {}];
1039 } & {
1040 command: [{
1041 expectation: string;
1042 }, string | string[], Options, {}, {}];
1043 } & {
1044 exit: [{
1045 error: any;
1046 }, number, {}, {}, {}];
1047 } & {
1048 hook: [{
1049 expectation: string;
1050 }, string, object, Options, {}];
1051 } & {
1052 [P in K]: [O, A1, A2, A3, A4];
1053 })["stub"][3] | undefined, arg4?: ({
1054 skip: [{}, {}, {}, {}, {}];
1055 } & {
1056 only: [{}, {}, {}, {}, {}];
1057 } & {
1058 catch: [{
1059 error: Error;
1060 }, string | RegExp | ((err: Error) => any), {
1061 raiseIfNotThrown?: boolean | undefined;
1062 }, {}, {}];
1063 } & {
1064 env: [{
1065 envs: NodeJS.ProcessEnv[];
1066 }, {
1067 [k: string]: string | undefined;
1068 }, EnvOptions, {}, {}];
1069 } & {
1070 stub: [{
1071 stubs: any[];
1072 }, any, string, any, {}];
1073 } & {
1074 nock: [{
1075 nock: number;
1076 }, string, (nock: NockScope) => any, {}, {}];
1077 } & {
1078 stderr: [{
1079 readonly stderr: string;
1080 }, {
1081 print?: boolean | undefined;
1082 stripColor?: boolean | undefined;
1083 }, {}, {}, {}];
1084 } & {
1085 stdout: [{
1086 readonly stdout: string;
1087 }, {
1088 print?: boolean | undefined;
1089 stripColor?: boolean | undefined;
1090 }, {}, {}, {}];
1091 } & {
1092 command: [{
1093 expectation: string;
1094 }, string | string[], Options, {}, {}];
1095 } & {
1096 exit: [{
1097 error: any;
1098 }, number, {}, {}, {}];
1099 } & {
1100 hook: [{
1101 expectation: string;
1102 }, string, object, Options, {}];
1103 } & {
1104 [P in K]: [O, A1, A2, A3, A4];
1105 })["stub"][4] | undefined) => any & any;
1106 nock: (arg1?: ({
1107 skip: [{}, {}, {}, {}, {}];
1108 } & {
1109 only: [{}, {}, {}, {}, {}];
1110 } & {
1111 catch: [{
1112 error: Error;
1113 }, string | RegExp | ((err: Error) => any), {
1114 raiseIfNotThrown?: boolean | undefined;
1115 }, {}, {}];
1116 } & {
1117 env: [{
1118 envs: NodeJS.ProcessEnv[];
1119 }, {
1120 [k: string]: string | undefined;
1121 }, EnvOptions, {}, {}];
1122 } & {
1123 stub: [{
1124 stubs: any[];
1125 }, any, string, any, {}];
1126 } & {
1127 nock: [{
1128 nock: number;
1129 }, string, (nock: NockScope) => any, {}, {}];
1130 } & {
1131 stderr: [{
1132 readonly stderr: string;
1133 }, {
1134 print?: boolean | undefined;
1135 stripColor?: boolean | undefined;
1136 }, {}, {}, {}];
1137 } & {
1138 stdout: [{
1139 readonly stdout: string;
1140 }, {
1141 print?: boolean | undefined;
1142 stripColor?: boolean | undefined;
1143 }, {}, {}, {}];
1144 } & {
1145 command: [{
1146 expectation: string;
1147 }, string | string[], Options, {}, {}];
1148 } & {
1149 exit: [{
1150 error: any;
1151 }, number, {}, {}, {}];
1152 } & {
1153 hook: [{
1154 expectation: string;
1155 }, string, object, Options, {}];
1156 } & {
1157 [P in K]: [O, A1, A2, A3, A4];
1158 })["nock"][1] | undefined, arg2?: ({
1159 skip: [{}, {}, {}, {}, {}];
1160 } & {
1161 only: [{}, {}, {}, {}, {}];
1162 } & {
1163 catch: [{
1164 error: Error;
1165 }, string | RegExp | ((err: Error) => any), {
1166 raiseIfNotThrown?: boolean | undefined;
1167 }, {}, {}];
1168 } & {
1169 env: [{
1170 envs: NodeJS.ProcessEnv[];
1171 }, {
1172 [k: string]: string | undefined;
1173 }, EnvOptions, {}, {}];
1174 } & {
1175 stub: [{
1176 stubs: any[];
1177 }, any, string, any, {}];
1178 } & {
1179 nock: [{
1180 nock: number;
1181 }, string, (nock: NockScope) => any, {}, {}];
1182 } & {
1183 stderr: [{
1184 readonly stderr: string;
1185 }, {
1186 print?: boolean | undefined;
1187 stripColor?: boolean | undefined;
1188 }, {}, {}, {}];
1189 } & {
1190 stdout: [{
1191 readonly stdout: string;
1192 }, {
1193 print?: boolean | undefined;
1194 stripColor?: boolean | undefined;
1195 }, {}, {}, {}];
1196 } & {
1197 command: [{
1198 expectation: string;
1199 }, string | string[], Options, {}, {}];
1200 } & {
1201 exit: [{
1202 error: any;
1203 }, number, {}, {}, {}];
1204 } & {
1205 hook: [{
1206 expectation: string;
1207 }, string, object, Options, {}];
1208 } & {
1209 [P in K]: [O, A1, A2, A3, A4];
1210 })["nock"][2] | undefined, arg3?: ({
1211 skip: [{}, {}, {}, {}, {}];
1212 } & {
1213 only: [{}, {}, {}, {}, {}];
1214 } & {
1215 catch: [{
1216 error: Error;
1217 }, string | RegExp | ((err: Error) => any), {
1218 raiseIfNotThrown?: boolean | undefined;
1219 }, {}, {}];
1220 } & {
1221 env: [{
1222 envs: NodeJS.ProcessEnv[];
1223 }, {
1224 [k: string]: string | undefined;
1225 }, EnvOptions, {}, {}];
1226 } & {
1227 stub: [{
1228 stubs: any[];
1229 }, any, string, any, {}];
1230 } & {
1231 nock: [{
1232 nock: number;
1233 }, string, (nock: NockScope) => any, {}, {}];
1234 } & {
1235 stderr: [{
1236 readonly stderr: string;
1237 }, {
1238 print?: boolean | undefined;
1239 stripColor?: boolean | undefined;
1240 }, {}, {}, {}];
1241 } & {
1242 stdout: [{
1243 readonly stdout: string;
1244 }, {
1245 print?: boolean | undefined;
1246 stripColor?: boolean | undefined;
1247 }, {}, {}, {}];
1248 } & {
1249 command: [{
1250 expectation: string;
1251 }, string | string[], Options, {}, {}];
1252 } & {
1253 exit: [{
1254 error: any;
1255 }, number, {}, {}, {}];
1256 } & {
1257 hook: [{
1258 expectation: string;
1259 }, string, object, Options, {}];
1260 } & {
1261 [P in K]: [O, A1, A2, A3, A4];
1262 })["nock"][3] | undefined, arg4?: ({
1263 skip: [{}, {}, {}, {}, {}];
1264 } & {
1265 only: [{}, {}, {}, {}, {}];
1266 } & {
1267 catch: [{
1268 error: Error;
1269 }, string | RegExp | ((err: Error) => any), {
1270 raiseIfNotThrown?: boolean | undefined;
1271 }, {}, {}];
1272 } & {
1273 env: [{
1274 envs: NodeJS.ProcessEnv[];
1275 }, {
1276 [k: string]: string | undefined;
1277 }, EnvOptions, {}, {}];
1278 } & {
1279 stub: [{
1280 stubs: any[];
1281 }, any, string, any, {}];
1282 } & {
1283 nock: [{
1284 nock: number;
1285 }, string, (nock: NockScope) => any, {}, {}];
1286 } & {
1287 stderr: [{
1288 readonly stderr: string;
1289 }, {
1290 print?: boolean | undefined;
1291 stripColor?: boolean | undefined;
1292 }, {}, {}, {}];
1293 } & {
1294 stdout: [{
1295 readonly stdout: string;
1296 }, {
1297 print?: boolean | undefined;
1298 stripColor?: boolean | undefined;
1299 }, {}, {}, {}];
1300 } & {
1301 command: [{
1302 expectation: string;
1303 }, string | string[], Options, {}, {}];
1304 } & {
1305 exit: [{
1306 error: any;
1307 }, number, {}, {}, {}];
1308 } & {
1309 hook: [{
1310 expectation: string;
1311 }, string, object, Options, {}];
1312 } & {
1313 [P in K]: [O, A1, A2, A3, A4];
1314 })["nock"][4] | undefined) => any & any;
1315 stderr: (arg1?: ({
1316 skip: [{}, {}, {}, {}, {}];
1317 } & {
1318 only: [{}, {}, {}, {}, {}];
1319 } & {
1320 catch: [{
1321 error: Error;
1322 }, string | RegExp | ((err: Error) => any), {
1323 raiseIfNotThrown?: boolean | undefined;
1324 }, {}, {}];
1325 } & {
1326 env: [{
1327 envs: NodeJS.ProcessEnv[];
1328 }, {
1329 [k: string]: string | undefined;
1330 }, EnvOptions, {}, {}];
1331 } & {
1332 stub: [{
1333 stubs: any[];
1334 }, any, string, any, {}];
1335 } & {
1336 nock: [{
1337 nock: number;
1338 }, string, (nock: NockScope) => any, {}, {}];
1339 } & {
1340 stderr: [{
1341 readonly stderr: string;
1342 }, {
1343 print?: boolean | undefined;
1344 stripColor?: boolean | undefined;
1345 }, {}, {}, {}];
1346 } & {
1347 stdout: [{
1348 readonly stdout: string;
1349 }, {
1350 print?: boolean | undefined;
1351 stripColor?: boolean | undefined;
1352 }, {}, {}, {}];
1353 } & {
1354 command: [{
1355 expectation: string;
1356 }, string | string[], Options, {}, {}];
1357 } & {
1358 exit: [{
1359 error: any;
1360 }, number, {}, {}, {}];
1361 } & {
1362 hook: [{
1363 expectation: string;
1364 }, string, object, Options, {}];
1365 } & {
1366 [P in K]: [O, A1, A2, A3, A4];
1367 })["stderr"][1] | undefined, arg2?: ({
1368 skip: [{}, {}, {}, {}, {}];
1369 } & {
1370 only: [{}, {}, {}, {}, {}];
1371 } & {
1372 catch: [{
1373 error: Error;
1374 }, string | RegExp | ((err: Error) => any), {
1375 raiseIfNotThrown?: boolean | undefined;
1376 }, {}, {}];
1377 } & {
1378 env: [{
1379 envs: NodeJS.ProcessEnv[];
1380 }, {
1381 [k: string]: string | undefined;
1382 }, EnvOptions, {}, {}];
1383 } & {
1384 stub: [{
1385 stubs: any[];
1386 }, any, string, any, {}];
1387 } & {
1388 nock: [{
1389 nock: number;
1390 }, string, (nock: NockScope) => any, {}, {}];
1391 } & {
1392 stderr: [{
1393 readonly stderr: string;
1394 }, {
1395 print?: boolean | undefined;
1396 stripColor?: boolean | undefined;
1397 }, {}, {}, {}];
1398 } & {
1399 stdout: [{
1400 readonly stdout: string;
1401 }, {
1402 print?: boolean | undefined;
1403 stripColor?: boolean | undefined;
1404 }, {}, {}, {}];
1405 } & {
1406 command: [{
1407 expectation: string;
1408 }, string | string[], Options, {}, {}];
1409 } & {
1410 exit: [{
1411 error: any;
1412 }, number, {}, {}, {}];
1413 } & {
1414 hook: [{
1415 expectation: string;
1416 }, string, object, Options, {}];
1417 } & {
1418 [P in K]: [O, A1, A2, A3, A4];
1419 })["stderr"][2] | undefined, arg3?: ({
1420 skip: [{}, {}, {}, {}, {}];
1421 } & {
1422 only: [{}, {}, {}, {}, {}];
1423 } & {
1424 catch: [{
1425 error: Error;
1426 }, string | RegExp | ((err: Error) => any), {
1427 raiseIfNotThrown?: boolean | undefined;
1428 }, {}, {}];
1429 } & {
1430 env: [{
1431 envs: NodeJS.ProcessEnv[];
1432 }, {
1433 [k: string]: string | undefined;
1434 }, EnvOptions, {}, {}];
1435 } & {
1436 stub: [{
1437 stubs: any[];
1438 }, any, string, any, {}];
1439 } & {
1440 nock: [{
1441 nock: number;
1442 }, string, (nock: NockScope) => any, {}, {}];
1443 } & {
1444 stderr: [{
1445 readonly stderr: string;
1446 }, {
1447 print?: boolean | undefined;
1448 stripColor?: boolean | undefined;
1449 }, {}, {}, {}];
1450 } & {
1451 stdout: [{
1452 readonly stdout: string;
1453 }, {
1454 print?: boolean | undefined;
1455 stripColor?: boolean | undefined;
1456 }, {}, {}, {}];
1457 } & {
1458 command: [{
1459 expectation: string;
1460 }, string | string[], Options, {}, {}];
1461 } & {
1462 exit: [{
1463 error: any;
1464 }, number, {}, {}, {}];
1465 } & {
1466 hook: [{
1467 expectation: string;
1468 }, string, object, Options, {}];
1469 } & {
1470 [P in K]: [O, A1, A2, A3, A4];
1471 })["stderr"][3] | undefined, arg4?: ({
1472 skip: [{}, {}, {}, {}, {}];
1473 } & {
1474 only: [{}, {}, {}, {}, {}];
1475 } & {
1476 catch: [{
1477 error: Error;
1478 }, string | RegExp | ((err: Error) => any), {
1479 raiseIfNotThrown?: boolean | undefined;
1480 }, {}, {}];
1481 } & {
1482 env: [{
1483 envs: NodeJS.ProcessEnv[];
1484 }, {
1485 [k: string]: string | undefined;
1486 }, EnvOptions, {}, {}];
1487 } & {
1488 stub: [{
1489 stubs: any[];
1490 }, any, string, any, {}];
1491 } & {
1492 nock: [{
1493 nock: number;
1494 }, string, (nock: NockScope) => any, {}, {}];
1495 } & {
1496 stderr: [{
1497 readonly stderr: string;
1498 }, {
1499 print?: boolean | undefined;
1500 stripColor?: boolean | undefined;
1501 }, {}, {}, {}];
1502 } & {
1503 stdout: [{
1504 readonly stdout: string;
1505 }, {
1506 print?: boolean | undefined;
1507 stripColor?: boolean | undefined;
1508 }, {}, {}, {}];
1509 } & {
1510 command: [{
1511 expectation: string;
1512 }, string | string[], Options, {}, {}];
1513 } & {
1514 exit: [{
1515 error: any;
1516 }, number, {}, {}, {}];
1517 } & {
1518 hook: [{
1519 expectation: string;
1520 }, string, object, Options, {}];
1521 } & {
1522 [P in K]: [O, A1, A2, A3, A4];
1523 })["stderr"][4] | undefined) => any & any;
1524 stdout: (arg1?: ({
1525 skip: [{}, {}, {}, {}, {}];
1526 } & {
1527 only: [{}, {}, {}, {}, {}];
1528 } & {
1529 catch: [{
1530 error: Error;
1531 }, string | RegExp | ((err: Error) => any), {
1532 raiseIfNotThrown?: boolean | undefined;
1533 }, {}, {}];
1534 } & {
1535 env: [{
1536 envs: NodeJS.ProcessEnv[];
1537 }, {
1538 [k: string]: string | undefined;
1539 }, EnvOptions, {}, {}];
1540 } & {
1541 stub: [{
1542 stubs: any[];
1543 }, any, string, any, {}];
1544 } & {
1545 nock: [{
1546 nock: number;
1547 }, string, (nock: NockScope) => any, {}, {}];
1548 } & {
1549 stderr: [{
1550 readonly stderr: string;
1551 }, {
1552 print?: boolean | undefined;
1553 stripColor?: boolean | undefined;
1554 }, {}, {}, {}];
1555 } & {
1556 stdout: [{
1557 readonly stdout: string;
1558 }, {
1559 print?: boolean | undefined;
1560 stripColor?: boolean | undefined;
1561 }, {}, {}, {}];
1562 } & {
1563 command: [{
1564 expectation: string;
1565 }, string | string[], Options, {}, {}];
1566 } & {
1567 exit: [{
1568 error: any;
1569 }, number, {}, {}, {}];
1570 } & {
1571 hook: [{
1572 expectation: string;
1573 }, string, object, Options, {}];
1574 } & {
1575 [P in K]: [O, A1, A2, A3, A4];
1576 })["stdout"][1] | undefined, arg2?: ({
1577 skip: [{}, {}, {}, {}, {}];
1578 } & {
1579 only: [{}, {}, {}, {}, {}];
1580 } & {
1581 catch: [{
1582 error: Error;
1583 }, string | RegExp | ((err: Error) => any), {
1584 raiseIfNotThrown?: boolean | undefined;
1585 }, {}, {}];
1586 } & {
1587 env: [{
1588 envs: NodeJS.ProcessEnv[];
1589 }, {
1590 [k: string]: string | undefined;
1591 }, EnvOptions, {}, {}];
1592 } & {
1593 stub: [{
1594 stubs: any[];
1595 }, any, string, any, {}];
1596 } & {
1597 nock: [{
1598 nock: number;
1599 }, string, (nock: NockScope) => any, {}, {}];
1600 } & {
1601 stderr: [{
1602 readonly stderr: string;
1603 }, {
1604 print?: boolean | undefined;
1605 stripColor?: boolean | undefined;
1606 }, {}, {}, {}];
1607 } & {
1608 stdout: [{
1609 readonly stdout: string;
1610 }, {
1611 print?: boolean | undefined;
1612 stripColor?: boolean | undefined;
1613 }, {}, {}, {}];
1614 } & {
1615 command: [{
1616 expectation: string;
1617 }, string | string[], Options, {}, {}];
1618 } & {
1619 exit: [{
1620 error: any;
1621 }, number, {}, {}, {}];
1622 } & {
1623 hook: [{
1624 expectation: string;
1625 }, string, object, Options, {}];
1626 } & {
1627 [P in K]: [O, A1, A2, A3, A4];
1628 })["stdout"][2] | undefined, arg3?: ({
1629 skip: [{}, {}, {}, {}, {}];
1630 } & {
1631 only: [{}, {}, {}, {}, {}];
1632 } & {
1633 catch: [{
1634 error: Error;
1635 }, string | RegExp | ((err: Error) => any), {
1636 raiseIfNotThrown?: boolean | undefined;
1637 }, {}, {}];
1638 } & {
1639 env: [{
1640 envs: NodeJS.ProcessEnv[];
1641 }, {
1642 [k: string]: string | undefined;
1643 }, EnvOptions, {}, {}];
1644 } & {
1645 stub: [{
1646 stubs: any[];
1647 }, any, string, any, {}];
1648 } & {
1649 nock: [{
1650 nock: number;
1651 }, string, (nock: NockScope) => any, {}, {}];
1652 } & {
1653 stderr: [{
1654 readonly stderr: string;
1655 }, {
1656 print?: boolean | undefined;
1657 stripColor?: boolean | undefined;
1658 }, {}, {}, {}];
1659 } & {
1660 stdout: [{
1661 readonly stdout: string;
1662 }, {
1663 print?: boolean | undefined;
1664 stripColor?: boolean | undefined;
1665 }, {}, {}, {}];
1666 } & {
1667 command: [{
1668 expectation: string;
1669 }, string | string[], Options, {}, {}];
1670 } & {
1671 exit: [{
1672 error: any;
1673 }, number, {}, {}, {}];
1674 } & {
1675 hook: [{
1676 expectation: string;
1677 }, string, object, Options, {}];
1678 } & {
1679 [P in K]: [O, A1, A2, A3, A4];
1680 })["stdout"][3] | undefined, arg4?: ({
1681 skip: [{}, {}, {}, {}, {}];
1682 } & {
1683 only: [{}, {}, {}, {}, {}];
1684 } & {
1685 catch: [{
1686 error: Error;
1687 }, string | RegExp | ((err: Error) => any), {
1688 raiseIfNotThrown?: boolean | undefined;
1689 }, {}, {}];
1690 } & {
1691 env: [{
1692 envs: NodeJS.ProcessEnv[];
1693 }, {
1694 [k: string]: string | undefined;
1695 }, EnvOptions, {}, {}];
1696 } & {
1697 stub: [{
1698 stubs: any[];
1699 }, any, string, any, {}];
1700 } & {
1701 nock: [{
1702 nock: number;
1703 }, string, (nock: NockScope) => any, {}, {}];
1704 } & {
1705 stderr: [{
1706 readonly stderr: string;
1707 }, {
1708 print?: boolean | undefined;
1709 stripColor?: boolean | undefined;
1710 }, {}, {}, {}];
1711 } & {
1712 stdout: [{
1713 readonly stdout: string;
1714 }, {
1715 print?: boolean | undefined;
1716 stripColor?: boolean | undefined;
1717 }, {}, {}, {}];
1718 } & {
1719 command: [{
1720 expectation: string;
1721 }, string | string[], Options, {}, {}];
1722 } & {
1723 exit: [{
1724 error: any;
1725 }, number, {}, {}, {}];
1726 } & {
1727 hook: [{
1728 expectation: string;
1729 }, string, object, Options, {}];
1730 } & {
1731 [P in K]: [O, A1, A2, A3, A4];
1732 })["stdout"][4] | undefined) => any & any;
1733 command: (arg1?: ({
1734 skip: [{}, {}, {}, {}, {}];
1735 } & {
1736 only: [{}, {}, {}, {}, {}];
1737 } & {
1738 catch: [{
1739 error: Error;
1740 }, string | RegExp | ((err: Error) => any), {
1741 raiseIfNotThrown?: boolean | undefined;
1742 }, {}, {}];
1743 } & {
1744 env: [{
1745 envs: NodeJS.ProcessEnv[];
1746 }, {
1747 [k: string]: string | undefined;
1748 }, EnvOptions, {}, {}];
1749 } & {
1750 stub: [{
1751 stubs: any[];
1752 }, any, string, any, {}];
1753 } & {
1754 nock: [{
1755 nock: number;
1756 }, string, (nock: NockScope) => any, {}, {}];
1757 } & {
1758 stderr: [{
1759 readonly stderr: string;
1760 }, {
1761 print?: boolean | undefined;
1762 stripColor?: boolean | undefined;
1763 }, {}, {}, {}];
1764 } & {
1765 stdout: [{
1766 readonly stdout: string;
1767 }, {
1768 print?: boolean | undefined;
1769 stripColor?: boolean | undefined;
1770 }, {}, {}, {}];
1771 } & {
1772 command: [{
1773 expectation: string;
1774 }, string | string[], Options, {}, {}];
1775 } & {
1776 exit: [{
1777 error: any;
1778 }, number, {}, {}, {}];
1779 } & {
1780 hook: [{
1781 expectation: string;
1782 }, string, object, Options, {}];
1783 } & {
1784 [P in K]: [O, A1, A2, A3, A4];
1785 })["command"][1] | undefined, arg2?: ({
1786 skip: [{}, {}, {}, {}, {}];
1787 } & {
1788 only: [{}, {}, {}, {}, {}];
1789 } & {
1790 catch: [{
1791 error: Error;
1792 }, string | RegExp | ((err: Error) => any), {
1793 raiseIfNotThrown?: boolean | undefined;
1794 }, {}, {}];
1795 } & {
1796 env: [{
1797 envs: NodeJS.ProcessEnv[];
1798 }, {
1799 [k: string]: string | undefined;
1800 }, EnvOptions, {}, {}];
1801 } & {
1802 stub: [{
1803 stubs: any[];
1804 }, any, string, any, {}];
1805 } & {
1806 nock: [{
1807 nock: number;
1808 }, string, (nock: NockScope) => any, {}, {}];
1809 } & {
1810 stderr: [{
1811 readonly stderr: string;
1812 }, {
1813 print?: boolean | undefined;
1814 stripColor?: boolean | undefined;
1815 }, {}, {}, {}];
1816 } & {
1817 stdout: [{
1818 readonly stdout: string;
1819 }, {
1820 print?: boolean | undefined;
1821 stripColor?: boolean | undefined;
1822 }, {}, {}, {}];
1823 } & {
1824 command: [{
1825 expectation: string;
1826 }, string | string[], Options, {}, {}];
1827 } & {
1828 exit: [{
1829 error: any;
1830 }, number, {}, {}, {}];
1831 } & {
1832 hook: [{
1833 expectation: string;
1834 }, string, object, Options, {}];
1835 } & {
1836 [P in K]: [O, A1, A2, A3, A4];
1837 })["command"][2] | undefined, arg3?: ({
1838 skip: [{}, {}, {}, {}, {}];
1839 } & {
1840 only: [{}, {}, {}, {}, {}];
1841 } & {
1842 catch: [{
1843 error: Error;
1844 }, string | RegExp | ((err: Error) => any), {
1845 raiseIfNotThrown?: boolean | undefined;
1846 }, {}, {}];
1847 } & {
1848 env: [{
1849 envs: NodeJS.ProcessEnv[];
1850 }, {
1851 [k: string]: string | undefined;
1852 }, EnvOptions, {}, {}];
1853 } & {
1854 stub: [{
1855 stubs: any[];
1856 }, any, string, any, {}];
1857 } & {
1858 nock: [{
1859 nock: number;
1860 }, string, (nock: NockScope) => any, {}, {}];
1861 } & {
1862 stderr: [{
1863 readonly stderr: string;
1864 }, {
1865 print?: boolean | undefined;
1866 stripColor?: boolean | undefined;
1867 }, {}, {}, {}];
1868 } & {
1869 stdout: [{
1870 readonly stdout: string;
1871 }, {
1872 print?: boolean | undefined;
1873 stripColor?: boolean | undefined;
1874 }, {}, {}, {}];
1875 } & {
1876 command: [{
1877 expectation: string;
1878 }, string | string[], Options, {}, {}];
1879 } & {
1880 exit: [{
1881 error: any;
1882 }, number, {}, {}, {}];
1883 } & {
1884 hook: [{
1885 expectation: string;
1886 }, string, object, Options, {}];
1887 } & {
1888 [P in K]: [O, A1, A2, A3, A4];
1889 })["command"][3] | undefined, arg4?: ({
1890 skip: [{}, {}, {}, {}, {}];
1891 } & {
1892 only: [{}, {}, {}, {}, {}];
1893 } & {
1894 catch: [{
1895 error: Error;
1896 }, string | RegExp | ((err: Error) => any), {
1897 raiseIfNotThrown?: boolean | undefined;
1898 }, {}, {}];
1899 } & {
1900 env: [{
1901 envs: NodeJS.ProcessEnv[];
1902 }, {
1903 [k: string]: string | undefined;
1904 }, EnvOptions, {}, {}];
1905 } & {
1906 stub: [{
1907 stubs: any[];
1908 }, any, string, any, {}];
1909 } & {
1910 nock: [{
1911 nock: number;
1912 }, string, (nock: NockScope) => any, {}, {}];
1913 } & {
1914 stderr: [{
1915 readonly stderr: string;
1916 }, {
1917 print?: boolean | undefined;
1918 stripColor?: boolean | undefined;
1919 }, {}, {}, {}];
1920 } & {
1921 stdout: [{
1922 readonly stdout: string;
1923 }, {
1924 print?: boolean | undefined;
1925 stripColor?: boolean | undefined;
1926 }, {}, {}, {}];
1927 } & {
1928 command: [{
1929 expectation: string;
1930 }, string | string[], Options, {}, {}];
1931 } & {
1932 exit: [{
1933 error: any;
1934 }, number, {}, {}, {}];
1935 } & {
1936 hook: [{
1937 expectation: string;
1938 }, string, object, Options, {}];
1939 } & {
1940 [P in K]: [O, A1, A2, A3, A4];
1941 })["command"][4] | undefined) => any & any;
1942 exit: (arg1?: ({
1943 skip: [{}, {}, {}, {}, {}];
1944 } & {
1945 only: [{}, {}, {}, {}, {}];
1946 } & {
1947 catch: [{
1948 error: Error;
1949 }, string | RegExp | ((err: Error) => any), {
1950 raiseIfNotThrown?: boolean | undefined;
1951 }, {}, {}];
1952 } & {
1953 env: [{
1954 envs: NodeJS.ProcessEnv[];
1955 }, {
1956 [k: string]: string | undefined;
1957 }, EnvOptions, {}, {}];
1958 } & {
1959 stub: [{
1960 stubs: any[];
1961 }, any, string, any, {}];
1962 } & {
1963 nock: [{
1964 nock: number;
1965 }, string, (nock: NockScope) => any, {}, {}];
1966 } & {
1967 stderr: [{
1968 readonly stderr: string;
1969 }, {
1970 print?: boolean | undefined;
1971 stripColor?: boolean | undefined;
1972 }, {}, {}, {}];
1973 } & {
1974 stdout: [{
1975 readonly stdout: string;
1976 }, {
1977 print?: boolean | undefined;
1978 stripColor?: boolean | undefined;
1979 }, {}, {}, {}];
1980 } & {
1981 command: [{
1982 expectation: string;
1983 }, string | string[], Options, {}, {}];
1984 } & {
1985 exit: [{
1986 error: any;
1987 }, number, {}, {}, {}];
1988 } & {
1989 hook: [{
1990 expectation: string;
1991 }, string, object, Options, {}];
1992 } & {
1993 [P in K]: [O, A1, A2, A3, A4];
1994 })["exit"][1] | undefined, arg2?: ({
1995 skip: [{}, {}, {}, {}, {}];
1996 } & {
1997 only: [{}, {}, {}, {}, {}];
1998 } & {
1999 catch: [{
2000 error: Error;
2001 }, string | RegExp | ((err: Error) => any), {
2002 raiseIfNotThrown?: boolean | undefined;
2003 }, {}, {}];
2004 } & {
2005 env: [{
2006 envs: NodeJS.ProcessEnv[];
2007 }, {
2008 [k: string]: string | undefined;
2009 }, EnvOptions, {}, {}];
2010 } & {
2011 stub: [{
2012 stubs: any[];
2013 }, any, string, any, {}];
2014 } & {
2015 nock: [{
2016 nock: number;
2017 }, string, (nock: NockScope) => any, {}, {}];
2018 } & {
2019 stderr: [{
2020 readonly stderr: string;
2021 }, {
2022 print?: boolean | undefined;
2023 stripColor?: boolean | undefined;
2024 }, {}, {}, {}];
2025 } & {
2026 stdout: [{
2027 readonly stdout: string;
2028 }, {
2029 print?: boolean | undefined;
2030 stripColor?: boolean | undefined;
2031 }, {}, {}, {}];
2032 } & {
2033 command: [{
2034 expectation: string;
2035 }, string | string[], Options, {}, {}];
2036 } & {
2037 exit: [{
2038 error: any;
2039 }, number, {}, {}, {}];
2040 } & {
2041 hook: [{
2042 expectation: string;
2043 }, string, object, Options, {}];
2044 } & {
2045 [P in K]: [O, A1, A2, A3, A4];
2046 })["exit"][2] | undefined, arg3?: ({
2047 skip: [{}, {}, {}, {}, {}];
2048 } & {
2049 only: [{}, {}, {}, {}, {}];
2050 } & {
2051 catch: [{
2052 error: Error;
2053 }, string | RegExp | ((err: Error) => any), {
2054 raiseIfNotThrown?: boolean | undefined;
2055 }, {}, {}];
2056 } & {
2057 env: [{
2058 envs: NodeJS.ProcessEnv[];
2059 }, {
2060 [k: string]: string | undefined;
2061 }, EnvOptions, {}, {}];
2062 } & {
2063 stub: [{
2064 stubs: any[];
2065 }, any, string, any, {}];
2066 } & {
2067 nock: [{
2068 nock: number;
2069 }, string, (nock: NockScope) => any, {}, {}];
2070 } & {
2071 stderr: [{
2072 readonly stderr: string;
2073 }, {
2074 print?: boolean | undefined;
2075 stripColor?: boolean | undefined;
2076 }, {}, {}, {}];
2077 } & {
2078 stdout: [{
2079 readonly stdout: string;
2080 }, {
2081 print?: boolean | undefined;
2082 stripColor?: boolean | undefined;
2083 }, {}, {}, {}];
2084 } & {
2085 command: [{
2086 expectation: string;
2087 }, string | string[], Options, {}, {}];
2088 } & {
2089 exit: [{
2090 error: any;
2091 }, number, {}, {}, {}];
2092 } & {
2093 hook: [{
2094 expectation: string;
2095 }, string, object, Options, {}];
2096 } & {
2097 [P in K]: [O, A1, A2, A3, A4];
2098 })["exit"][3] | undefined, arg4?: ({
2099 skip: [{}, {}, {}, {}, {}];
2100 } & {
2101 only: [{}, {}, {}, {}, {}];
2102 } & {
2103 catch: [{
2104 error: Error;
2105 }, string | RegExp | ((err: Error) => any), {
2106 raiseIfNotThrown?: boolean | undefined;
2107 }, {}, {}];
2108 } & {
2109 env: [{
2110 envs: NodeJS.ProcessEnv[];
2111 }, {
2112 [k: string]: string | undefined;
2113 }, EnvOptions, {}, {}];
2114 } & {
2115 stub: [{
2116 stubs: any[];
2117 }, any, string, any, {}];
2118 } & {
2119 nock: [{
2120 nock: number;
2121 }, string, (nock: NockScope) => any, {}, {}];
2122 } & {
2123 stderr: [{
2124 readonly stderr: string;
2125 }, {
2126 print?: boolean | undefined;
2127 stripColor?: boolean | undefined;
2128 }, {}, {}, {}];
2129 } & {
2130 stdout: [{
2131 readonly stdout: string;
2132 }, {
2133 print?: boolean | undefined;
2134 stripColor?: boolean | undefined;
2135 }, {}, {}, {}];
2136 } & {
2137 command: [{
2138 expectation: string;
2139 }, string | string[], Options, {}, {}];
2140 } & {
2141 exit: [{
2142 error: any;
2143 }, number, {}, {}, {}];
2144 } & {
2145 hook: [{
2146 expectation: string;
2147 }, string, object, Options, {}];
2148 } & {
2149 [P in K]: [O, A1, A2, A3, A4];
2150 })["exit"][4] | undefined) => any & any;
2151 hook: (arg1?: ({
2152 skip: [{}, {}, {}, {}, {}];
2153 } & {
2154 only: [{}, {}, {}, {}, {}];
2155 } & {
2156 catch: [{
2157 error: Error;
2158 }, string | RegExp | ((err: Error) => any), {
2159 raiseIfNotThrown?: boolean | undefined;
2160 }, {}, {}];
2161 } & {
2162 env: [{
2163 envs: NodeJS.ProcessEnv[];
2164 }, {
2165 [k: string]: string | undefined;
2166 }, EnvOptions, {}, {}];
2167 } & {
2168 stub: [{
2169 stubs: any[];
2170 }, any, string, any, {}];
2171 } & {
2172 nock: [{
2173 nock: number;
2174 }, string, (nock: NockScope) => any, {}, {}];
2175 } & {
2176 stderr: [{
2177 readonly stderr: string;
2178 }, {
2179 print?: boolean | undefined;
2180 stripColor?: boolean | undefined;
2181 }, {}, {}, {}];
2182 } & {
2183 stdout: [{
2184 readonly stdout: string;
2185 }, {
2186 print?: boolean | undefined;
2187 stripColor?: boolean | undefined;
2188 }, {}, {}, {}];
2189 } & {
2190 command: [{
2191 expectation: string;
2192 }, string | string[], Options, {}, {}];
2193 } & {
2194 exit: [{
2195 error: any;
2196 }, number, {}, {}, {}];
2197 } & {
2198 hook: [{
2199 expectation: string;
2200 }, string, object, Options, {}];
2201 } & {
2202 [P in K]: [O, A1, A2, A3, A4];
2203 })["hook"][1] | undefined, arg2?: ({
2204 skip: [{}, {}, {}, {}, {}];
2205 } & {
2206 only: [{}, {}, {}, {}, {}];
2207 } & {
2208 catch: [{
2209 error: Error;
2210 }, string | RegExp | ((err: Error) => any), {
2211 raiseIfNotThrown?: boolean | undefined;
2212 }, {}, {}];
2213 } & {
2214 env: [{
2215 envs: NodeJS.ProcessEnv[];
2216 }, {
2217 [k: string]: string | undefined;
2218 }, EnvOptions, {}, {}];
2219 } & {
2220 stub: [{
2221 stubs: any[];
2222 }, any, string, any, {}];
2223 } & {
2224 nock: [{
2225 nock: number;
2226 }, string, (nock: NockScope) => any, {}, {}];
2227 } & {
2228 stderr: [{
2229 readonly stderr: string;
2230 }, {
2231 print?: boolean | undefined;
2232 stripColor?: boolean | undefined;
2233 }, {}, {}, {}];
2234 } & {
2235 stdout: [{
2236 readonly stdout: string;
2237 }, {
2238 print?: boolean | undefined;
2239 stripColor?: boolean | undefined;
2240 }, {}, {}, {}];
2241 } & {
2242 command: [{
2243 expectation: string;
2244 }, string | string[], Options, {}, {}];
2245 } & {
2246 exit: [{
2247 error: any;
2248 }, number, {}, {}, {}];
2249 } & {
2250 hook: [{
2251 expectation: string;
2252 }, string, object, Options, {}];
2253 } & {
2254 [P in K]: [O, A1, A2, A3, A4];
2255 })["hook"][2] | undefined, arg3?: ({
2256 skip: [{}, {}, {}, {}, {}];
2257 } & {
2258 only: [{}, {}, {}, {}, {}];
2259 } & {
2260 catch: [{
2261 error: Error;
2262 }, string | RegExp | ((err: Error) => any), {
2263 raiseIfNotThrown?: boolean | undefined;
2264 }, {}, {}];
2265 } & {
2266 env: [{
2267 envs: NodeJS.ProcessEnv[];
2268 }, {
2269 [k: string]: string | undefined;
2270 }, EnvOptions, {}, {}];
2271 } & {
2272 stub: [{
2273 stubs: any[];
2274 }, any, string, any, {}];
2275 } & {
2276 nock: [{
2277 nock: number;
2278 }, string, (nock: NockScope) => any, {}, {}];
2279 } & {
2280 stderr: [{
2281 readonly stderr: string;
2282 }, {
2283 print?: boolean | undefined;
2284 stripColor?: boolean | undefined;
2285 }, {}, {}, {}];
2286 } & {
2287 stdout: [{
2288 readonly stdout: string;
2289 }, {
2290 print?: boolean | undefined;
2291 stripColor?: boolean | undefined;
2292 }, {}, {}, {}];
2293 } & {
2294 command: [{
2295 expectation: string;
2296 }, string | string[], Options, {}, {}];
2297 } & {
2298 exit: [{
2299 error: any;
2300 }, number, {}, {}, {}];
2301 } & {
2302 hook: [{
2303 expectation: string;
2304 }, string, object, Options, {}];
2305 } & {
2306 [P in K]: [O, A1, A2, A3, A4];
2307 })["hook"][3] | undefined, arg4?: ({
2308 skip: [{}, {}, {}, {}, {}];
2309 } & {
2310 only: [{}, {}, {}, {}, {}];
2311 } & {
2312 catch: [{
2313 error: Error;
2314 }, string | RegExp | ((err: Error) => any), {
2315 raiseIfNotThrown?: boolean | undefined;
2316 }, {}, {}];
2317 } & {
2318 env: [{
2319 envs: NodeJS.ProcessEnv[];
2320 }, {
2321 [k: string]: string | undefined;
2322 }, EnvOptions, {}, {}];
2323 } & {
2324 stub: [{
2325 stubs: any[];
2326 }, any, string, any, {}];
2327 } & {
2328 nock: [{
2329 nock: number;
2330 }, string, (nock: NockScope) => any, {}, {}];
2331 } & {
2332 stderr: [{
2333 readonly stderr: string;
2334 }, {
2335 print?: boolean | undefined;
2336 stripColor?: boolean | undefined;
2337 }, {}, {}, {}];
2338 } & {
2339 stdout: [{
2340 readonly stdout: string;
2341 }, {
2342 print?: boolean | undefined;
2343 stripColor?: boolean | undefined;
2344 }, {}, {}, {}];
2345 } & {
2346 command: [{
2347 expectation: string;
2348 }, string | string[], Options, {}, {}];
2349 } & {
2350 exit: [{
2351 error: any;
2352 }, number, {}, {}, {}];
2353 } & {
2354 hook: [{
2355 expectation: string;
2356 }, string, object, Options, {}];
2357 } & {
2358 [P in K]: [O, A1, A2, A3, A4];
2359 })["hook"][4] | undefined) => any & any;
2360 };
2361} & {
2362 skip: (arg1?: {} | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => {
2363 it: {
2364 (expectation: string, cb?: ((context: Context) => any) | undefined): void;
2365 (cb?: ((context: Context) => any) | undefined): void;
2366 };
2367 end: {
2368 (expectation: string, cb?: ((context: Context) => any) | undefined): void;
2369 (cb?: ((context: Context) => any) | undefined): void;
2370 };
2371 add<K extends string, O>(key: K, cb: (context: Context) => O | Promise<O>): any & any;
2372 do(cb: (context: Context) => any): any & any;
2373 register<K extends string, O, A1, A2, A3, A4>(key: K, plugin: (arg1?: A1 | undefined, arg2?: A2 | undefined, arg3?: A3 | undefined, arg4?: A4 | undefined) => Plugin<O & Context>): any & any;
2374 } & any;
2375 only: (arg1?: {} | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => {
2376 it: {
2377 (expectation: string, cb?: ((context: Context) => any) | undefined): void;
2378 (cb?: ((context: Context) => any) | undefined): void;
2379 };
2380 end: {
2381 (expectation: string, cb?: ((context: Context) => any) | undefined): void;
2382 (cb?: ((context: Context) => any) | undefined): void;
2383 };
2384 add<K extends string, O>(key: K, cb: (context: Context) => O | Promise<O>): any & any;
2385 do(cb: (context: Context) => any): any & any;
2386 register<K extends string, O, A1, A2, A3, A4>(key: K, plugin: (arg1?: A1 | undefined, arg2?: A2 | undefined, arg3?: A3 | undefined, arg4?: A4 | undefined) => Plugin<O & Context>): any & any;
2387 } & any;
2388 catch: (arg1?: string | RegExp | ((err: Error) => any) | undefined, arg2?: {
2389 raiseIfNotThrown?: boolean | undefined;
2390 } | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => {
2391 it: {
2392 (expectation: string, cb?: ((context: {
2393 error: Error;
2394 } & Context) => any) | undefined): void;
2395 (cb?: ((context: {
2396 error: Error;
2397 } & Context) => any) | undefined): void;
2398 };
2399 end: {
2400 (expectation: string, cb?: ((context: {
2401 error: Error;
2402 } & Context) => any) | undefined): void;
2403 (cb?: ((context: {
2404 error: Error;
2405 } & Context) => any) | undefined): void;
2406 };
2407 add<K extends string, O>(key: K, cb: (context: {
2408 error: Error;
2409 } & Context) => O | Promise<O>): any & any;
2410 do(cb: (context: {
2411 error: Error;
2412 } & Context) => any): any & any;
2413 register<K extends string, O, A1, A2, A3, A4>(key: K, plugin: (arg1?: A1 | undefined, arg2?: A2 | undefined, arg3?: A3 | undefined, arg4?: A4 | undefined) => Plugin<O & {
2414 error: Error;
2415 } & Context>): any & any;
2416 } & any;
2417 env: (arg1?: {
2418 [k: string]: string | undefined;
2419 } | undefined, arg2?: EnvOptions | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => {
2420 it: {
2421 (expectation: string, cb?: ((context: {
2422 envs: NodeJS.ProcessEnv[];
2423 } & Context) => any) | undefined): void;
2424 (cb?: ((context: {
2425 envs: NodeJS.ProcessEnv[];
2426 } & Context) => any) | undefined): void;
2427 };
2428 end: {
2429 (expectation: string, cb?: ((context: {
2430 envs: NodeJS.ProcessEnv[];
2431 } & Context) => any) | undefined): void;
2432 (cb?: ((context: {
2433 envs: NodeJS.ProcessEnv[];
2434 } & Context) => any) | undefined): void;
2435 };
2436 add<K extends string, O>(key: K, cb: (context: {
2437 envs: NodeJS.ProcessEnv[];
2438 } & Context) => O | Promise<O>): any & any;
2439 do(cb: (context: {
2440 envs: NodeJS.ProcessEnv[];
2441 } & Context) => any): any & any;
2442 register<K extends string, O, A1, A2, A3, A4>(key: K, plugin: (arg1?: A1 | undefined, arg2?: A2 | undefined, arg3?: A3 | undefined, arg4?: A4 | undefined) => Plugin<O & {
2443 envs: NodeJS.ProcessEnv[];
2444 } & Context>): any & any;
2445 } & any;
2446 stub: (arg1?: any, arg2?: string | undefined, arg3?: any, arg4?: {} | undefined) => {
2447 it: {
2448 (expectation: string, cb?: ((context: {
2449 stubs: any[];
2450 } & Context) => any) | undefined): void;
2451 (cb?: ((context: {
2452 stubs: any[];
2453 } & Context) => any) | undefined): void;
2454 };
2455 end: {
2456 (expectation: string, cb?: ((context: {
2457 stubs: any[];
2458 } & Context) => any) | undefined): void;
2459 (cb?: ((context: {
2460 stubs: any[];
2461 } & Context) => any) | undefined): void;
2462 };
2463 add<K extends string, O>(key: K, cb: (context: {
2464 stubs: any[];
2465 } & Context) => O | Promise<O>): any & any;
2466 do(cb: (context: {
2467 stubs: any[];
2468 } & Context) => any): any & any;
2469 register<K extends string, O, A1, A2, A3, A4>(key: K, plugin: (arg1?: A1 | undefined, arg2?: A2 | undefined, arg3?: A3 | undefined, arg4?: A4 | undefined) => Plugin<O & {
2470 stubs: any[];
2471 } & Context>): any & any;
2472 } & any;
2473 nock: (arg1?: string | undefined, arg2?: ((nock: NockScope) => any) | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => {
2474 it: {
2475 (expectation: string, cb?: ((context: {
2476 nock: number;
2477 } & Context) => any) | undefined): void;
2478 (cb?: ((context: {
2479 nock: number;
2480 } & Context) => any) | undefined): void;
2481 };
2482 end: {
2483 (expectation: string, cb?: ((context: {
2484 nock: number;
2485 } & Context) => any) | undefined): void;
2486 (cb?: ((context: {
2487 nock: number;
2488 } & Context) => any) | undefined): void;
2489 };
2490 add<K extends string, O>(key: K, cb: (context: {
2491 nock: number;
2492 } & Context) => O | Promise<O>): any & any;
2493 do(cb: (context: {
2494 nock: number;
2495 } & Context) => any): any & any;
2496 register<K extends string, O, A1, A2, A3, A4>(key: K, plugin: (arg1?: A1 | undefined, arg2?: A2 | undefined, arg3?: A3 | undefined, arg4?: A4 | undefined) => Plugin<O & {
2497 nock: number;
2498 } & Context>): any & any;
2499 } & any;
2500 stderr: (arg1?: {
2501 print?: boolean | undefined;
2502 stripColor?: boolean | undefined;
2503 } | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => {
2504 it: {
2505 (expectation: string, cb?: ((context: {
2506 readonly stderr: string;
2507 } & Context) => any) | undefined): void;
2508 (cb?: ((context: {
2509 readonly stderr: string;
2510 } & Context) => any) | undefined): void;
2511 };
2512 end: {
2513 (expectation: string, cb?: ((context: {
2514 readonly stderr: string;
2515 } & Context) => any) | undefined): void;
2516 (cb?: ((context: {
2517 readonly stderr: string;
2518 } & Context) => any) | undefined): void;
2519 };
2520 add<K extends string, O>(key: K, cb: (context: {
2521 readonly stderr: string;
2522 } & Context) => O | Promise<O>): any & any;
2523 do(cb: (context: {
2524 readonly stderr: string;
2525 } & Context) => any): any & any;
2526 register<K extends string, O, A1, A2, A3, A4>(key: K, plugin: (arg1?: A1 | undefined, arg2?: A2 | undefined, arg3?: A3 | undefined, arg4?: A4 | undefined) => Plugin<O & {
2527 readonly stderr: string;
2528 } & Context>): any & any;
2529 } & any;
2530 stdout: (arg1?: {
2531 print?: boolean | undefined;
2532 stripColor?: boolean | undefined;
2533 } | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => {
2534 it: {
2535 (expectation: string, cb?: ((context: {
2536 readonly stdout: string;
2537 } & Context) => any) | undefined): void;
2538 (cb?: ((context: {
2539 readonly stdout: string;
2540 } & Context) => any) | undefined): void;
2541 };
2542 end: {
2543 (expectation: string, cb?: ((context: {
2544 readonly stdout: string;
2545 } & Context) => any) | undefined): void;
2546 (cb?: ((context: {
2547 readonly stdout: string;
2548 } & Context) => any) | undefined): void;
2549 };
2550 add<K extends string, O>(key: K, cb: (context: {
2551 readonly stdout: string;
2552 } & Context) => O | Promise<O>): any & any;
2553 do(cb: (context: {
2554 readonly stdout: string;
2555 } & Context) => any): any & any;
2556 register<K extends string, O, A1, A2, A3, A4>(key: K, plugin: (arg1?: A1 | undefined, arg2?: A2 | undefined, arg3?: A3 | undefined, arg4?: A4 | undefined) => Plugin<O & {
2557 readonly stdout: string;
2558 } & Context>): any & any;
2559 } & any;
2560 command: (arg1?: string | string[] | undefined, arg2?: Options | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => {
2561 it: {
2562 (expectation: string, cb?: ((context: {
2563 expectation: string;
2564 } & Context) => any) | undefined): void;
2565 (cb?: ((context: {
2566 expectation: string;
2567 } & Context) => any) | undefined): void;
2568 };
2569 end: {
2570 (expectation: string, cb?: ((context: {
2571 expectation: string;
2572 } & Context) => any) | undefined): void;
2573 (cb?: ((context: {
2574 expectation: string;
2575 } & Context) => any) | undefined): void;
2576 };
2577 add<K extends string, O>(key: K, cb: (context: {
2578 expectation: string;
2579 } & Context) => O | Promise<O>): any & any;
2580 do(cb: (context: {
2581 expectation: string;
2582 } & Context) => any): any & any;
2583 register<K extends string, O, A1, A2, A3, A4>(key: K, plugin: (arg1?: A1 | undefined, arg2?: A2 | undefined, arg3?: A3 | undefined, arg4?: A4 | undefined) => Plugin<O & {
2584 expectation: string;
2585 } & Context>): any & any;
2586 } & any;
2587 exit: (arg1?: number | undefined, arg2?: {} | undefined, arg3?: {} | undefined, arg4?: {} | undefined) => {
2588 it: {
2589 (expectation: string, cb?: ((context: {
2590 error: any;
2591 } & Context) => any) | undefined): void;
2592 (cb?: ((context: {
2593 error: any;
2594 } & Context) => any) | undefined): void;
2595 };
2596 end: {
2597 (expectation: string, cb?: ((context: {
2598 error: any;
2599 } & Context) => any) | undefined): void;
2600 (cb?: ((context: {
2601 error: any;
2602 } & Context) => any) | undefined): void;
2603 };
2604 add<K extends string, O>(key: K, cb: (context: {
2605 error: any;
2606 } & Context) => O | Promise<O>): any & any;
2607 do(cb: (context: {
2608 error: any;
2609 } & Context) => any): any & any;
2610 register<K extends string, O, A1, A2, A3, A4>(key: K, plugin: (arg1?: A1 | undefined, arg2?: A2 | undefined, arg3?: A3 | undefined, arg4?: A4 | undefined) => Plugin<O & {
2611 error: any;
2612 } & Context>): any & any;
2613 } & any;
2614 hook: (arg1?: string | undefined, arg2?: object | undefined, arg3?: Options | undefined, arg4?: {} | undefined) => {
2615 it: {
2616 (expectation: string, cb?: ((context: {
2617 expectation: string;
2618 } & Context) => any) | undefined): void;
2619 (cb?: ((context: {
2620 expectation: string;
2621 } & Context) => any) | undefined): void;
2622 };
2623 end: {
2624 (expectation: string, cb?: ((context: {
2625 expectation: string;
2626 } & Context) => any) | undefined): void;
2627 (cb?: ((context: {
2628 expectation: string;
2629 } & Context) => any) | undefined): void;
2630 };
2631 add<K extends string, O>(key: K, cb: (context: {
2632 expectation: string;
2633 } & Context) => O | Promise<O>): any & any;
2634 do(cb: (context: {
2635 expectation: string;
2636 } & Context) => any): any & any;
2637 register<K extends string, O, A1, A2, A3, A4>(key: K, plugin: (arg1?: A1 | undefined, arg2?: A2 | undefined, arg3?: A3 | undefined, arg4?: A4 | undefined) => Plugin<O & {
2638 expectation: string;
2639 } & Context>): any & any;
2640 } & any;
2641};
2642export default test;
2643export { Context, EnvOptions, NockScope, Options, Plugin, expect };
2644
\No newline at end of file