@scalar/openapi-parser 0.8.3 → 0.8.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (10) hide show
  1. package/CHANGELOG.md +6 -0
  2. package/dist/utils/openapi/commands/dereferenceCommand.d.ts +3 -3
  3. package/dist/utils/openapi/commands/filterCommand.d.ts +6 -6
  4. package/dist/utils/openapi/commands/loadCommand.d.ts +900 -900
  5. package/dist/utils/openapi/commands/upgradeCommand.d.ts +264 -264
  6. package/dist/utils/openapi/commands/validateCommand.d.ts +264 -264
  7. package/dist/utils/openapi/openapi.d.ts +585 -585
  8. package/dist/utils/upgradeFromTwoToThree.d.ts.map +1 -1
  9. package/dist/utils/upgradeFromTwoToThree.js +1 -1
  10. package/package.json +1 -1
package/dist/utils/openapi/commands/loadCommand.d.ts CHANGED
@@ -18,14 +18,14 @@ declare global {
18
18
  */
19
19
  export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, input: AnyApiDefinitionFormat, options?: LoadOptions): {
20
20
  dereference: (dereferenceOptions?: DereferenceOptions) => {
21
- details: () => Promise<import("../../../types").DetailsResult>;
22
- files: () => Promise<import("../../../types").Filesystem>;
23
- get: () => Promise<import("../../../types").CommandChain<[...T, {
21
+ details: () => Promise<import("../../../index.js").DetailsResult>;
22
+ files: () => Promise<import("../../../index.js").Filesystem>;
23
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
24
24
  readonly name: "load";
25
25
  readonly options: {
26
- readonly plugins?: import("../../load").LoadPlugin[];
26
+ readonly plugins?: import("../..").LoadPlugin[];
27
27
  readonly filename?: string;
28
- readonly filesystem?: import("../../../types").Filesystem;
28
+ readonly filesystem?: import("../../../index.js").Filesystem;
29
29
  throwOnError: boolean;
30
30
  };
31
31
  }, {
@@ -35,18 +35,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
35
35
  toJson: () => Promise<string>;
36
36
  toYaml: () => Promise<string>;
37
37
  };
38
- details: () => Promise<import("../../../types").DetailsResult>;
39
- files: () => Promise<import("../../../types").Filesystem>;
38
+ details: () => Promise<import("../../../index.js").DetailsResult>;
39
+ files: () => Promise<import("../../../index.js").Filesystem>;
40
40
  filter: (callback: (specification: AnyObject) => boolean) => {
41
41
  dereference: (dereferenceOptions?: DereferenceOptions) => {
42
- details: () => Promise<import("../../../types").DetailsResult>;
43
- files: () => Promise<import("../../../types").Filesystem>;
44
- get: () => Promise<import("../../../types").CommandChain<[...T, {
42
+ details: () => Promise<import("../../../index.js").DetailsResult>;
43
+ files: () => Promise<import("../../../index.js").Filesystem>;
44
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
45
45
  readonly name: "load";
46
46
  readonly options: {
47
- readonly plugins?: import("../../load").LoadPlugin[];
47
+ readonly plugins?: import("../..").LoadPlugin[];
48
48
  readonly filename?: string;
49
- readonly filesystem?: import("../../../types").Filesystem;
49
+ readonly filesystem?: import("../../../index.js").Filesystem;
50
50
  throwOnError: boolean;
51
51
  };
52
52
  }, {
@@ -59,14 +59,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
59
59
  toJson: () => Promise<string>;
60
60
  toYaml: () => Promise<string>;
61
61
  };
62
- details: () => Promise<import("../../../types").DetailsResult>;
63
- files: () => Promise<import("../../../types").Filesystem>;
64
- get: () => Promise<import("../../../types").CommandChain<[...T, {
62
+ details: () => Promise<import("../../../index.js").DetailsResult>;
63
+ files: () => Promise<import("../../../index.js").Filesystem>;
64
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
65
65
  readonly name: "load";
66
66
  readonly options: {
67
- readonly plugins?: import("../../load").LoadPlugin[];
67
+ readonly plugins?: import("../..").LoadPlugin[];
68
68
  readonly filename?: string;
69
- readonly filesystem?: import("../../../types").Filesystem;
69
+ readonly filesystem?: import("../../../index.js").Filesystem;
70
70
  throwOnError: boolean;
71
71
  };
72
72
  }, {
@@ -76,25 +76,25 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
76
76
  toJson: () => Promise<string>;
77
77
  toYaml: () => Promise<string>;
78
78
  };
79
- get: () => Promise<import("../../../types").CommandChain<[...T, {
79
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
80
80
  readonly name: "load";
81
81
  readonly options: {
82
- readonly plugins?: import("../../load").LoadPlugin[];
82
+ readonly plugins?: import("../..").LoadPlugin[];
83
83
  readonly filename?: string;
84
- readonly filesystem?: import("../../../types").Filesystem;
84
+ readonly filesystem?: import("../../../index.js").Filesystem;
85
85
  throwOnError: boolean;
86
86
  };
87
87
  }]>>;
88
88
  upgrade: () => {
89
89
  dereference: (dereferenceOptions?: DereferenceOptions) => {
90
- details: () => Promise<import("../../../types").DetailsResult>;
91
- files: () => Promise<import("../../../types").Filesystem>;
92
- get: () => Promise<import("../../../types").CommandChain<[...T, {
90
+ details: () => Promise<import("../../../index.js").DetailsResult>;
91
+ files: () => Promise<import("../../../index.js").Filesystem>;
92
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
93
93
  readonly name: "load";
94
94
  readonly options: {
95
- readonly plugins?: import("../../load").LoadPlugin[];
95
+ readonly plugins?: import("../..").LoadPlugin[];
96
96
  readonly filename?: string;
97
- readonly filesystem?: import("../../../types").Filesystem;
97
+ readonly filesystem?: import("../../../index.js").Filesystem;
98
98
  throwOnError: boolean;
99
99
  };
100
100
  }, {
@@ -106,18 +106,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
106
106
  toJson: () => Promise<string>;
107
107
  toYaml: () => Promise<string>;
108
108
  };
109
- details: () => Promise<import("../../../types").DetailsResult>;
110
- files: () => Promise<import("../../../types").Filesystem>;
109
+ details: () => Promise<import("../../../index.js").DetailsResult>;
110
+ files: () => Promise<import("../../../index.js").Filesystem>;
111
111
  filter: (callback: (specification: AnyObject) => boolean) => {
112
112
  dereference: (dereferenceOptions?: DereferenceOptions) => {
113
- details: () => Promise<import("../../../types").DetailsResult>;
114
- files: () => Promise<import("../../../types").Filesystem>;
115
- get: () => Promise<import("../../../types").CommandChain<[...T, {
113
+ details: () => Promise<import("../../../index.js").DetailsResult>;
114
+ files: () => Promise<import("../../../index.js").Filesystem>;
115
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
116
116
  readonly name: "load";
117
117
  readonly options: {
118
- readonly plugins?: import("../../load").LoadPlugin[];
118
+ readonly plugins?: import("../..").LoadPlugin[];
119
119
  readonly filename?: string;
120
- readonly filesystem?: import("../../../types").Filesystem;
120
+ readonly filesystem?: import("../../../index.js").Filesystem;
121
121
  throwOnError: boolean;
122
122
  };
123
123
  }, {
@@ -132,14 +132,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
132
132
  toJson: () => Promise<string>;
133
133
  toYaml: () => Promise<string>;
134
134
  };
135
- details: () => Promise<import("../../../types").DetailsResult>;
136
- files: () => Promise<import("../../../types").Filesystem>;
137
- get: () => Promise<import("../../../types").CommandChain<[...T, {
135
+ details: () => Promise<import("../../../index.js").DetailsResult>;
136
+ files: () => Promise<import("../../../index.js").Filesystem>;
137
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
138
138
  readonly name: "load";
139
139
  readonly options: {
140
- readonly plugins?: import("../../load").LoadPlugin[];
140
+ readonly plugins?: import("../..").LoadPlugin[];
141
141
  readonly filename?: string;
142
- readonly filesystem?: import("../../../types").Filesystem;
142
+ readonly filesystem?: import("../../../index.js").Filesystem;
143
143
  throwOnError: boolean;
144
144
  };
145
145
  }, {
@@ -151,12 +151,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
151
151
  toJson: () => Promise<string>;
152
152
  toYaml: () => Promise<string>;
153
153
  };
154
- get: () => Promise<import("../../../types").CommandChain<[...T, {
154
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
155
155
  readonly name: "load";
156
156
  readonly options: {
157
- readonly plugins?: import("../../load").LoadPlugin[];
157
+ readonly plugins?: import("../..").LoadPlugin[];
158
158
  readonly filename?: string;
159
- readonly filesystem?: import("../../../types").Filesystem;
159
+ readonly filesystem?: import("../../../index.js").Filesystem;
160
160
  throwOnError: boolean;
161
161
  };
162
162
  }, {
@@ -166,14 +166,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
166
166
  toYaml: () => Promise<string>;
167
167
  validate: (validateOptions?: ValidateOptions) => {
168
168
  dereference: (dereferenceOptions?: DereferenceOptions) => {
169
- details: () => Promise<import("../../../types").DetailsResult>;
170
- files: () => Promise<import("../../../types").Filesystem>;
171
- get: () => Promise<import("../../../types").CommandChain<[...T, {
169
+ details: () => Promise<import("../../../index.js").DetailsResult>;
170
+ files: () => Promise<import("../../../index.js").Filesystem>;
171
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
172
172
  readonly name: "load";
173
173
  readonly options: {
174
- readonly plugins?: import("../../load").LoadPlugin[];
174
+ readonly plugins?: import("../..").LoadPlugin[];
175
175
  readonly filename?: string;
176
- readonly filesystem?: import("../../../types").Filesystem;
176
+ readonly filesystem?: import("../../../index.js").Filesystem;
177
177
  throwOnError: boolean;
178
178
  };
179
179
  }, {
@@ -188,18 +188,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
188
188
  toJson: () => Promise<string>;
189
189
  toYaml: () => Promise<string>;
190
190
  };
191
- details: () => Promise<import("../../../types").DetailsResult>;
192
- files: () => Promise<import("../../../types").Filesystem>;
191
+ details: () => Promise<import("../../../index.js").DetailsResult>;
192
+ files: () => Promise<import("../../../index.js").Filesystem>;
193
193
  filter: (callback: (specification: AnyObject) => boolean) => {
194
194
  dereference: (dereferenceOptions?: DereferenceOptions) => {
195
- details: () => Promise<import("../../../types").DetailsResult>;
196
- files: () => Promise<import("../../../types").Filesystem>;
197
- get: () => Promise<import("../../../types").CommandChain<[...T, {
195
+ details: () => Promise<import("../../../index.js").DetailsResult>;
196
+ files: () => Promise<import("../../../index.js").Filesystem>;
197
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
198
198
  readonly name: "load";
199
199
  readonly options: {
200
- readonly plugins?: import("../../load").LoadPlugin[];
200
+ readonly plugins?: import("../..").LoadPlugin[];
201
201
  readonly filename?: string;
202
- readonly filesystem?: import("../../../types").Filesystem;
202
+ readonly filesystem?: import("../../../index.js").Filesystem;
203
203
  throwOnError: boolean;
204
204
  };
205
205
  }, {
@@ -217,14 +217,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
217
217
  toJson: () => Promise<string>;
218
218
  toYaml: () => Promise<string>;
219
219
  };
220
- details: () => Promise<import("../../../types").DetailsResult>;
221
- files: () => Promise<import("../../../types").Filesystem>;
222
- get: () => Promise<import("../../../types").CommandChain<[...T, {
220
+ details: () => Promise<import("../../../index.js").DetailsResult>;
221
+ files: () => Promise<import("../../../index.js").Filesystem>;
222
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
223
223
  readonly name: "load";
224
224
  readonly options: {
225
- readonly plugins?: import("../../load").LoadPlugin[];
225
+ readonly plugins?: import("../..").LoadPlugin[];
226
226
  readonly filename?: string;
227
- readonly filesystem?: import("../../../types").Filesystem;
227
+ readonly filesystem?: import("../../../index.js").Filesystem;
228
228
  throwOnError: boolean;
229
229
  };
230
230
  }, {
@@ -239,12 +239,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
239
239
  toJson: () => Promise<string>;
240
240
  toYaml: () => Promise<string>;
241
241
  };
242
- get: () => Promise<import("../../../types").CommandChain<[...T, {
242
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
243
243
  readonly name: "load";
244
244
  readonly options: {
245
- readonly plugins?: import("../../load").LoadPlugin[];
245
+ readonly plugins?: import("../..").LoadPlugin[];
246
246
  readonly filename?: string;
247
- readonly filesystem?: import("../../../types").Filesystem;
247
+ readonly filesystem?: import("../../../index.js").Filesystem;
248
248
  throwOnError: boolean;
249
249
  };
250
250
  }, {
@@ -257,14 +257,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
257
257
  toYaml: () => Promise<string>;
258
258
  upgrade: () => {
259
259
  dereference: (dereferenceOptions?: DereferenceOptions) => {
260
- details: () => Promise<import("../../../types").DetailsResult>;
261
- files: () => Promise<import("../../../types").Filesystem>;
262
- get: () => Promise<import("../../../types").CommandChain<[...T, {
260
+ details: () => Promise<import("../../../index.js").DetailsResult>;
261
+ files: () => Promise<import("../../../index.js").Filesystem>;
262
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
263
263
  readonly name: "load";
264
264
  readonly options: {
265
- readonly plugins?: import("../../load").LoadPlugin[];
265
+ readonly plugins?: import("../..").LoadPlugin[];
266
266
  readonly filename?: string;
267
- readonly filesystem?: import("../../../types").Filesystem;
267
+ readonly filesystem?: import("../../../index.js").Filesystem;
268
268
  throwOnError: boolean;
269
269
  };
270
270
  }, {
@@ -281,18 +281,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
281
281
  toJson: () => Promise<string>;
282
282
  toYaml: () => Promise<string>;
283
283
  };
284
- details: () => Promise<import("../../../types").DetailsResult>;
285
- files: () => Promise<import("../../../types").Filesystem>;
284
+ details: () => Promise<import("../../../index.js").DetailsResult>;
285
+ files: () => Promise<import("../../../index.js").Filesystem>;
286
286
  filter: (callback: (specification: AnyObject) => boolean) => {
287
287
  dereference: (dereferenceOptions?: DereferenceOptions) => {
288
- details: () => Promise<import("../../../types").DetailsResult>;
289
- files: () => Promise<import("../../../types").Filesystem>;
290
- get: () => Promise<import("../../../types").CommandChain<[...T, {
288
+ details: () => Promise<import("../../../index.js").DetailsResult>;
289
+ files: () => Promise<import("../../../index.js").Filesystem>;
290
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
291
291
  readonly name: "load";
292
292
  readonly options: {
293
- readonly plugins?: import("../../load").LoadPlugin[];
293
+ readonly plugins?: import("../..").LoadPlugin[];
294
294
  readonly filename?: string;
295
- readonly filesystem?: import("../../../types").Filesystem;
295
+ readonly filesystem?: import("../../../index.js").Filesystem;
296
296
  throwOnError: boolean;
297
297
  };
298
298
  }, {
@@ -312,14 +312,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
312
312
  toJson: () => Promise<string>;
313
313
  toYaml: () => Promise<string>;
314
314
  };
315
- details: () => Promise<import("../../../types").DetailsResult>;
316
- files: () => Promise<import("../../../types").Filesystem>;
317
- get: () => Promise<import("../../../types").CommandChain<[...T, {
315
+ details: () => Promise<import("../../../index.js").DetailsResult>;
316
+ files: () => Promise<import("../../../index.js").Filesystem>;
317
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
318
318
  readonly name: "load";
319
319
  readonly options: {
320
- readonly plugins?: import("../../load").LoadPlugin[];
320
+ readonly plugins?: import("../..").LoadPlugin[];
321
321
  readonly filename?: string;
322
- readonly filesystem?: import("../../../types").Filesystem;
322
+ readonly filesystem?: import("../../../index.js").Filesystem;
323
323
  throwOnError: boolean;
324
324
  };
325
325
  }, {
@@ -336,12 +336,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
336
336
  toJson: () => Promise<string>;
337
337
  toYaml: () => Promise<string>;
338
338
  };
339
- get: () => Promise<import("../../../types").CommandChain<[...T, {
339
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
340
340
  readonly name: "load";
341
341
  readonly options: {
342
- readonly plugins?: import("../../load").LoadPlugin[];
342
+ readonly plugins?: import("../..").LoadPlugin[];
343
343
  readonly filename?: string;
344
- readonly filesystem?: import("../../../types").Filesystem;
344
+ readonly filesystem?: import("../../../index.js").Filesystem;
345
345
  throwOnError: boolean;
346
346
  };
347
347
  }, {
@@ -356,14 +356,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
356
356
  toYaml: () => Promise<string>;
357
357
  validate: (validateOptions?: ValidateOptions) => {
358
358
  dereference: (dereferenceOptions?: DereferenceOptions) => {
359
- details: () => Promise<import("../../../types").DetailsResult>;
360
- files: () => Promise<import("../../../types").Filesystem>;
361
- get: () => Promise<import("../../../types").CommandChain<[...T, {
359
+ details: () => Promise<import("../../../index.js").DetailsResult>;
360
+ files: () => Promise<import("../../../index.js").Filesystem>;
361
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
362
362
  readonly name: "load";
363
363
  readonly options: {
364
- readonly plugins?: import("../../load").LoadPlugin[];
364
+ readonly plugins?: import("../..").LoadPlugin[];
365
365
  readonly filename?: string;
366
- readonly filesystem?: import("../../../types").Filesystem;
366
+ readonly filesystem?: import("../../../index.js").Filesystem;
367
367
  throwOnError: boolean;
368
368
  };
369
369
  }, {
@@ -383,18 +383,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
383
383
  toJson: () => Promise<string>;
384
384
  toYaml: () => Promise<string>;
385
385
  };
386
- details: () => Promise<import("../../../types").DetailsResult>;
387
- files: () => Promise<import("../../../types").Filesystem>;
386
+ details: () => Promise<import("../../../index.js").DetailsResult>;
387
+ files: () => Promise<import("../../../index.js").Filesystem>;
388
388
  filter: (callback: (specification: AnyObject) => boolean) => {
389
389
  dereference: (dereferenceOptions?: DereferenceOptions) => {
390
- details: () => Promise<import("../../../types").DetailsResult>;
391
- files: () => Promise<import("../../../types").Filesystem>;
392
- get: () => Promise<import("../../../types").CommandChain<[...T, {
390
+ details: () => Promise<import("../../../index.js").DetailsResult>;
391
+ files: () => Promise<import("../../../index.js").Filesystem>;
392
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
393
393
  readonly name: "load";
394
394
  readonly options: {
395
- readonly plugins?: import("../../load").LoadPlugin[];
395
+ readonly plugins?: import("../..").LoadPlugin[];
396
396
  readonly filename?: string;
397
- readonly filesystem?: import("../../../types").Filesystem;
397
+ readonly filesystem?: import("../../../index.js").Filesystem;
398
398
  throwOnError: boolean;
399
399
  };
400
400
  }, {
@@ -417,14 +417,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
417
417
  toJson: () => Promise<string>;
418
418
  toYaml: () => Promise<string>;
419
419
  };
420
- details: () => Promise<import("../../../types").DetailsResult>;
421
- files: () => Promise<import("../../../types").Filesystem>;
422
- get: () => Promise<import("../../../types").CommandChain<[...T, {
420
+ details: () => Promise<import("../../../index.js").DetailsResult>;
421
+ files: () => Promise<import("../../../index.js").Filesystem>;
422
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
423
423
  readonly name: "load";
424
424
  readonly options: {
425
- readonly plugins?: import("../../load").LoadPlugin[];
425
+ readonly plugins?: import("../..").LoadPlugin[];
426
426
  readonly filename?: string;
427
- readonly filesystem?: import("../../../types").Filesystem;
427
+ readonly filesystem?: import("../../../index.js").Filesystem;
428
428
  throwOnError: boolean;
429
429
  };
430
430
  }, {
@@ -444,12 +444,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
444
444
  toJson: () => Promise<string>;
445
445
  toYaml: () => Promise<string>;
446
446
  };
447
- get: () => Promise<import("../../../types").CommandChain<[...T, {
447
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
448
448
  readonly name: "load";
449
449
  readonly options: {
450
- readonly plugins?: import("../../load").LoadPlugin[];
450
+ readonly plugins?: import("../..").LoadPlugin[];
451
451
  readonly filename?: string;
452
- readonly filesystem?: import("../../../types").Filesystem;
452
+ readonly filesystem?: import("../../../index.js").Filesystem;
453
453
  throwOnError: boolean;
454
454
  };
455
455
  }, {
@@ -467,14 +467,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
467
467
  toYaml: () => Promise<string>;
468
468
  upgrade: () => {
469
469
  dereference: (dereferenceOptions?: DereferenceOptions) => {
470
- details: () => Promise<import("../../../types").DetailsResult>;
471
- files: () => Promise<import("../../../types").Filesystem>;
472
- get: () => Promise<import("../../../types").CommandChain<[...T, {
470
+ details: () => Promise<import("../../../index.js").DetailsResult>;
471
+ files: () => Promise<import("../../../index.js").Filesystem>;
472
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
473
473
  readonly name: "load";
474
474
  readonly options: {
475
- readonly plugins?: import("../../load").LoadPlugin[];
475
+ readonly plugins?: import("../..").LoadPlugin[];
476
476
  readonly filename?: string;
477
- readonly filesystem?: import("../../../types").Filesystem;
477
+ readonly filesystem?: import("../../../index.js").Filesystem;
478
478
  throwOnError: boolean;
479
479
  };
480
480
  }, {
@@ -496,18 +496,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
496
496
  toJson: () => Promise<string>;
497
497
  toYaml: () => Promise<string>;
498
498
  };
499
- details: () => Promise<import("../../../types").DetailsResult>;
500
- files: () => Promise<import("../../../types").Filesystem>;
499
+ details: () => Promise<import("../../../index.js").DetailsResult>;
500
+ files: () => Promise<import("../../../index.js").Filesystem>;
501
501
  filter: (callback: (specification: AnyObject) => boolean) => {
502
502
  dereference: (dereferenceOptions?: DereferenceOptions) => {
503
- details: () => Promise<import("../../../types").DetailsResult>;
504
- files: () => Promise<import("../../../types").Filesystem>;
505
- get: () => Promise<import("../../../types").CommandChain<[...T, {
503
+ details: () => Promise<import("../../../index.js").DetailsResult>;
504
+ files: () => Promise<import("../../../index.js").Filesystem>;
505
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
506
506
  readonly name: "load";
507
507
  readonly options: {
508
- readonly plugins?: import("../../load").LoadPlugin[];
508
+ readonly plugins?: import("../..").LoadPlugin[];
509
509
  readonly filename?: string;
510
- readonly filesystem?: import("../../../types").Filesystem;
510
+ readonly filesystem?: import("../../../index.js").Filesystem;
511
511
  throwOnError: boolean;
512
512
  };
513
513
  }, {
@@ -532,14 +532,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
532
532
  toJson: () => Promise<string>;
533
533
  toYaml: () => Promise<string>;
534
534
  };
535
- details: () => Promise<import("../../../types").DetailsResult>;
536
- files: () => Promise<import("../../../types").Filesystem>;
537
- get: () => Promise<import("../../../types").CommandChain<[...T, {
535
+ details: () => Promise<import("../../../index.js").DetailsResult>;
536
+ files: () => Promise<import("../../../index.js").Filesystem>;
537
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
538
538
  readonly name: "load";
539
539
  readonly options: {
540
- readonly plugins?: import("../../load").LoadPlugin[];
540
+ readonly plugins?: import("../..").LoadPlugin[];
541
541
  readonly filename?: string;
542
- readonly filesystem?: import("../../../types").Filesystem;
542
+ readonly filesystem?: import("../../../index.js").Filesystem;
543
543
  throwOnError: boolean;
544
544
  };
545
545
  }, {
@@ -561,12 +561,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
561
561
  toJson: () => Promise<string>;
562
562
  toYaml: () => Promise<string>;
563
563
  };
564
- get: () => Promise<import("../../../types").CommandChain<[...T, {
564
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
565
565
  readonly name: "load";
566
566
  readonly options: {
567
- readonly plugins?: import("../../load").LoadPlugin[];
567
+ readonly plugins?: import("../..").LoadPlugin[];
568
568
  readonly filename?: string;
569
- readonly filesystem?: import("../../../types").Filesystem;
569
+ readonly filesystem?: import("../../../index.js").Filesystem;
570
570
  throwOnError: boolean;
571
571
  };
572
572
  }, {
@@ -586,14 +586,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
586
586
  toYaml: () => Promise<string>;
587
587
  validate: (validateOptions?: ValidateOptions) => {
588
588
  dereference: (dereferenceOptions?: DereferenceOptions) => {
589
- details: () => Promise<import("../../../types").DetailsResult>;
590
- files: () => Promise<import("../../../types").Filesystem>;
591
- get: () => Promise<import("../../../types").CommandChain<[...T, {
589
+ details: () => Promise<import("../../../index.js").DetailsResult>;
590
+ files: () => Promise<import("../../../index.js").Filesystem>;
591
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
592
592
  readonly name: "load";
593
593
  readonly options: {
594
- readonly plugins?: import("../../load").LoadPlugin[];
594
+ readonly plugins?: import("../..").LoadPlugin[];
595
595
  readonly filename?: string;
596
- readonly filesystem?: import("../../../types").Filesystem;
596
+ readonly filesystem?: import("../../../index.js").Filesystem;
597
597
  throwOnError: boolean;
598
598
  };
599
599
  }, {
@@ -618,18 +618,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
618
618
  toJson: () => Promise<string>;
619
619
  toYaml: () => Promise<string>;
620
620
  };
621
- details: () => Promise<import("../../../types").DetailsResult>;
622
- files: () => Promise<import("../../../types").Filesystem>;
621
+ details: () => Promise<import("../../../index.js").DetailsResult>;
622
+ files: () => Promise<import("../../../index.js").Filesystem>;
623
623
  filter: (callback: (specification: AnyObject) => boolean) => {
624
624
  dereference: (dereferenceOptions?: DereferenceOptions) => {
625
- details: () => Promise<import("../../../types").DetailsResult>;
626
- files: () => Promise<import("../../../types").Filesystem>;
627
- get: () => Promise<import("../../../types").CommandChain<[...T, {
625
+ details: () => Promise<import("../../../index.js").DetailsResult>;
626
+ files: () => Promise<import("../../../index.js").Filesystem>;
627
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
628
628
  readonly name: "load";
629
629
  readonly options: {
630
- readonly plugins?: import("../../load").LoadPlugin[];
630
+ readonly plugins?: import("../..").LoadPlugin[];
631
631
  readonly filename?: string;
632
- readonly filesystem?: import("../../../types").Filesystem;
632
+ readonly filesystem?: import("../../../index.js").Filesystem;
633
633
  throwOnError: boolean;
634
634
  };
635
635
  }, {
@@ -657,14 +657,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
657
657
  toJson: () => Promise<string>;
658
658
  toYaml: () => Promise<string>;
659
659
  };
660
- details: () => Promise<import("../../../types").DetailsResult>;
661
- files: () => Promise<import("../../../types").Filesystem>;
662
- get: () => Promise<import("../../../types").CommandChain<[...T, {
660
+ details: () => Promise<import("../../../index.js").DetailsResult>;
661
+ files: () => Promise<import("../../../index.js").Filesystem>;
662
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
663
663
  readonly name: "load";
664
664
  readonly options: {
665
- readonly plugins?: import("../../load").LoadPlugin[];
665
+ readonly plugins?: import("../..").LoadPlugin[];
666
666
  readonly filename?: string;
667
- readonly filesystem?: import("../../../types").Filesystem;
667
+ readonly filesystem?: import("../../../index.js").Filesystem;
668
668
  throwOnError: boolean;
669
669
  };
670
670
  }, {
@@ -689,12 +689,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
689
689
  toJson: () => Promise<string>;
690
690
  toYaml: () => Promise<string>;
691
691
  };
692
- get: () => Promise<import("../../../types").CommandChain<[...T, {
692
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
693
693
  readonly name: "load";
694
694
  readonly options: {
695
- readonly plugins?: import("../../load").LoadPlugin[];
695
+ readonly plugins?: import("../..").LoadPlugin[];
696
696
  readonly filename?: string;
697
- readonly filesystem?: import("../../../types").Filesystem;
697
+ readonly filesystem?: import("../../../index.js").Filesystem;
698
698
  throwOnError: boolean;
699
699
  };
700
700
  }, {
@@ -717,14 +717,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
717
717
  toYaml: () => Promise<string>;
718
718
  upgrade: () => {
719
719
  dereference: (dereferenceOptions?: DereferenceOptions) => {
720
- details: () => Promise<import("../../../types").DetailsResult>;
721
- files: () => Promise<import("../../../types").Filesystem>;
722
- get: () => Promise<import("../../../types").CommandChain<[...T, {
720
+ details: () => Promise<import("../../../index.js").DetailsResult>;
721
+ files: () => Promise<import("../../../index.js").Filesystem>;
722
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
723
723
  readonly name: "load";
724
724
  readonly options: {
725
- readonly plugins?: import("../../load").LoadPlugin[];
725
+ readonly plugins?: import("../..").LoadPlugin[];
726
726
  readonly filename?: string;
727
- readonly filesystem?: import("../../../types").Filesystem;
727
+ readonly filesystem?: import("../../../index.js").Filesystem;
728
728
  throwOnError: boolean;
729
729
  };
730
730
  }, {
@@ -751,18 +751,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
751
751
  toJson: () => Promise<string>;
752
752
  toYaml: () => Promise<string>;
753
753
  };
754
- details: () => Promise<import("../../../types").DetailsResult>;
755
- files: () => Promise<import("../../../types").Filesystem>;
754
+ details: () => Promise<import("../../../index.js").DetailsResult>;
755
+ files: () => Promise<import("../../../index.js").Filesystem>;
756
756
  filter: (callback: (specification: AnyObject) => boolean) => {
757
757
  dereference: (dereferenceOptions?: DereferenceOptions) => {
758
- details: () => Promise<import("../../../types").DetailsResult>;
759
- files: () => Promise<import("../../../types").Filesystem>;
760
- get: () => Promise<import("../../../types").CommandChain<[...T, {
758
+ details: () => Promise<import("../../../index.js").DetailsResult>;
759
+ files: () => Promise<import("../../../index.js").Filesystem>;
760
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
761
761
  readonly name: "load";
762
762
  readonly options: {
763
- readonly plugins?: import("../../load").LoadPlugin[];
763
+ readonly plugins?: import("../..").LoadPlugin[];
764
764
  readonly filename?: string;
765
- readonly filesystem?: import("../../../types").Filesystem;
765
+ readonly filesystem?: import("../../../index.js").Filesystem;
766
766
  throwOnError: boolean;
767
767
  };
768
768
  }, {
@@ -792,14 +792,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
792
792
  toJson: () => Promise<string>;
793
793
  toYaml: () => Promise<string>;
794
794
  };
795
- details: () => Promise<import("../../../types").DetailsResult>;
796
- files: () => Promise<import("../../../types").Filesystem>;
797
- get: () => Promise<import("../../../types").CommandChain<[...T, {
795
+ details: () => Promise<import("../../../index.js").DetailsResult>;
796
+ files: () => Promise<import("../../../index.js").Filesystem>;
797
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
798
798
  readonly name: "load";
799
799
  readonly options: {
800
- readonly plugins?: import("../../load").LoadPlugin[];
800
+ readonly plugins?: import("../..").LoadPlugin[];
801
801
  readonly filename?: string;
802
- readonly filesystem?: import("../../../types").Filesystem;
802
+ readonly filesystem?: import("../../../index.js").Filesystem;
803
803
  throwOnError: boolean;
804
804
  };
805
805
  }, {
@@ -826,12 +826,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
826
826
  toJson: () => Promise<string>;
827
827
  toYaml: () => Promise<string>;
828
828
  };
829
- get: () => Promise<import("../../../types").CommandChain<[...T, {
829
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
830
830
  readonly name: "load";
831
831
  readonly options: {
832
- readonly plugins?: import("../../load").LoadPlugin[];
832
+ readonly plugins?: import("../..").LoadPlugin[];
833
833
  readonly filename?: string;
834
- readonly filesystem?: import("../../../types").Filesystem;
834
+ readonly filesystem?: import("../../../index.js").Filesystem;
835
835
  throwOnError: boolean;
836
836
  };
837
837
  }, {
@@ -856,14 +856,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
856
856
  toYaml: () => Promise<string>;
857
857
  validate: (validateOptions?: ValidateOptions) => {
858
858
  dereference: (dereferenceOptions?: DereferenceOptions) => {
859
- details: () => Promise<import("../../../types").DetailsResult>;
860
- files: () => Promise<import("../../../types").Filesystem>;
861
- get: () => Promise<import("../../../types").CommandChain<[...T, {
859
+ details: () => Promise<import("../../../index.js").DetailsResult>;
860
+ files: () => Promise<import("../../../index.js").Filesystem>;
861
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
862
862
  readonly name: "load";
863
863
  readonly options: {
864
- readonly plugins?: import("../../load").LoadPlugin[];
864
+ readonly plugins?: import("../..").LoadPlugin[];
865
865
  readonly filename?: string;
866
- readonly filesystem?: import("../../../types").Filesystem;
866
+ readonly filesystem?: import("../../../index.js").Filesystem;
867
867
  throwOnError: boolean;
868
868
  };
869
869
  }, {
@@ -893,18 +893,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
893
893
  toJson: () => Promise<string>;
894
894
  toYaml: () => Promise<string>;
895
895
  };
896
- details: () => Promise<import("../../../types").DetailsResult>;
897
- files: () => Promise<import("../../../types").Filesystem>;
896
+ details: () => Promise<import("../../../index.js").DetailsResult>;
897
+ files: () => Promise<import("../../../index.js").Filesystem>;
898
898
  filter: (callback: (specification: AnyObject) => boolean) => {
899
899
  dereference: (dereferenceOptions?: DereferenceOptions) => {
900
- details: () => Promise<import("../../../types").DetailsResult>;
901
- files: () => Promise<import("../../../types").Filesystem>;
902
- get: () => Promise<import("../../../types").CommandChain<[...T, {
900
+ details: () => Promise<import("../../../index.js").DetailsResult>;
901
+ files: () => Promise<import("../../../index.js").Filesystem>;
902
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
903
903
  readonly name: "load";
904
904
  readonly options: {
905
- readonly plugins?: import("../../load").LoadPlugin[];
905
+ readonly plugins?: import("../..").LoadPlugin[];
906
906
  readonly filename?: string;
907
- readonly filesystem?: import("../../../types").Filesystem;
907
+ readonly filesystem?: import("../../../index.js").Filesystem;
908
908
  throwOnError: boolean;
909
909
  };
910
910
  }, {
@@ -937,14 +937,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
937
937
  toJson: () => Promise<string>;
938
938
  toYaml: () => Promise<string>;
939
939
  };
940
- details: () => Promise<import("../../../types").DetailsResult>;
941
- files: () => Promise<import("../../../types").Filesystem>;
942
- get: () => Promise<import("../../../types").CommandChain<[...T, {
940
+ details: () => Promise<import("../../../index.js").DetailsResult>;
941
+ files: () => Promise<import("../../../index.js").Filesystem>;
942
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
943
943
  readonly name: "load";
944
944
  readonly options: {
945
- readonly plugins?: import("../../load").LoadPlugin[];
945
+ readonly plugins?: import("../..").LoadPlugin[];
946
946
  readonly filename?: string;
947
- readonly filesystem?: import("../../../types").Filesystem;
947
+ readonly filesystem?: import("../../../index.js").Filesystem;
948
948
  throwOnError: boolean;
949
949
  };
950
950
  }, {
@@ -974,12 +974,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
974
974
  toJson: () => Promise<string>;
975
975
  toYaml: () => Promise<string>;
976
976
  };
977
- get: () => Promise<import("../../../types").CommandChain<[...T, {
977
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
978
978
  readonly name: "load";
979
979
  readonly options: {
980
- readonly plugins?: import("../../load").LoadPlugin[];
980
+ readonly plugins?: import("../..").LoadPlugin[];
981
981
  readonly filename?: string;
982
- readonly filesystem?: import("../../../types").Filesystem;
982
+ readonly filesystem?: import("../../../index.js").Filesystem;
983
983
  throwOnError: boolean;
984
984
  };
985
985
  }, {
@@ -1007,14 +1007,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
1007
1007
  toYaml: () => Promise<string>;
1008
1008
  upgrade: () => {
1009
1009
  dereference: (dereferenceOptions?: DereferenceOptions) => {
1010
- details: () => Promise<import("../../../types").DetailsResult>;
1011
- files: () => Promise<import("../../../types").Filesystem>;
1012
- get: () => Promise<import("../../../types").CommandChain<[...T, {
1010
+ details: () => Promise<import("../../../index.js").DetailsResult>;
1011
+ files: () => Promise<import("../../../index.js").Filesystem>;
1012
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
1013
1013
  readonly name: "load";
1014
1014
  readonly options: {
1015
- readonly plugins?: import("../../load").LoadPlugin[];
1015
+ readonly plugins?: import("../..").LoadPlugin[];
1016
1016
  readonly filename?: string;
1017
- readonly filesystem?: import("../../../types").Filesystem;
1017
+ readonly filesystem?: import("../../../index.js").Filesystem;
1018
1018
  throwOnError: boolean;
1019
1019
  };
1020
1020
  }, {
@@ -1046,18 +1046,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
1046
1046
  toJson: () => Promise<string>;
1047
1047
  toYaml: () => Promise<string>;
1048
1048
  };
1049
- details: () => Promise<import("../../../types").DetailsResult>;
1050
- files: () => Promise<import("../../../types").Filesystem>;
1049
+ details: () => Promise<import("../../../index.js").DetailsResult>;
1050
+ files: () => Promise<import("../../../index.js").Filesystem>;
1051
1051
  filter: (callback: (specification: AnyObject) => boolean) => {
1052
1052
  dereference: (dereferenceOptions?: DereferenceOptions) => {
1053
- details: () => Promise<import("../../../types").DetailsResult>;
1054
- files: () => Promise<import("../../../types").Filesystem>;
1055
- get: () => Promise<import("../../../types").CommandChain<[...T, {
1053
+ details: () => Promise<import("../../../index.js").DetailsResult>;
1054
+ files: () => Promise<import("../../../index.js").Filesystem>;
1055
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
1056
1056
  readonly name: "load";
1057
1057
  readonly options: {
1058
- readonly plugins?: import("../../load").LoadPlugin[];
1058
+ readonly plugins?: import("../..").LoadPlugin[];
1059
1059
  readonly filename?: string;
1060
- readonly filesystem?: import("../../../types").Filesystem;
1060
+ readonly filesystem?: import("../../../index.js").Filesystem;
1061
1061
  throwOnError: boolean;
1062
1062
  };
1063
1063
  }, {
@@ -1092,14 +1092,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
1092
1092
  toJson: () => Promise<string>;
1093
1093
  toYaml: () => Promise<string>;
1094
1094
  };
1095
- details: () => Promise<import("../../../types").DetailsResult>;
1096
- files: () => Promise<import("../../../types").Filesystem>;
1097
- get: () => Promise<import("../../../types").CommandChain<[...T, {
1095
+ details: () => Promise<import("../../../index.js").DetailsResult>;
1096
+ files: () => Promise<import("../../../index.js").Filesystem>;
1097
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
1098
1098
  readonly name: "load";
1099
1099
  readonly options: {
1100
- readonly plugins?: import("../../load").LoadPlugin[];
1100
+ readonly plugins?: import("../..").LoadPlugin[];
1101
1101
  readonly filename?: string;
1102
- readonly filesystem?: import("../../../types").Filesystem;
1102
+ readonly filesystem?: import("../../../index.js").Filesystem;
1103
1103
  throwOnError: boolean;
1104
1104
  };
1105
1105
  }, {
@@ -1131,12 +1131,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
1131
1131
  toJson: () => Promise<string>;
1132
1132
  toYaml: () => Promise<string>;
1133
1133
  };
1134
- get: () => Promise<import("../../../types").CommandChain<[...T, {
1134
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
1135
1135
  readonly name: "load";
1136
1136
  readonly options: {
1137
- readonly plugins?: import("../../load").LoadPlugin[];
1137
+ readonly plugins?: import("../..").LoadPlugin[];
1138
1138
  readonly filename?: string;
1139
- readonly filesystem?: import("../../../types").Filesystem;
1139
+ readonly filesystem?: import("../../../index.js").Filesystem;
1140
1140
  throwOnError: boolean;
1141
1141
  };
1142
1142
  }, {
@@ -1166,14 +1166,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
1166
1166
  toYaml: () => Promise<string>;
1167
1167
  validate: (validateOptions?: ValidateOptions) => {
1168
1168
  dereference: (dereferenceOptions?: DereferenceOptions) => {
1169
- details: () => Promise<import("../../../types").DetailsResult>;
1170
- files: () => Promise<import("../../../types").Filesystem>;
1171
- get: () => Promise<import("../../../types").CommandChain<[...T, {
1169
+ details: () => Promise<import("../../../index.js").DetailsResult>;
1170
+ files: () => Promise<import("../../../index.js").Filesystem>;
1171
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
1172
1172
  readonly name: "load";
1173
1173
  readonly options: {
1174
- readonly plugins?: import("../../load").LoadPlugin[];
1174
+ readonly plugins?: import("../..").LoadPlugin[];
1175
1175
  readonly filename?: string;
1176
- readonly filesystem?: import("../../../types").Filesystem;
1176
+ readonly filesystem?: import("../../../index.js").Filesystem;
1177
1177
  throwOnError: boolean;
1178
1178
  };
1179
1179
  }, {
@@ -1208,18 +1208,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
1208
1208
  toJson: () => Promise<string>;
1209
1209
  toYaml: () => Promise<string>;
1210
1210
  };
1211
- details: () => Promise<import("../../../types").DetailsResult>;
1212
- files: () => Promise<import("../../../types").Filesystem>;
1211
+ details: () => Promise<import("../../../index.js").DetailsResult>;
1212
+ files: () => Promise<import("../../../index.js").Filesystem>;
1213
1213
  filter: (callback: (specification: AnyObject) => boolean) => {
1214
1214
  dereference: (dereferenceOptions?: DereferenceOptions) => {
1215
- details: () => Promise<import("../../../types").DetailsResult>;
1216
- files: () => Promise<import("../../../types").Filesystem>;
1217
- get: () => Promise<import("../../../types").CommandChain<[...T, {
1215
+ details: () => Promise<import("../../../index.js").DetailsResult>;
1216
+ files: () => Promise<import("../../../index.js").Filesystem>;
1217
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
1218
1218
  readonly name: "load";
1219
1219
  readonly options: {
1220
- readonly plugins?: import("../../load").LoadPlugin[];
1220
+ readonly plugins?: import("../..").LoadPlugin[];
1221
1221
  readonly filename?: string;
1222
- readonly filesystem?: import("../../../types").Filesystem;
1222
+ readonly filesystem?: import("../../../index.js").Filesystem;
1223
1223
  throwOnError: boolean;
1224
1224
  };
1225
1225
  }, {
@@ -1257,14 +1257,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
1257
1257
  toJson: () => Promise<string>;
1258
1258
  toYaml: () => Promise<string>;
1259
1259
  };
1260
- details: () => Promise<import("../../../types").DetailsResult>;
1261
- files: () => Promise<import("../../../types").Filesystem>;
1262
- get: () => Promise<import("../../../types").CommandChain<[...T, {
1260
+ details: () => Promise<import("../../../index.js").DetailsResult>;
1261
+ files: () => Promise<import("../../../index.js").Filesystem>;
1262
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
1263
1263
  readonly name: "load";
1264
1264
  readonly options: {
1265
- readonly plugins?: import("../../load").LoadPlugin[];
1265
+ readonly plugins?: import("../..").LoadPlugin[];
1266
1266
  readonly filename?: string;
1267
- readonly filesystem?: import("../../../types").Filesystem;
1267
+ readonly filesystem?: import("../../../index.js").Filesystem;
1268
1268
  throwOnError: boolean;
1269
1269
  };
1270
1270
  }, {
@@ -1299,12 +1299,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
1299
1299
  toJson: () => Promise<string>;
1300
1300
  toYaml: () => Promise<string>;
1301
1301
  };
1302
- get: () => Promise<import("../../../types").CommandChain<[...T, {
1302
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
1303
1303
  readonly name: "load";
1304
1304
  readonly options: {
1305
- readonly plugins?: import("../../load").LoadPlugin[];
1305
+ readonly plugins?: import("../..").LoadPlugin[];
1306
1306
  readonly filename?: string;
1307
- readonly filesystem?: import("../../../types").Filesystem;
1307
+ readonly filesystem?: import("../../../index.js").Filesystem;
1308
1308
  throwOnError: boolean;
1309
1309
  };
1310
1310
  }, {
@@ -1337,14 +1337,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
1337
1337
  toYaml: () => Promise<string>;
1338
1338
  upgrade: () => {
1339
1339
  dereference: (dereferenceOptions?: DereferenceOptions) => {
1340
- details: () => Promise<import("../../../types").DetailsResult>;
1341
- files: () => Promise<import("../../../types").Filesystem>;
1342
- get: () => Promise<import("../../../types").CommandChain<[...T, {
1340
+ details: () => Promise<import("../../../index.js").DetailsResult>;
1341
+ files: () => Promise<import("../../../index.js").Filesystem>;
1342
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
1343
1343
  readonly name: "load";
1344
1344
  readonly options: {
1345
- readonly plugins?: import("../../load").LoadPlugin[];
1345
+ readonly plugins?: import("../..").LoadPlugin[];
1346
1346
  readonly filename?: string;
1347
- readonly filesystem?: import("../../../types").Filesystem;
1347
+ readonly filesystem?: import("../../../index.js").Filesystem;
1348
1348
  throwOnError: boolean;
1349
1349
  };
1350
1350
  }, {
@@ -1381,18 +1381,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
1381
1381
  toJson: () => Promise<string>;
1382
1382
  toYaml: () => Promise<string>;
1383
1383
  };
1384
- details: () => Promise<import("../../../types").DetailsResult>;
1385
- files: () => Promise<import("../../../types").Filesystem>;
1384
+ details: () => Promise<import("../../../index.js").DetailsResult>;
1385
+ files: () => Promise<import("../../../index.js").Filesystem>;
1386
1386
  filter: (callback: (specification: AnyObject) => boolean) => {
1387
1387
  dereference: (dereferenceOptions?: DereferenceOptions) => {
1388
- details: () => Promise<import("../../../types").DetailsResult>;
1389
- files: () => Promise<import("../../../types").Filesystem>;
1390
- get: () => Promise<import("../../../types").CommandChain<[...T, {
1388
+ details: () => Promise<import("../../../index.js").DetailsResult>;
1389
+ files: () => Promise<import("../../../index.js").Filesystem>;
1390
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
1391
1391
  readonly name: "load";
1392
1392
  readonly options: {
1393
- readonly plugins?: import("../../load").LoadPlugin[];
1393
+ readonly plugins?: import("../..").LoadPlugin[];
1394
1394
  readonly filename?: string;
1395
- readonly filesystem?: import("../../../types").Filesystem;
1395
+ readonly filesystem?: import("../../../index.js").Filesystem;
1396
1396
  throwOnError: boolean;
1397
1397
  };
1398
1398
  }, {
@@ -1432,14 +1432,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
1432
1432
  toJson: () => Promise<string>;
1433
1433
  toYaml: () => Promise<string>;
1434
1434
  };
1435
- details: () => Promise<import("../../../types").DetailsResult>;
1436
- files: () => Promise<import("../../../types").Filesystem>;
1437
- get: () => Promise<import("../../../types").CommandChain<[...T, {
1435
+ details: () => Promise<import("../../../index.js").DetailsResult>;
1436
+ files: () => Promise<import("../../../index.js").Filesystem>;
1437
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
1438
1438
  readonly name: "load";
1439
1439
  readonly options: {
1440
- readonly plugins?: import("../../load").LoadPlugin[];
1440
+ readonly plugins?: import("../..").LoadPlugin[];
1441
1441
  readonly filename?: string;
1442
- readonly filesystem?: import("../../../types").Filesystem;
1442
+ readonly filesystem?: import("../../../index.js").Filesystem;
1443
1443
  throwOnError: boolean;
1444
1444
  };
1445
1445
  }, {
@@ -1476,12 +1476,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
1476
1476
  toJson: () => Promise<string>;
1477
1477
  toYaml: () => Promise<string>;
1478
1478
  };
1479
- get: () => Promise<import("../../../types").CommandChain<[...T, {
1479
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
1480
1480
  readonly name: "load";
1481
1481
  readonly options: {
1482
- readonly plugins?: import("../../load").LoadPlugin[];
1482
+ readonly plugins?: import("../..").LoadPlugin[];
1483
1483
  readonly filename?: string;
1484
- readonly filesystem?: import("../../../types").Filesystem;
1484
+ readonly filesystem?: import("../../../index.js").Filesystem;
1485
1485
  throwOnError: boolean;
1486
1486
  };
1487
1487
  }, {
@@ -1516,14 +1516,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
1516
1516
  toYaml: () => Promise<string>;
1517
1517
  validate: (validateOptions?: ValidateOptions) => {
1518
1518
  dereference: (dereferenceOptions?: DereferenceOptions) => {
1519
- details: () => Promise<import("../../../types").DetailsResult>;
1520
- files: () => Promise<import("../../../types").Filesystem>;
1521
- get: () => Promise<import("../../../types").CommandChain<[...T, {
1519
+ details: () => Promise<import("../../../index.js").DetailsResult>;
1520
+ files: () => Promise<import("../../../index.js").Filesystem>;
1521
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
1522
1522
  readonly name: "load";
1523
1523
  readonly options: {
1524
- readonly plugins?: import("../../load").LoadPlugin[];
1524
+ readonly plugins?: import("../..").LoadPlugin[];
1525
1525
  readonly filename?: string;
1526
- readonly filesystem?: import("../../../types").Filesystem;
1526
+ readonly filesystem?: import("../../../index.js").Filesystem;
1527
1527
  throwOnError: boolean;
1528
1528
  };
1529
1529
  }, {
@@ -1563,18 +1563,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
1563
1563
  toJson: () => Promise<string>;
1564
1564
  toYaml: () => Promise<string>;
1565
1565
  };
1566
- details: () => Promise<import("../../../types").DetailsResult>;
1567
- files: () => Promise<import("../../../types").Filesystem>;
1566
+ details: () => Promise<import("../../../index.js").DetailsResult>;
1567
+ files: () => Promise<import("../../../index.js").Filesystem>;
1568
1568
  filter: (callback: (specification: AnyObject) => boolean) => {
1569
1569
  dereference: (dereferenceOptions?: DereferenceOptions) => {
1570
- details: () => Promise<import("../../../types").DetailsResult>;
1571
- files: () => Promise<import("../../../types").Filesystem>;
1572
- get: () => Promise<import("../../../types").CommandChain<[...T, {
1570
+ details: () => Promise<import("../../../index.js").DetailsResult>;
1571
+ files: () => Promise<import("../../../index.js").Filesystem>;
1572
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
1573
1573
  readonly name: "load";
1574
1574
  readonly options: {
1575
- readonly plugins?: import("../../load").LoadPlugin[];
1575
+ readonly plugins?: import("../..").LoadPlugin[];
1576
1576
  readonly filename?: string;
1577
- readonly filesystem?: import("../../../types").Filesystem;
1577
+ readonly filesystem?: import("../../../index.js").Filesystem;
1578
1578
  throwOnError: boolean;
1579
1579
  };
1580
1580
  }, {
@@ -1617,14 +1617,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
1617
1617
  toJson: () => Promise<string>;
1618
1618
  toYaml: () => Promise<string>;
1619
1619
  };
1620
- details: () => Promise<import("../../../types").DetailsResult>;
1621
- files: () => Promise<import("../../../types").Filesystem>;
1622
- get: () => Promise<import("../../../types").CommandChain<[...T, {
1620
+ details: () => Promise<import("../../../index.js").DetailsResult>;
1621
+ files: () => Promise<import("../../../index.js").Filesystem>;
1622
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
1623
1623
  readonly name: "load";
1624
1624
  readonly options: {
1625
- readonly plugins?: import("../../load").LoadPlugin[];
1625
+ readonly plugins?: import("../..").LoadPlugin[];
1626
1626
  readonly filename?: string;
1627
- readonly filesystem?: import("../../../types").Filesystem;
1627
+ readonly filesystem?: import("../../../index.js").Filesystem;
1628
1628
  throwOnError: boolean;
1629
1629
  };
1630
1630
  }, {
@@ -1664,12 +1664,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
1664
1664
  toJson: () => Promise<string>;
1665
1665
  toYaml: () => Promise<string>;
1666
1666
  };
1667
- get: () => Promise<import("../../../types").CommandChain<[...T, {
1667
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
1668
1668
  readonly name: "load";
1669
1669
  readonly options: {
1670
- readonly plugins?: import("../../load").LoadPlugin[];
1670
+ readonly plugins?: import("../..").LoadPlugin[];
1671
1671
  readonly filename?: string;
1672
- readonly filesystem?: import("../../../types").Filesystem;
1672
+ readonly filesystem?: import("../../../index.js").Filesystem;
1673
1673
  throwOnError: boolean;
1674
1674
  };
1675
1675
  }, {
@@ -1707,14 +1707,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
1707
1707
  toYaml: () => Promise<string>;
1708
1708
  upgrade: () => {
1709
1709
  dereference: (dereferenceOptions?: DereferenceOptions) => {
1710
- details: () => Promise<import("../../../types").DetailsResult>;
1711
- files: () => Promise<import("../../../types").Filesystem>;
1712
- get: () => Promise<import("../../../types").CommandChain<[...T, {
1710
+ details: () => Promise<import("../../../index.js").DetailsResult>;
1711
+ files: () => Promise<import("../../../index.js").Filesystem>;
1712
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
1713
1713
  readonly name: "load";
1714
1714
  readonly options: {
1715
- readonly plugins?: import("../../load").LoadPlugin[];
1715
+ readonly plugins?: import("../..").LoadPlugin[];
1716
1716
  readonly filename?: string;
1717
- readonly filesystem?: import("../../../types").Filesystem;
1717
+ readonly filesystem?: import("../../../index.js").Filesystem;
1718
1718
  throwOnError: boolean;
1719
1719
  };
1720
1720
  }, {
@@ -1756,18 +1756,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
1756
1756
  toJson: () => Promise<string>;
1757
1757
  toYaml: () => Promise<string>;
1758
1758
  };
1759
- details: () => Promise<import("../../../types").DetailsResult>;
1760
- files: () => Promise<import("../../../types").Filesystem>;
1759
+ details: () => Promise<import("../../../index.js").DetailsResult>;
1760
+ files: () => Promise<import("../../../index.js").Filesystem>;
1761
1761
  filter: (callback: (specification: AnyObject) => boolean) => {
1762
1762
  dereference: (dereferenceOptions?: DereferenceOptions) => {
1763
- details: () => Promise<import("../../../types").DetailsResult>;
1764
- files: () => Promise<import("../../../types").Filesystem>;
1765
- get: () => Promise<import("../../../types").CommandChain<[...T, {
1763
+ details: () => Promise<import("../../../index.js").DetailsResult>;
1764
+ files: () => Promise<import("../../../index.js").Filesystem>;
1765
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
1766
1766
  readonly name: "load";
1767
1767
  readonly options: {
1768
- readonly plugins?: import("../../load").LoadPlugin[];
1768
+ readonly plugins?: import("../..").LoadPlugin[];
1769
1769
  readonly filename?: string;
1770
- readonly filesystem?: import("../../../types").Filesystem;
1770
+ readonly filesystem?: import("../../../index.js").Filesystem;
1771
1771
  throwOnError: boolean;
1772
1772
  };
1773
1773
  }, {
@@ -1812,14 +1812,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
1812
1812
  toJson: () => Promise<string>;
1813
1813
  toYaml: () => Promise<string>;
1814
1814
  };
1815
- details: () => Promise<import("../../../types").DetailsResult>;
1816
- files: () => Promise<import("../../../types").Filesystem>;
1817
- get: () => Promise<import("../../../types").CommandChain<[...T, {
1815
+ details: () => Promise<import("../../../index.js").DetailsResult>;
1816
+ files: () => Promise<import("../../../index.js").Filesystem>;
1817
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
1818
1818
  readonly name: "load";
1819
1819
  readonly options: {
1820
- readonly plugins?: import("../../load").LoadPlugin[];
1820
+ readonly plugins?: import("../..").LoadPlugin[];
1821
1821
  readonly filename?: string;
1822
- readonly filesystem?: import("../../../types").Filesystem;
1822
+ readonly filesystem?: import("../../../index.js").Filesystem;
1823
1823
  throwOnError: boolean;
1824
1824
  };
1825
1825
  }, {
@@ -1861,12 +1861,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
1861
1861
  toJson: () => Promise<string>;
1862
1862
  toYaml: () => Promise<string>;
1863
1863
  };
1864
- get: () => Promise<import("../../../types").CommandChain<[...T, {
1864
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
1865
1865
  readonly name: "load";
1866
1866
  readonly options: {
1867
- readonly plugins?: import("../../load").LoadPlugin[];
1867
+ readonly plugins?: import("../..").LoadPlugin[];
1868
1868
  readonly filename?: string;
1869
- readonly filesystem?: import("../../../types").Filesystem;
1869
+ readonly filesystem?: import("../../../index.js").Filesystem;
1870
1870
  throwOnError: boolean;
1871
1871
  };
1872
1872
  }, {
@@ -1906,14 +1906,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
1906
1906
  toYaml: () => Promise<string>;
1907
1907
  validate: (validateOptions?: ValidateOptions) => {
1908
1908
  dereference: (dereferenceOptions?: DereferenceOptions) => {
1909
- details: () => Promise<import("../../../types").DetailsResult>;
1910
- files: () => Promise<import("../../../types").Filesystem>;
1911
- get: () => Promise<import("../../../types").CommandChain<[...T, {
1909
+ details: () => Promise<import("../../../index.js").DetailsResult>;
1910
+ files: () => Promise<import("../../../index.js").Filesystem>;
1911
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
1912
1912
  readonly name: "load";
1913
1913
  readonly options: {
1914
- readonly plugins?: import("../../load").LoadPlugin[];
1914
+ readonly plugins?: import("../..").LoadPlugin[];
1915
1915
  readonly filename?: string;
1916
- readonly filesystem?: import("../../../types").Filesystem;
1916
+ readonly filesystem?: import("../../../index.js").Filesystem;
1917
1917
  throwOnError: boolean;
1918
1918
  };
1919
1919
  }, {
@@ -1958,18 +1958,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
1958
1958
  toJson: () => Promise<string>;
1959
1959
  toYaml: () => Promise<string>;
1960
1960
  };
1961
- details: () => Promise<import("../../../types").DetailsResult>;
1962
- files: () => Promise<import("../../../types").Filesystem>;
1961
+ details: () => Promise<import("../../../index.js").DetailsResult>;
1962
+ files: () => Promise<import("../../../index.js").Filesystem>;
1963
1963
  filter: (callback: (specification: AnyObject) => boolean) => {
1964
1964
  dereference: (dereferenceOptions?: DereferenceOptions) => {
1965
- details: () => Promise<import("../../../types").DetailsResult>;
1966
- files: () => Promise<import("../../../types").Filesystem>;
1967
- get: () => Promise<import("../../../types").CommandChain<[...T, {
1965
+ details: () => Promise<import("../../../index.js").DetailsResult>;
1966
+ files: () => Promise<import("../../../index.js").Filesystem>;
1967
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
1968
1968
  readonly name: "load";
1969
1969
  readonly options: {
1970
- readonly plugins?: import("../../load").LoadPlugin[];
1970
+ readonly plugins?: import("../..").LoadPlugin[];
1971
1971
  readonly filename?: string;
1972
- readonly filesystem?: import("../../../types").Filesystem;
1972
+ readonly filesystem?: import("../../../index.js").Filesystem;
1973
1973
  throwOnError: boolean;
1974
1974
  };
1975
1975
  }, {
@@ -2017,14 +2017,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
2017
2017
  toJson: () => Promise<string>;
2018
2018
  toYaml: () => Promise<string>;
2019
2019
  };
2020
- details: () => Promise<import("../../../types").DetailsResult>;
2021
- files: () => Promise<import("../../../types").Filesystem>;
2022
- get: () => Promise<import("../../../types").CommandChain<[...T, {
2020
+ details: () => Promise<import("../../../index.js").DetailsResult>;
2021
+ files: () => Promise<import("../../../index.js").Filesystem>;
2022
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
2023
2023
  readonly name: "load";
2024
2024
  readonly options: {
2025
- readonly plugins?: import("../../load").LoadPlugin[];
2025
+ readonly plugins?: import("../..").LoadPlugin[];
2026
2026
  readonly filename?: string;
2027
- readonly filesystem?: import("../../../types").Filesystem;
2027
+ readonly filesystem?: import("../../../index.js").Filesystem;
2028
2028
  throwOnError: boolean;
2029
2029
  };
2030
2030
  }, {
@@ -2069,12 +2069,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
2069
2069
  toJson: () => Promise<string>;
2070
2070
  toYaml: () => Promise<string>;
2071
2071
  };
2072
- get: () => Promise<import("../../../types").CommandChain<[...T, {
2072
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
2073
2073
  readonly name: "load";
2074
2074
  readonly options: {
2075
- readonly plugins?: import("../../load").LoadPlugin[];
2075
+ readonly plugins?: import("../..").LoadPlugin[];
2076
2076
  readonly filename?: string;
2077
- readonly filesystem?: import("../../../types").Filesystem;
2077
+ readonly filesystem?: import("../../../index.js").Filesystem;
2078
2078
  throwOnError: boolean;
2079
2079
  };
2080
2080
  }, {
@@ -2117,14 +2117,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
2117
2117
  toYaml: () => Promise<string>;
2118
2118
  upgrade: () => {
2119
2119
  dereference: (dereferenceOptions?: DereferenceOptions) => {
2120
- details: () => Promise<import("../../../types").DetailsResult>;
2121
- files: () => Promise<import("../../../types").Filesystem>;
2122
- get: () => Promise<import("../../../types").CommandChain<[...T, {
2120
+ details: () => Promise<import("../../../index.js").DetailsResult>;
2121
+ files: () => Promise<import("../../../index.js").Filesystem>;
2122
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
2123
2123
  readonly name: "load";
2124
2124
  readonly options: {
2125
- readonly plugins?: import("../../load").LoadPlugin[];
2125
+ readonly plugins?: import("../..").LoadPlugin[];
2126
2126
  readonly filename?: string;
2127
- readonly filesystem?: import("../../../types").Filesystem;
2127
+ readonly filesystem?: import("../../../index.js").Filesystem;
2128
2128
  throwOnError: boolean;
2129
2129
  };
2130
2130
  }, {
@@ -2171,18 +2171,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
2171
2171
  toJson: () => Promise<string>;
2172
2172
  toYaml: () => Promise<string>;
2173
2173
  };
2174
- details: () => Promise<import("../../../types").DetailsResult>;
2175
- files: () => Promise<import("../../../types").Filesystem>;
2174
+ details: () => Promise<import("../../../index.js").DetailsResult>;
2175
+ files: () => Promise<import("../../../index.js").Filesystem>;
2176
2176
  filter: (callback: (specification: AnyObject) => boolean) => {
2177
2177
  dereference: (dereferenceOptions?: DereferenceOptions) => {
2178
- details: () => Promise<import("../../../types").DetailsResult>;
2179
- files: () => Promise<import("../../../types").Filesystem>;
2180
- get: () => Promise<import("../../../types").CommandChain<[...T, {
2178
+ details: () => Promise<import("../../../index.js").DetailsResult>;
2179
+ files: () => Promise<import("../../../index.js").Filesystem>;
2180
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
2181
2181
  readonly name: "load";
2182
2182
  readonly options: {
2183
- readonly plugins?: import("../../load").LoadPlugin[];
2183
+ readonly plugins?: import("../..").LoadPlugin[];
2184
2184
  readonly filename?: string;
2185
- readonly filesystem?: import("../../../types").Filesystem;
2185
+ readonly filesystem?: import("../../../index.js").Filesystem;
2186
2186
  throwOnError: boolean;
2187
2187
  };
2188
2188
  }, {
@@ -2232,14 +2232,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
2232
2232
  toJson: () => Promise<string>;
2233
2233
  toYaml: () => Promise<string>;
2234
2234
  };
2235
- details: () => Promise<import("../../../types").DetailsResult>;
2236
- files: () => Promise<import("../../../types").Filesystem>;
2237
- get: () => Promise<import("../../../types").CommandChain<[...T, {
2235
+ details: () => Promise<import("../../../index.js").DetailsResult>;
2236
+ files: () => Promise<import("../../../index.js").Filesystem>;
2237
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
2238
2238
  readonly name: "load";
2239
2239
  readonly options: {
2240
- readonly plugins?: import("../../load").LoadPlugin[];
2240
+ readonly plugins?: import("../..").LoadPlugin[];
2241
2241
  readonly filename?: string;
2242
- readonly filesystem?: import("../../../types").Filesystem;
2242
+ readonly filesystem?: import("../../../index.js").Filesystem;
2243
2243
  throwOnError: boolean;
2244
2244
  };
2245
2245
  }, {
@@ -2286,12 +2286,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
2286
2286
  toJson: () => Promise<string>;
2287
2287
  toYaml: () => Promise<string>;
2288
2288
  };
2289
- get: () => Promise<import("../../../types").CommandChain<[...T, {
2289
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
2290
2290
  readonly name: "load";
2291
2291
  readonly options: {
2292
- readonly plugins?: import("../../load").LoadPlugin[];
2292
+ readonly plugins?: import("../..").LoadPlugin[];
2293
2293
  readonly filename?: string;
2294
- readonly filesystem?: import("../../../types").Filesystem;
2294
+ readonly filesystem?: import("../../../index.js").Filesystem;
2295
2295
  throwOnError: boolean;
2296
2296
  };
2297
2297
  }, {
@@ -2336,14 +2336,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
2336
2336
  toYaml: () => Promise<string>;
2337
2337
  validate: (validateOptions?: ValidateOptions) => {
2338
2338
  dereference: (dereferenceOptions?: DereferenceOptions) => {
2339
- details: () => Promise<import("../../../types").DetailsResult>;
2340
- files: () => Promise<import("../../../types").Filesystem>;
2341
- get: () => Promise<import("../../../types").CommandChain<[...T, {
2339
+ details: () => Promise<import("../../../index.js").DetailsResult>;
2340
+ files: () => Promise<import("../../../index.js").Filesystem>;
2341
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
2342
2342
  readonly name: "load";
2343
2343
  readonly options: {
2344
- readonly plugins?: import("../../load").LoadPlugin[];
2344
+ readonly plugins?: import("../..").LoadPlugin[];
2345
2345
  readonly filename?: string;
2346
- readonly filesystem?: import("../../../types").Filesystem;
2346
+ readonly filesystem?: import("../../../index.js").Filesystem;
2347
2347
  throwOnError: boolean;
2348
2348
  };
2349
2349
  }, {
@@ -2393,18 +2393,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
2393
2393
  toJson: () => Promise<string>;
2394
2394
  toYaml: () => Promise<string>;
2395
2395
  };
2396
- details: () => Promise<import("../../../types").DetailsResult>;
2397
- files: () => Promise<import("../../../types").Filesystem>;
2396
+ details: () => Promise<import("../../../index.js").DetailsResult>;
2397
+ files: () => Promise<import("../../../index.js").Filesystem>;
2398
2398
  filter: (callback: (specification: AnyObject) => boolean) => {
2399
2399
  dereference: (dereferenceOptions?: DereferenceOptions) => {
2400
- details: () => Promise<import("../../../types").DetailsResult>;
2401
- files: () => Promise<import("../../../types").Filesystem>;
2402
- get: () => Promise<import("../../../types").CommandChain<[...T, {
2400
+ details: () => Promise<import("../../../index.js").DetailsResult>;
2401
+ files: () => Promise<import("../../../index.js").Filesystem>;
2402
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
2403
2403
  readonly name: "load";
2404
2404
  readonly options: {
2405
- readonly plugins?: import("../../load").LoadPlugin[];
2405
+ readonly plugins?: import("../..").LoadPlugin[];
2406
2406
  readonly filename?: string;
2407
- readonly filesystem?: import("../../../types").Filesystem;
2407
+ readonly filesystem?: import("../../../index.js").Filesystem;
2408
2408
  throwOnError: boolean;
2409
2409
  };
2410
2410
  }, {
@@ -2457,14 +2457,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
2457
2457
  toJson: () => Promise<string>;
2458
2458
  toYaml: () => Promise<string>;
2459
2459
  };
2460
- details: () => Promise<import("../../../types").DetailsResult>;
2461
- files: () => Promise<import("../../../types").Filesystem>;
2462
- get: () => Promise<import("../../../types").CommandChain<[...T, {
2460
+ details: () => Promise<import("../../../index.js").DetailsResult>;
2461
+ files: () => Promise<import("../../../index.js").Filesystem>;
2462
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
2463
2463
  readonly name: "load";
2464
2464
  readonly options: {
2465
- readonly plugins?: import("../../load").LoadPlugin[];
2465
+ readonly plugins?: import("../..").LoadPlugin[];
2466
2466
  readonly filename?: string;
2467
- readonly filesystem?: import("../../../types").Filesystem;
2467
+ readonly filesystem?: import("../../../index.js").Filesystem;
2468
2468
  throwOnError: boolean;
2469
2469
  };
2470
2470
  }, {
@@ -2514,12 +2514,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
2514
2514
  toJson: () => Promise<string>;
2515
2515
  toYaml: () => Promise<string>;
2516
2516
  };
2517
- get: () => Promise<import("../../../types").CommandChain<[...T, {
2517
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
2518
2518
  readonly name: "load";
2519
2519
  readonly options: {
2520
- readonly plugins?: import("../../load").LoadPlugin[];
2520
+ readonly plugins?: import("../..").LoadPlugin[];
2521
2521
  readonly filename?: string;
2522
- readonly filesystem?: import("../../../types").Filesystem;
2522
+ readonly filesystem?: import("../../../index.js").Filesystem;
2523
2523
  throwOnError: boolean;
2524
2524
  };
2525
2525
  }, {
@@ -2567,14 +2567,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
2567
2567
  toYaml: () => Promise<string>;
2568
2568
  upgrade: () => {
2569
2569
  dereference: (dereferenceOptions?: DereferenceOptions) => {
2570
- details: () => Promise<import("../../../types").DetailsResult>;
2571
- files: () => Promise<import("../../../types").Filesystem>;
2572
- get: () => Promise<import("../../../types").CommandChain<[...T, {
2570
+ details: () => Promise<import("../../../index.js").DetailsResult>;
2571
+ files: () => Promise<import("../../../index.js").Filesystem>;
2572
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
2573
2573
  readonly name: "load";
2574
2574
  readonly options: {
2575
- readonly plugins?: import("../../load").LoadPlugin[];
2575
+ readonly plugins?: import("../..").LoadPlugin[];
2576
2576
  readonly filename?: string;
2577
- readonly filesystem?: import("../../../types").Filesystem;
2577
+ readonly filesystem?: import("../../../index.js").Filesystem;
2578
2578
  throwOnError: boolean;
2579
2579
  };
2580
2580
  }, {
@@ -2626,18 +2626,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
2626
2626
  toJson: () => Promise<string>;
2627
2627
  toYaml: () => Promise<string>;
2628
2628
  };
2629
- details: () => Promise<import("../../../types").DetailsResult>;
2630
- files: () => Promise<import("../../../types").Filesystem>;
2629
+ details: () => Promise<import("../../../index.js").DetailsResult>;
2630
+ files: () => Promise<import("../../../index.js").Filesystem>;
2631
2631
  filter: (callback: (specification: AnyObject) => boolean) => {
2632
2632
  dereference: (dereferenceOptions?: DereferenceOptions) => {
2633
- details: () => Promise<import("../../../types").DetailsResult>;
2634
- files: () => Promise<import("../../../types").Filesystem>;
2635
- get: () => Promise<import("../../../types").CommandChain<[...T, {
2633
+ details: () => Promise<import("../../../index.js").DetailsResult>;
2634
+ files: () => Promise<import("../../../index.js").Filesystem>;
2635
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
2636
2636
  readonly name: "load";
2637
2637
  readonly options: {
2638
- readonly plugins?: import("../../load").LoadPlugin[];
2638
+ readonly plugins?: import("../..").LoadPlugin[];
2639
2639
  readonly filename?: string;
2640
- readonly filesystem?: import("../../../types").Filesystem;
2640
+ readonly filesystem?: import("../../../index.js").Filesystem;
2641
2641
  throwOnError: boolean;
2642
2642
  };
2643
2643
  }, {
@@ -2692,14 +2692,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
2692
2692
  toJson: () => Promise<string>;
2693
2693
  toYaml: () => Promise<string>;
2694
2694
  };
2695
- details: () => Promise<import("../../../types").DetailsResult>;
2696
- files: () => Promise<import("../../../types").Filesystem>;
2697
- get: () => Promise<import("../../../types").CommandChain<[...T, {
2695
+ details: () => Promise<import("../../../index.js").DetailsResult>;
2696
+ files: () => Promise<import("../../../index.js").Filesystem>;
2697
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
2698
2698
  readonly name: "load";
2699
2699
  readonly options: {
2700
- readonly plugins?: import("../../load").LoadPlugin[];
2700
+ readonly plugins?: import("../..").LoadPlugin[];
2701
2701
  readonly filename?: string;
2702
- readonly filesystem?: import("../../../types").Filesystem;
2702
+ readonly filesystem?: import("../../../index.js").Filesystem;
2703
2703
  throwOnError: boolean;
2704
2704
  };
2705
2705
  }, {
@@ -2751,12 +2751,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
2751
2751
  toJson: () => Promise<string>;
2752
2752
  toYaml: () => Promise<string>;
2753
2753
  };
2754
- get: () => Promise<import("../../../types").CommandChain<[...T, {
2754
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
2755
2755
  readonly name: "load";
2756
2756
  readonly options: {
2757
- readonly plugins?: import("../../load").LoadPlugin[];
2757
+ readonly plugins?: import("../..").LoadPlugin[];
2758
2758
  readonly filename?: string;
2759
- readonly filesystem?: import("../../../types").Filesystem;
2759
+ readonly filesystem?: import("../../../index.js").Filesystem;
2760
2760
  throwOnError: boolean;
2761
2761
  };
2762
2762
  }, {
@@ -2806,14 +2806,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
2806
2806
  toYaml: () => Promise<string>;
2807
2807
  validate: (validateOptions?: ValidateOptions) => {
2808
2808
  dereference: (dereferenceOptions?: DereferenceOptions) => {
2809
- details: () => Promise<import("../../../types").DetailsResult>;
2810
- files: () => Promise<import("../../../types").Filesystem>;
2811
- get: () => Promise<import("../../../types").CommandChain<[...T, {
2809
+ details: () => Promise<import("../../../index.js").DetailsResult>;
2810
+ files: () => Promise<import("../../../index.js").Filesystem>;
2811
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
2812
2812
  readonly name: "load";
2813
2813
  readonly options: {
2814
- readonly plugins?: import("../../load").LoadPlugin[];
2814
+ readonly plugins?: import("../..").LoadPlugin[];
2815
2815
  readonly filename?: string;
2816
- readonly filesystem?: import("../../../types").Filesystem;
2816
+ readonly filesystem?: import("../../../index.js").Filesystem;
2817
2817
  throwOnError: boolean;
2818
2818
  };
2819
2819
  }, {
@@ -2868,18 +2868,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
2868
2868
  toJson: () => Promise<string>;
2869
2869
  toYaml: () => Promise<string>;
2870
2870
  };
2871
- details: () => Promise<import("../../../types").DetailsResult>;
2872
- files: () => Promise<import("../../../types").Filesystem>;
2871
+ details: () => Promise<import("../../../index.js").DetailsResult>;
2872
+ files: () => Promise<import("../../../index.js").Filesystem>;
2873
2873
  filter: (callback: (specification: AnyObject) => boolean) => {
2874
2874
  dereference: (dereferenceOptions?: DereferenceOptions) => {
2875
- details: () => Promise<import("../../../types").DetailsResult>;
2876
- files: () => Promise<import("../../../types").Filesystem>;
2877
- get: () => Promise<import("../../../types").CommandChain<[...T, {
2875
+ details: () => Promise<import("../../../index.js").DetailsResult>;
2876
+ files: () => Promise<import("../../../index.js").Filesystem>;
2877
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
2878
2878
  readonly name: "load";
2879
2879
  readonly options: {
2880
- readonly plugins?: import("../../load").LoadPlugin[];
2880
+ readonly plugins?: import("../..").LoadPlugin[];
2881
2881
  readonly filename?: string;
2882
- readonly filesystem?: import("../../../types").Filesystem;
2882
+ readonly filesystem?: import("../../../index.js").Filesystem;
2883
2883
  throwOnError: boolean;
2884
2884
  };
2885
2885
  }, {
@@ -2937,14 +2937,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
2937
2937
  toJson: () => Promise<string>;
2938
2938
  toYaml: () => Promise<string>;
2939
2939
  };
2940
- details: () => Promise<import("../../../types").DetailsResult>;
2941
- files: () => Promise<import("../../../types").Filesystem>;
2942
- get: () => Promise<import("../../../types").CommandChain<[...T, {
2940
+ details: () => Promise<import("../../../index.js").DetailsResult>;
2941
+ files: () => Promise<import("../../../index.js").Filesystem>;
2942
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
2943
2943
  readonly name: "load";
2944
2944
  readonly options: {
2945
- readonly plugins?: import("../../load").LoadPlugin[];
2945
+ readonly plugins?: import("../..").LoadPlugin[];
2946
2946
  readonly filename?: string;
2947
- readonly filesystem?: import("../../../types").Filesystem;
2947
+ readonly filesystem?: import("../../../index.js").Filesystem;
2948
2948
  throwOnError: boolean;
2949
2949
  };
2950
2950
  }, {
@@ -2999,12 +2999,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
2999
2999
  toJson: () => Promise<string>;
3000
3000
  toYaml: () => Promise<string>;
3001
3001
  };
3002
- get: () => Promise<import("../../../types").CommandChain<[...T, {
3002
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
3003
3003
  readonly name: "load";
3004
3004
  readonly options: {
3005
- readonly plugins?: import("../../load").LoadPlugin[];
3005
+ readonly plugins?: import("../..").LoadPlugin[];
3006
3006
  readonly filename?: string;
3007
- readonly filesystem?: import("../../../types").Filesystem;
3007
+ readonly filesystem?: import("../../../index.js").Filesystem;
3008
3008
  throwOnError: boolean;
3009
3009
  };
3010
3010
  }, {
@@ -3057,14 +3057,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
3057
3057
  toYaml: () => Promise<string>;
3058
3058
  upgrade: () => {
3059
3059
  dereference: (dereferenceOptions?: DereferenceOptions) => {
3060
- details: () => Promise<import("../../../types").DetailsResult>;
3061
- files: () => Promise<import("../../../types").Filesystem>;
3062
- get: () => Promise<import("../../../types").CommandChain<[...T, {
3060
+ details: () => Promise<import("../../../index.js").DetailsResult>;
3061
+ files: () => Promise<import("../../../index.js").Filesystem>;
3062
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
3063
3063
  readonly name: "load";
3064
3064
  readonly options: {
3065
- readonly plugins?: import("../../load").LoadPlugin[];
3065
+ readonly plugins?: import("../..").LoadPlugin[];
3066
3066
  readonly filename?: string;
3067
- readonly filesystem?: import("../../../types").Filesystem;
3067
+ readonly filesystem?: import("../../../index.js").Filesystem;
3068
3068
  throwOnError: boolean;
3069
3069
  };
3070
3070
  }, {
@@ -3121,18 +3121,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
3121
3121
  toJson: () => Promise<string>;
3122
3122
  toYaml: () => Promise<string>;
3123
3123
  };
3124
- details: () => Promise<import("../../../types").DetailsResult>;
3125
- files: () => Promise<import("../../../types").Filesystem>;
3124
+ details: () => Promise<import("../../../index.js").DetailsResult>;
3125
+ files: () => Promise<import("../../../index.js").Filesystem>;
3126
3126
  filter: (callback: (specification: AnyObject) => boolean) => {
3127
3127
  dereference: (dereferenceOptions?: DereferenceOptions) => {
3128
- details: () => Promise<import("../../../types").DetailsResult>;
3129
- files: () => Promise<import("../../../types").Filesystem>;
3130
- get: () => Promise<import("../../../types").CommandChain<[...T, {
3128
+ details: () => Promise<import("../../../index.js").DetailsResult>;
3129
+ files: () => Promise<import("../../../index.js").Filesystem>;
3130
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
3131
3131
  readonly name: "load";
3132
3132
  readonly options: {
3133
- readonly plugins?: import("../../load").LoadPlugin[];
3133
+ readonly plugins?: import("../..").LoadPlugin[];
3134
3134
  readonly filename?: string;
3135
- readonly filesystem?: import("../../../types").Filesystem;
3135
+ readonly filesystem?: import("../../../index.js").Filesystem;
3136
3136
  throwOnError: boolean;
3137
3137
  };
3138
3138
  }, {
@@ -3192,14 +3192,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
3192
3192
  toJson: () => Promise<string>;
3193
3193
  toYaml: () => Promise<string>;
3194
3194
  };
3195
- details: () => Promise<import("../../../types").DetailsResult>;
3196
- files: () => Promise<import("../../../types").Filesystem>;
3197
- get: () => Promise<import("../../../types").CommandChain<[...T, {
3195
+ details: () => Promise<import("../../../index.js").DetailsResult>;
3196
+ files: () => Promise<import("../../../index.js").Filesystem>;
3197
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
3198
3198
  readonly name: "load";
3199
3199
  readonly options: {
3200
- readonly plugins?: import("../../load").LoadPlugin[];
3200
+ readonly plugins?: import("../..").LoadPlugin[];
3201
3201
  readonly filename?: string;
3202
- readonly filesystem?: import("../../../types").Filesystem;
3202
+ readonly filesystem?: import("../../../index.js").Filesystem;
3203
3203
  throwOnError: boolean;
3204
3204
  };
3205
3205
  }, {
@@ -3256,12 +3256,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
3256
3256
  toJson: () => Promise<string>;
3257
3257
  toYaml: () => Promise<string>;
3258
3258
  };
3259
- get: () => Promise<import("../../../types").CommandChain<[...T, {
3259
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
3260
3260
  readonly name: "load";
3261
3261
  readonly options: {
3262
- readonly plugins?: import("../../load").LoadPlugin[];
3262
+ readonly plugins?: import("../..").LoadPlugin[];
3263
3263
  readonly filename?: string;
3264
- readonly filesystem?: import("../../../types").Filesystem;
3264
+ readonly filesystem?: import("../../../index.js").Filesystem;
3265
3265
  throwOnError: boolean;
3266
3266
  };
3267
3267
  }, {
@@ -3316,14 +3316,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
3316
3316
  toYaml: () => Promise<string>;
3317
3317
  validate: (validateOptions?: ValidateOptions) => {
3318
3318
  dereference: (dereferenceOptions?: DereferenceOptions) => {
3319
- details: () => Promise<import("../../../types").DetailsResult>;
3320
- files: () => Promise<import("../../../types").Filesystem>;
3321
- get: () => Promise<import("../../../types").CommandChain<[...T, {
3319
+ details: () => Promise<import("../../../index.js").DetailsResult>;
3320
+ files: () => Promise<import("../../../index.js").Filesystem>;
3321
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
3322
3322
  readonly name: "load";
3323
3323
  readonly options: {
3324
- readonly plugins?: import("../../load").LoadPlugin[];
3324
+ readonly plugins?: import("../..").LoadPlugin[];
3325
3325
  readonly filename?: string;
3326
- readonly filesystem?: import("../../../types").Filesystem;
3326
+ readonly filesystem?: import("../../../index.js").Filesystem;
3327
3327
  throwOnError: boolean;
3328
3328
  };
3329
3329
  }, {
@@ -3383,18 +3383,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
3383
3383
  toJson: () => Promise<string>;
3384
3384
  toYaml: () => Promise<string>;
3385
3385
  };
3386
- details: () => Promise<import("../../../types").DetailsResult>;
3387
- files: () => Promise<import("../../../types").Filesystem>;
3386
+ details: () => Promise<import("../../../index.js").DetailsResult>;
3387
+ files: () => Promise<import("../../../index.js").Filesystem>;
3388
3388
  filter: (callback: (specification: AnyObject) => boolean) => {
3389
3389
  dereference: (dereferenceOptions?: DereferenceOptions) => {
3390
- details: () => Promise<import("../../../types").DetailsResult>;
3391
- files: () => Promise<import("../../../types").Filesystem>;
3392
- get: () => Promise<import("../../../types").CommandChain<[...T, {
3390
+ details: () => Promise<import("../../../index.js").DetailsResult>;
3391
+ files: () => Promise<import("../../../index.js").Filesystem>;
3392
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
3393
3393
  readonly name: "load";
3394
3394
  readonly options: {
3395
- readonly plugins?: import("../../load").LoadPlugin[];
3395
+ readonly plugins?: import("../..").LoadPlugin[];
3396
3396
  readonly filename?: string;
3397
- readonly filesystem?: import("../../../types").Filesystem;
3397
+ readonly filesystem?: import("../../../index.js").Filesystem;
3398
3398
  throwOnError: boolean;
3399
3399
  };
3400
3400
  }, {
@@ -3457,14 +3457,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
3457
3457
  toJson: () => Promise<string>;
3458
3458
  toYaml: () => Promise<string>;
3459
3459
  };
3460
- details: () => Promise<import("../../../types").DetailsResult>;
3461
- files: () => Promise<import("../../../types").Filesystem>;
3462
- get: () => Promise<import("../../../types").CommandChain<[...T, {
3460
+ details: () => Promise<import("../../../index.js").DetailsResult>;
3461
+ files: () => Promise<import("../../../index.js").Filesystem>;
3462
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
3463
3463
  readonly name: "load";
3464
3464
  readonly options: {
3465
- readonly plugins?: import("../../load").LoadPlugin[];
3465
+ readonly plugins?: import("../..").LoadPlugin[];
3466
3466
  readonly filename?: string;
3467
- readonly filesystem?: import("../../../types").Filesystem;
3467
+ readonly filesystem?: import("../../../index.js").Filesystem;
3468
3468
  throwOnError: boolean;
3469
3469
  };
3470
3470
  }, {
@@ -3524,12 +3524,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
3524
3524
  toJson: () => Promise<string>;
3525
3525
  toYaml: () => Promise<string>;
3526
3526
  };
3527
- get: () => Promise<import("../../../types").CommandChain<[...T, {
3527
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
3528
3528
  readonly name: "load";
3529
3529
  readonly options: {
3530
- readonly plugins?: import("../../load").LoadPlugin[];
3530
+ readonly plugins?: import("../..").LoadPlugin[];
3531
3531
  readonly filename?: string;
3532
- readonly filesystem?: import("../../../types").Filesystem;
3532
+ readonly filesystem?: import("../../../index.js").Filesystem;
3533
3533
  throwOnError: boolean;
3534
3534
  };
3535
3535
  }, {
@@ -3587,14 +3587,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
3587
3587
  toYaml: () => Promise<string>;
3588
3588
  upgrade: () => {
3589
3589
  dereference: (dereferenceOptions?: DereferenceOptions) => {
3590
- details: () => Promise<import("../../../types").DetailsResult>;
3591
- files: () => Promise<import("../../../types").Filesystem>;
3592
- get: () => Promise<import("../../../types").CommandChain<[...T, {
3590
+ details: () => Promise<import("../../../index.js").DetailsResult>;
3591
+ files: () => Promise<import("../../../index.js").Filesystem>;
3592
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
3593
3593
  readonly name: "load";
3594
3594
  readonly options: {
3595
- readonly plugins?: import("../../load").LoadPlugin[];
3595
+ readonly plugins?: import("../..").LoadPlugin[];
3596
3596
  readonly filename?: string;
3597
- readonly filesystem?: import("../../../types").Filesystem;
3597
+ readonly filesystem?: import("../../../index.js").Filesystem;
3598
3598
  throwOnError: boolean;
3599
3599
  };
3600
3600
  }, {
@@ -3656,18 +3656,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
3656
3656
  toJson: () => Promise<string>;
3657
3657
  toYaml: () => Promise<string>;
3658
3658
  };
3659
- details: () => Promise<import("../../../types").DetailsResult>;
3660
- files: () => Promise<import("../../../types").Filesystem>;
3659
+ details: () => Promise<import("../../../index.js").DetailsResult>;
3660
+ files: () => Promise<import("../../../index.js").Filesystem>;
3661
3661
  filter: (callback: (specification: AnyObject) => boolean) => {
3662
3662
  dereference: (dereferenceOptions?: DereferenceOptions) => {
3663
- details: () => Promise<import("../../../types").DetailsResult>;
3664
- files: () => Promise<import("../../../types").Filesystem>;
3665
- get: () => Promise<import("../../../types").CommandChain<[...T, {
3663
+ details: () => Promise<import("../../../index.js").DetailsResult>;
3664
+ files: () => Promise<import("../../../index.js").Filesystem>;
3665
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
3666
3666
  readonly name: "load";
3667
3667
  readonly options: {
3668
- readonly plugins?: import("../../load").LoadPlugin[];
3668
+ readonly plugins?: import("../..").LoadPlugin[];
3669
3669
  readonly filename?: string;
3670
- readonly filesystem?: import("../../../types").Filesystem;
3670
+ readonly filesystem?: import("../../../index.js").Filesystem;
3671
3671
  throwOnError: boolean;
3672
3672
  };
3673
3673
  }, {
@@ -3732,14 +3732,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
3732
3732
  toJson: () => Promise<string>;
3733
3733
  toYaml: () => Promise<string>;
3734
3734
  };
3735
- details: () => Promise<import("../../../types").DetailsResult>;
3736
- files: () => Promise<import("../../../types").Filesystem>;
3737
- get: () => Promise<import("../../../types").CommandChain<[...T, {
3735
+ details: () => Promise<import("../../../index.js").DetailsResult>;
3736
+ files: () => Promise<import("../../../index.js").Filesystem>;
3737
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
3738
3738
  readonly name: "load";
3739
3739
  readonly options: {
3740
- readonly plugins?: import("../../load").LoadPlugin[];
3740
+ readonly plugins?: import("../..").LoadPlugin[];
3741
3741
  readonly filename?: string;
3742
- readonly filesystem?: import("../../../types").Filesystem;
3742
+ readonly filesystem?: import("../../../index.js").Filesystem;
3743
3743
  throwOnError: boolean;
3744
3744
  };
3745
3745
  }, {
@@ -3801,12 +3801,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
3801
3801
  toJson: () => Promise<string>;
3802
3802
  toYaml: () => Promise<string>;
3803
3803
  };
3804
- get: () => Promise<import("../../../types").CommandChain<[...T, {
3804
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
3805
3805
  readonly name: "load";
3806
3806
  readonly options: {
3807
- readonly plugins?: import("../../load").LoadPlugin[];
3807
+ readonly plugins?: import("../..").LoadPlugin[];
3808
3808
  readonly filename?: string;
3809
- readonly filesystem?: import("../../../types").Filesystem;
3809
+ readonly filesystem?: import("../../../index.js").Filesystem;
3810
3810
  throwOnError: boolean;
3811
3811
  };
3812
3812
  }, {
@@ -3866,14 +3866,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
3866
3866
  toYaml: () => Promise<string>;
3867
3867
  validate: (validateOptions?: ValidateOptions) => {
3868
3868
  dereference: (dereferenceOptions?: DereferenceOptions) => {
3869
- details: () => Promise<import("../../../types").DetailsResult>;
3870
- files: () => Promise<import("../../../types").Filesystem>;
3871
- get: () => Promise<import("../../../types").CommandChain<[...T, {
3869
+ details: () => Promise<import("../../../index.js").DetailsResult>;
3870
+ files: () => Promise<import("../../../index.js").Filesystem>;
3871
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
3872
3872
  readonly name: "load";
3873
3873
  readonly options: {
3874
- readonly plugins?: import("../../load").LoadPlugin[];
3874
+ readonly plugins?: import("../..").LoadPlugin[];
3875
3875
  readonly filename?: string;
3876
- readonly filesystem?: import("../../../types").Filesystem;
3876
+ readonly filesystem?: import("../../../index.js").Filesystem;
3877
3877
  throwOnError: boolean;
3878
3878
  };
3879
3879
  }, {
@@ -3938,18 +3938,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
3938
3938
  toJson: () => Promise<string>;
3939
3939
  toYaml: () => Promise<string>;
3940
3940
  };
3941
- details: () => Promise<import("../../../types").DetailsResult>;
3942
- files: () => Promise<import("../../../types").Filesystem>;
3941
+ details: () => Promise<import("../../../index.js").DetailsResult>;
3942
+ files: () => Promise<import("../../../index.js").Filesystem>;
3943
3943
  filter: (callback: (specification: AnyObject) => boolean) => {
3944
3944
  dereference: (dereferenceOptions?: DereferenceOptions) => {
3945
- details: () => Promise<import("../../../types").DetailsResult>;
3946
- files: () => Promise<import("../../../types").Filesystem>;
3947
- get: () => Promise<import("../../../types").CommandChain<[...T, {
3945
+ details: () => Promise<import("../../../index.js").DetailsResult>;
3946
+ files: () => Promise<import("../../../index.js").Filesystem>;
3947
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
3948
3948
  readonly name: "load";
3949
3949
  readonly options: {
3950
- readonly plugins?: import("../../load").LoadPlugin[];
3950
+ readonly plugins?: import("../..").LoadPlugin[];
3951
3951
  readonly filename?: string;
3952
- readonly filesystem?: import("../../../types").Filesystem;
3952
+ readonly filesystem?: import("../../../index.js").Filesystem;
3953
3953
  throwOnError: boolean;
3954
3954
  };
3955
3955
  }, {
@@ -4017,14 +4017,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4017
4017
  toJson: () => Promise<string>;
4018
4018
  toYaml: () => Promise<string>;
4019
4019
  };
4020
- details: () => Promise<import("../../../types").DetailsResult>;
4021
- files: () => Promise<import("../../../types").Filesystem>;
4022
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4020
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4021
+ files: () => Promise<import("../../../index.js").Filesystem>;
4022
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4023
4023
  readonly name: "load";
4024
4024
  readonly options: {
4025
- readonly plugins?: import("../../load").LoadPlugin[];
4025
+ readonly plugins?: import("../..").LoadPlugin[];
4026
4026
  readonly filename?: string;
4027
- readonly filesystem?: import("../../../types").Filesystem;
4027
+ readonly filesystem?: import("../../../index.js").Filesystem;
4028
4028
  throwOnError: boolean;
4029
4029
  };
4030
4030
  }, {
@@ -4089,12 +4089,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4089
4089
  toJson: () => Promise<string>;
4090
4090
  toYaml: () => Promise<string>;
4091
4091
  };
4092
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4092
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4093
4093
  readonly name: "load";
4094
4094
  readonly options: {
4095
- readonly plugins?: import("../../load").LoadPlugin[];
4095
+ readonly plugins?: import("../..").LoadPlugin[];
4096
4096
  readonly filename?: string;
4097
- readonly filesystem?: import("../../../types").Filesystem;
4097
+ readonly filesystem?: import("../../../index.js").Filesystem;
4098
4098
  throwOnError: boolean;
4099
4099
  };
4100
4100
  }, {
@@ -4182,14 +4182,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4182
4182
  toYaml: () => Promise<string>;
4183
4183
  validate: (validateOptions?: ValidateOptions) => {
4184
4184
  dereference: (dereferenceOptions?: DereferenceOptions) => {
4185
- details: () => Promise<import("../../../types").DetailsResult>;
4186
- files: () => Promise<import("../../../types").Filesystem>;
4187
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4185
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4186
+ files: () => Promise<import("../../../index.js").Filesystem>;
4187
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4188
4188
  readonly name: "load";
4189
4189
  readonly options: {
4190
- readonly plugins?: import("../../load").LoadPlugin[];
4190
+ readonly plugins?: import("../..").LoadPlugin[];
4191
4191
  readonly filename?: string;
4192
- readonly filesystem?: import("../../../types").Filesystem;
4192
+ readonly filesystem?: import("../../../index.js").Filesystem;
4193
4193
  throwOnError: boolean;
4194
4194
  };
4195
4195
  }, {
@@ -4202,18 +4202,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4202
4202
  toJson: () => Promise<string>;
4203
4203
  toYaml: () => Promise<string>;
4204
4204
  };
4205
- details: () => Promise<import("../../../types").DetailsResult>;
4206
- files: () => Promise<import("../../../types").Filesystem>;
4205
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4206
+ files: () => Promise<import("../../../index.js").Filesystem>;
4207
4207
  filter: (callback: (specification: AnyObject) => boolean) => {
4208
4208
  dereference: (dereferenceOptions?: DereferenceOptions) => {
4209
- details: () => Promise<import("../../../types").DetailsResult>;
4210
- files: () => Promise<import("../../../types").Filesystem>;
4211
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4209
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4210
+ files: () => Promise<import("../../../index.js").Filesystem>;
4211
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4212
4212
  readonly name: "load";
4213
4213
  readonly options: {
4214
- readonly plugins?: import("../../load").LoadPlugin[];
4214
+ readonly plugins?: import("../..").LoadPlugin[];
4215
4215
  readonly filename?: string;
4216
- readonly filesystem?: import("../../../types").Filesystem;
4216
+ readonly filesystem?: import("../../../index.js").Filesystem;
4217
4217
  throwOnError: boolean;
4218
4218
  };
4219
4219
  }, {
@@ -4229,14 +4229,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4229
4229
  toJson: () => Promise<string>;
4230
4230
  toYaml: () => Promise<string>;
4231
4231
  };
4232
- details: () => Promise<import("../../../types").DetailsResult>;
4233
- files: () => Promise<import("../../../types").Filesystem>;
4234
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4232
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4233
+ files: () => Promise<import("../../../index.js").Filesystem>;
4234
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4235
4235
  readonly name: "load";
4236
4236
  readonly options: {
4237
- readonly plugins?: import("../../load").LoadPlugin[];
4237
+ readonly plugins?: import("../..").LoadPlugin[];
4238
4238
  readonly filename?: string;
4239
- readonly filesystem?: import("../../../types").Filesystem;
4239
+ readonly filesystem?: import("../../../index.js").Filesystem;
4240
4240
  throwOnError: boolean;
4241
4241
  };
4242
4242
  }, {
@@ -4249,12 +4249,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4249
4249
  toJson: () => Promise<string>;
4250
4250
  toYaml: () => Promise<string>;
4251
4251
  };
4252
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4252
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4253
4253
  readonly name: "load";
4254
4254
  readonly options: {
4255
- readonly plugins?: import("../../load").LoadPlugin[];
4255
+ readonly plugins?: import("../..").LoadPlugin[];
4256
4256
  readonly filename?: string;
4257
- readonly filesystem?: import("../../../types").Filesystem;
4257
+ readonly filesystem?: import("../../../index.js").Filesystem;
4258
4258
  throwOnError: boolean;
4259
4259
  };
4260
4260
  }, {
@@ -4265,14 +4265,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4265
4265
  toYaml: () => Promise<string>;
4266
4266
  upgrade: () => {
4267
4267
  dereference: (dereferenceOptions?: DereferenceOptions) => {
4268
- details: () => Promise<import("../../../types").DetailsResult>;
4269
- files: () => Promise<import("../../../types").Filesystem>;
4270
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4268
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4269
+ files: () => Promise<import("../../../index.js").Filesystem>;
4270
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4271
4271
  readonly name: "load";
4272
4272
  readonly options: {
4273
- readonly plugins?: import("../../load").LoadPlugin[];
4273
+ readonly plugins?: import("../..").LoadPlugin[];
4274
4274
  readonly filename?: string;
4275
- readonly filesystem?: import("../../../types").Filesystem;
4275
+ readonly filesystem?: import("../../../index.js").Filesystem;
4276
4276
  throwOnError: boolean;
4277
4277
  };
4278
4278
  }, {
@@ -4287,18 +4287,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4287
4287
  toJson: () => Promise<string>;
4288
4288
  toYaml: () => Promise<string>;
4289
4289
  };
4290
- details: () => Promise<import("../../../types").DetailsResult>;
4291
- files: () => Promise<import("../../../types").Filesystem>;
4290
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4291
+ files: () => Promise<import("../../../index.js").Filesystem>;
4292
4292
  filter: (callback: (specification: AnyObject) => boolean) => {
4293
4293
  dereference: (dereferenceOptions?: DereferenceOptions) => {
4294
- details: () => Promise<import("../../../types").DetailsResult>;
4295
- files: () => Promise<import("../../../types").Filesystem>;
4296
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4294
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4295
+ files: () => Promise<import("../../../index.js").Filesystem>;
4296
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4297
4297
  readonly name: "load";
4298
4298
  readonly options: {
4299
- readonly plugins?: import("../../load").LoadPlugin[];
4299
+ readonly plugins?: import("../..").LoadPlugin[];
4300
4300
  readonly filename?: string;
4301
- readonly filesystem?: import("../../../types").Filesystem;
4301
+ readonly filesystem?: import("../../../index.js").Filesystem;
4302
4302
  throwOnError: boolean;
4303
4303
  };
4304
4304
  }, {
@@ -4316,14 +4316,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4316
4316
  toJson: () => Promise<string>;
4317
4317
  toYaml: () => Promise<string>;
4318
4318
  };
4319
- details: () => Promise<import("../../../types").DetailsResult>;
4320
- files: () => Promise<import("../../../types").Filesystem>;
4321
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4319
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4320
+ files: () => Promise<import("../../../index.js").Filesystem>;
4321
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4322
4322
  readonly name: "load";
4323
4323
  readonly options: {
4324
- readonly plugins?: import("../../load").LoadPlugin[];
4324
+ readonly plugins?: import("../..").LoadPlugin[];
4325
4325
  readonly filename?: string;
4326
- readonly filesystem?: import("../../../types").Filesystem;
4326
+ readonly filesystem?: import("../../../index.js").Filesystem;
4327
4327
  throwOnError: boolean;
4328
4328
  };
4329
4329
  }, {
@@ -4338,12 +4338,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4338
4338
  toJson: () => Promise<string>;
4339
4339
  toYaml: () => Promise<string>;
4340
4340
  };
4341
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4341
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4342
4342
  readonly name: "load";
4343
4343
  readonly options: {
4344
- readonly plugins?: import("../../load").LoadPlugin[];
4344
+ readonly plugins?: import("../..").LoadPlugin[];
4345
4345
  readonly filename?: string;
4346
- readonly filesystem?: import("../../../types").Filesystem;
4346
+ readonly filesystem?: import("../../../index.js").Filesystem;
4347
4347
  throwOnError: boolean;
4348
4348
  };
4349
4349
  }, {
@@ -4356,14 +4356,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4356
4356
  toYaml: () => Promise<string>;
4357
4357
  validate: (validateOptions?: ValidateOptions) => {
4358
4358
  dereference: (dereferenceOptions?: DereferenceOptions) => {
4359
- details: () => Promise<import("../../../types").DetailsResult>;
4360
- files: () => Promise<import("../../../types").Filesystem>;
4361
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4359
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4360
+ files: () => Promise<import("../../../index.js").Filesystem>;
4361
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4362
4362
  readonly name: "load";
4363
4363
  readonly options: {
4364
- readonly plugins?: import("../../load").LoadPlugin[];
4364
+ readonly plugins?: import("../..").LoadPlugin[];
4365
4365
  readonly filename?: string;
4366
- readonly filesystem?: import("../../../types").Filesystem;
4366
+ readonly filesystem?: import("../../../index.js").Filesystem;
4367
4367
  throwOnError: boolean;
4368
4368
  };
4369
4369
  }, {
@@ -4381,18 +4381,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4381
4381
  toJson: () => Promise<string>;
4382
4382
  toYaml: () => Promise<string>;
4383
4383
  };
4384
- details: () => Promise<import("../../../types").DetailsResult>;
4385
- files: () => Promise<import("../../../types").Filesystem>;
4384
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4385
+ files: () => Promise<import("../../../index.js").Filesystem>;
4386
4386
  filter: (callback: (specification: AnyObject) => boolean) => {
4387
4387
  dereference: (dereferenceOptions?: DereferenceOptions) => {
4388
- details: () => Promise<import("../../../types").DetailsResult>;
4389
- files: () => Promise<import("../../../types").Filesystem>;
4390
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4388
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4389
+ files: () => Promise<import("../../../index.js").Filesystem>;
4390
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4391
4391
  readonly name: "load";
4392
4392
  readonly options: {
4393
- readonly plugins?: import("../../load").LoadPlugin[];
4393
+ readonly plugins?: import("../..").LoadPlugin[];
4394
4394
  readonly filename?: string;
4395
- readonly filesystem?: import("../../../types").Filesystem;
4395
+ readonly filesystem?: import("../../../index.js").Filesystem;
4396
4396
  throwOnError: boolean;
4397
4397
  };
4398
4398
  }, {
@@ -4413,14 +4413,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4413
4413
  toJson: () => Promise<string>;
4414
4414
  toYaml: () => Promise<string>;
4415
4415
  };
4416
- details: () => Promise<import("../../../types").DetailsResult>;
4417
- files: () => Promise<import("../../../types").Filesystem>;
4418
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4416
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4417
+ files: () => Promise<import("../../../index.js").Filesystem>;
4418
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4419
4419
  readonly name: "load";
4420
4420
  readonly options: {
4421
- readonly plugins?: import("../../load").LoadPlugin[];
4421
+ readonly plugins?: import("../..").LoadPlugin[];
4422
4422
  readonly filename?: string;
4423
- readonly filesystem?: import("../../../types").Filesystem;
4423
+ readonly filesystem?: import("../../../index.js").Filesystem;
4424
4424
  throwOnError: boolean;
4425
4425
  };
4426
4426
  }, {
@@ -4438,12 +4438,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4438
4438
  toJson: () => Promise<string>;
4439
4439
  toYaml: () => Promise<string>;
4440
4440
  };
4441
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4441
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4442
4442
  readonly name: "load";
4443
4443
  readonly options: {
4444
- readonly plugins?: import("../../load").LoadPlugin[];
4444
+ readonly plugins?: import("../..").LoadPlugin[];
4445
4445
  readonly filename?: string;
4446
- readonly filesystem?: import("../../../types").Filesystem;
4446
+ readonly filesystem?: import("../../../index.js").Filesystem;
4447
4447
  throwOnError: boolean;
4448
4448
  };
4449
4449
  }, {
@@ -4459,14 +4459,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4459
4459
  toYaml: () => Promise<string>;
4460
4460
  upgrade: () => {
4461
4461
  dereference: (dereferenceOptions?: DereferenceOptions) => {
4462
- details: () => Promise<import("../../../types").DetailsResult>;
4463
- files: () => Promise<import("../../../types").Filesystem>;
4464
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4462
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4463
+ files: () => Promise<import("../../../index.js").Filesystem>;
4464
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4465
4465
  readonly name: "load";
4466
4466
  readonly options: {
4467
- readonly plugins?: import("../../load").LoadPlugin[];
4467
+ readonly plugins?: import("../..").LoadPlugin[];
4468
4468
  readonly filename?: string;
4469
- readonly filesystem?: import("../../../types").Filesystem;
4469
+ readonly filesystem?: import("../../../index.js").Filesystem;
4470
4470
  throwOnError: boolean;
4471
4471
  };
4472
4472
  }, {
@@ -4486,18 +4486,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4486
4486
  toJson: () => Promise<string>;
4487
4487
  toYaml: () => Promise<string>;
4488
4488
  };
4489
- details: () => Promise<import("../../../types").DetailsResult>;
4490
- files: () => Promise<import("../../../types").Filesystem>;
4489
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4490
+ files: () => Promise<import("../../../index.js").Filesystem>;
4491
4491
  filter: (callback: (specification: AnyObject) => boolean) => {
4492
4492
  dereference: (dereferenceOptions?: DereferenceOptions) => {
4493
- details: () => Promise<import("../../../types").DetailsResult>;
4494
- files: () => Promise<import("../../../types").Filesystem>;
4495
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4493
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4494
+ files: () => Promise<import("../../../index.js").Filesystem>;
4495
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4496
4496
  readonly name: "load";
4497
4497
  readonly options: {
4498
- readonly plugins?: import("../../load").LoadPlugin[];
4498
+ readonly plugins?: import("../..").LoadPlugin[];
4499
4499
  readonly filename?: string;
4500
- readonly filesystem?: import("../../../types").Filesystem;
4500
+ readonly filesystem?: import("../../../index.js").Filesystem;
4501
4501
  throwOnError: boolean;
4502
4502
  };
4503
4503
  }, {
@@ -4520,14 +4520,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4520
4520
  toJson: () => Promise<string>;
4521
4521
  toYaml: () => Promise<string>;
4522
4522
  };
4523
- details: () => Promise<import("../../../types").DetailsResult>;
4524
- files: () => Promise<import("../../../types").Filesystem>;
4525
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4523
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4524
+ files: () => Promise<import("../../../index.js").Filesystem>;
4525
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4526
4526
  readonly name: "load";
4527
4527
  readonly options: {
4528
- readonly plugins?: import("../../load").LoadPlugin[];
4528
+ readonly plugins?: import("../..").LoadPlugin[];
4529
4529
  readonly filename?: string;
4530
- readonly filesystem?: import("../../../types").Filesystem;
4530
+ readonly filesystem?: import("../../../index.js").Filesystem;
4531
4531
  throwOnError: boolean;
4532
4532
  };
4533
4533
  }, {
@@ -4547,12 +4547,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4547
4547
  toJson: () => Promise<string>;
4548
4548
  toYaml: () => Promise<string>;
4549
4549
  };
4550
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4550
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4551
4551
  readonly name: "load";
4552
4552
  readonly options: {
4553
- readonly plugins?: import("../../load").LoadPlugin[];
4553
+ readonly plugins?: import("../..").LoadPlugin[];
4554
4554
  readonly filename?: string;
4555
- readonly filesystem?: import("../../../types").Filesystem;
4555
+ readonly filesystem?: import("../../../index.js").Filesystem;
4556
4556
  throwOnError: boolean;
4557
4557
  };
4558
4558
  }, {
@@ -4570,14 +4570,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4570
4570
  toYaml: () => Promise<string>;
4571
4571
  validate: (validateOptions?: ValidateOptions) => {
4572
4572
  dereference: (dereferenceOptions?: DereferenceOptions) => {
4573
- details: () => Promise<import("../../../types").DetailsResult>;
4574
- files: () => Promise<import("../../../types").Filesystem>;
4575
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4573
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4574
+ files: () => Promise<import("../../../index.js").Filesystem>;
4575
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4576
4576
  readonly name: "load";
4577
4577
  readonly options: {
4578
- readonly plugins?: import("../../load").LoadPlugin[];
4578
+ readonly plugins?: import("../..").LoadPlugin[];
4579
4579
  readonly filename?: string;
4580
- readonly filesystem?: import("../../../types").Filesystem;
4580
+ readonly filesystem?: import("../../../index.js").Filesystem;
4581
4581
  throwOnError: boolean;
4582
4582
  };
4583
4583
  }, {
@@ -4600,18 +4600,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4600
4600
  toJson: () => Promise<string>;
4601
4601
  toYaml: () => Promise<string>;
4602
4602
  };
4603
- details: () => Promise<import("../../../types").DetailsResult>;
4604
- files: () => Promise<import("../../../types").Filesystem>;
4603
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4604
+ files: () => Promise<import("../../../index.js").Filesystem>;
4605
4605
  filter: (callback: (specification: AnyObject) => boolean) => {
4606
4606
  dereference: (dereferenceOptions?: DereferenceOptions) => {
4607
- details: () => Promise<import("../../../types").DetailsResult>;
4608
- files: () => Promise<import("../../../types").Filesystem>;
4609
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4607
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4608
+ files: () => Promise<import("../../../index.js").Filesystem>;
4609
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4610
4610
  readonly name: "load";
4611
4611
  readonly options: {
4612
- readonly plugins?: import("../../load").LoadPlugin[];
4612
+ readonly plugins?: import("../..").LoadPlugin[];
4613
4613
  readonly filename?: string;
4614
- readonly filesystem?: import("../../../types").Filesystem;
4614
+ readonly filesystem?: import("../../../index.js").Filesystem;
4615
4615
  throwOnError: boolean;
4616
4616
  };
4617
4617
  }, {
@@ -4637,14 +4637,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4637
4637
  toJson: () => Promise<string>;
4638
4638
  toYaml: () => Promise<string>;
4639
4639
  };
4640
- details: () => Promise<import("../../../types").DetailsResult>;
4641
- files: () => Promise<import("../../../types").Filesystem>;
4642
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4640
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4641
+ files: () => Promise<import("../../../index.js").Filesystem>;
4642
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4643
4643
  readonly name: "load";
4644
4644
  readonly options: {
4645
- readonly plugins?: import("../../load").LoadPlugin[];
4645
+ readonly plugins?: import("../..").LoadPlugin[];
4646
4646
  readonly filename?: string;
4647
- readonly filesystem?: import("../../../types").Filesystem;
4647
+ readonly filesystem?: import("../../../index.js").Filesystem;
4648
4648
  throwOnError: boolean;
4649
4649
  };
4650
4650
  }, {
@@ -4667,12 +4667,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4667
4667
  toJson: () => Promise<string>;
4668
4668
  toYaml: () => Promise<string>;
4669
4669
  };
4670
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4670
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4671
4671
  readonly name: "load";
4672
4672
  readonly options: {
4673
- readonly plugins?: import("../../load").LoadPlugin[];
4673
+ readonly plugins?: import("../..").LoadPlugin[];
4674
4674
  readonly filename?: string;
4675
- readonly filesystem?: import("../../../types").Filesystem;
4675
+ readonly filesystem?: import("../../../index.js").Filesystem;
4676
4676
  throwOnError: boolean;
4677
4677
  };
4678
4678
  }, {
@@ -4693,14 +4693,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4693
4693
  toYaml: () => Promise<string>;
4694
4694
  upgrade: () => {
4695
4695
  dereference: (dereferenceOptions?: DereferenceOptions) => {
4696
- details: () => Promise<import("../../../types").DetailsResult>;
4697
- files: () => Promise<import("../../../types").Filesystem>;
4698
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4696
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4697
+ files: () => Promise<import("../../../index.js").Filesystem>;
4698
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4699
4699
  readonly name: "load";
4700
4700
  readonly options: {
4701
- readonly plugins?: import("../../load").LoadPlugin[];
4701
+ readonly plugins?: import("../..").LoadPlugin[];
4702
4702
  readonly filename?: string;
4703
- readonly filesystem?: import("../../../types").Filesystem;
4703
+ readonly filesystem?: import("../../../index.js").Filesystem;
4704
4704
  throwOnError: boolean;
4705
4705
  };
4706
4706
  }, {
@@ -4725,18 +4725,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4725
4725
  toJson: () => Promise<string>;
4726
4726
  toYaml: () => Promise<string>;
4727
4727
  };
4728
- details: () => Promise<import("../../../types").DetailsResult>;
4729
- files: () => Promise<import("../../../types").Filesystem>;
4728
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4729
+ files: () => Promise<import("../../../index.js").Filesystem>;
4730
4730
  filter: (callback: (specification: AnyObject) => boolean) => {
4731
4731
  dereference: (dereferenceOptions?: DereferenceOptions) => {
4732
- details: () => Promise<import("../../../types").DetailsResult>;
4733
- files: () => Promise<import("../../../types").Filesystem>;
4734
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4732
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4733
+ files: () => Promise<import("../../../index.js").Filesystem>;
4734
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4735
4735
  readonly name: "load";
4736
4736
  readonly options: {
4737
- readonly plugins?: import("../../load").LoadPlugin[];
4737
+ readonly plugins?: import("../..").LoadPlugin[];
4738
4738
  readonly filename?: string;
4739
- readonly filesystem?: import("../../../types").Filesystem;
4739
+ readonly filesystem?: import("../../../index.js").Filesystem;
4740
4740
  throwOnError: boolean;
4741
4741
  };
4742
4742
  }, {
@@ -4764,14 +4764,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4764
4764
  toJson: () => Promise<string>;
4765
4765
  toYaml: () => Promise<string>;
4766
4766
  };
4767
- details: () => Promise<import("../../../types").DetailsResult>;
4768
- files: () => Promise<import("../../../types").Filesystem>;
4769
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4767
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4768
+ files: () => Promise<import("../../../index.js").Filesystem>;
4769
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4770
4770
  readonly name: "load";
4771
4771
  readonly options: {
4772
- readonly plugins?: import("../../load").LoadPlugin[];
4772
+ readonly plugins?: import("../..").LoadPlugin[];
4773
4773
  readonly filename?: string;
4774
- readonly filesystem?: import("../../../types").Filesystem;
4774
+ readonly filesystem?: import("../../../index.js").Filesystem;
4775
4775
  throwOnError: boolean;
4776
4776
  };
4777
4777
  }, {
@@ -4796,12 +4796,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4796
4796
  toJson: () => Promise<string>;
4797
4797
  toYaml: () => Promise<string>;
4798
4798
  };
4799
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4799
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4800
4800
  readonly name: "load";
4801
4801
  readonly options: {
4802
- readonly plugins?: import("../../load").LoadPlugin[];
4802
+ readonly plugins?: import("../..").LoadPlugin[];
4803
4803
  readonly filename?: string;
4804
- readonly filesystem?: import("../../../types").Filesystem;
4804
+ readonly filesystem?: import("../../../index.js").Filesystem;
4805
4805
  throwOnError: boolean;
4806
4806
  };
4807
4807
  }, {
@@ -4824,14 +4824,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4824
4824
  toYaml: () => Promise<string>;
4825
4825
  validate: (validateOptions?: ValidateOptions) => {
4826
4826
  dereference: (dereferenceOptions?: DereferenceOptions) => {
4827
- details: () => Promise<import("../../../types").DetailsResult>;
4828
- files: () => Promise<import("../../../types").Filesystem>;
4829
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4827
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4828
+ files: () => Promise<import("../../../index.js").Filesystem>;
4829
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4830
4830
  readonly name: "load";
4831
4831
  readonly options: {
4832
- readonly plugins?: import("../../load").LoadPlugin[];
4832
+ readonly plugins?: import("../..").LoadPlugin[];
4833
4833
  readonly filename?: string;
4834
- readonly filesystem?: import("../../../types").Filesystem;
4834
+ readonly filesystem?: import("../../../index.js").Filesystem;
4835
4835
  throwOnError: boolean;
4836
4836
  };
4837
4837
  }, {
@@ -4859,18 +4859,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4859
4859
  toJson: () => Promise<string>;
4860
4860
  toYaml: () => Promise<string>;
4861
4861
  };
4862
- details: () => Promise<import("../../../types").DetailsResult>;
4863
- files: () => Promise<import("../../../types").Filesystem>;
4862
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4863
+ files: () => Promise<import("../../../index.js").Filesystem>;
4864
4864
  filter: (callback: (specification: AnyObject) => boolean) => {
4865
4865
  dereference: (dereferenceOptions?: DereferenceOptions) => {
4866
- details: () => Promise<import("../../../types").DetailsResult>;
4867
- files: () => Promise<import("../../../types").Filesystem>;
4868
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4866
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4867
+ files: () => Promise<import("../../../index.js").Filesystem>;
4868
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4869
4869
  readonly name: "load";
4870
4870
  readonly options: {
4871
- readonly plugins?: import("../../load").LoadPlugin[];
4871
+ readonly plugins?: import("../..").LoadPlugin[];
4872
4872
  readonly filename?: string;
4873
- readonly filesystem?: import("../../../types").Filesystem;
4873
+ readonly filesystem?: import("../../../index.js").Filesystem;
4874
4874
  throwOnError: boolean;
4875
4875
  };
4876
4876
  }, {
@@ -4901,14 +4901,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4901
4901
  toJson: () => Promise<string>;
4902
4902
  toYaml: () => Promise<string>;
4903
4903
  };
4904
- details: () => Promise<import("../../../types").DetailsResult>;
4905
- files: () => Promise<import("../../../types").Filesystem>;
4906
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4904
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4905
+ files: () => Promise<import("../../../index.js").Filesystem>;
4906
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4907
4907
  readonly name: "load";
4908
4908
  readonly options: {
4909
- readonly plugins?: import("../../load").LoadPlugin[];
4909
+ readonly plugins?: import("../..").LoadPlugin[];
4910
4910
  readonly filename?: string;
4911
- readonly filesystem?: import("../../../types").Filesystem;
4911
+ readonly filesystem?: import("../../../index.js").Filesystem;
4912
4912
  throwOnError: boolean;
4913
4913
  };
4914
4914
  }, {
@@ -4936,12 +4936,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4936
4936
  toJson: () => Promise<string>;
4937
4937
  toYaml: () => Promise<string>;
4938
4938
  };
4939
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4939
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4940
4940
  readonly name: "load";
4941
4941
  readonly options: {
4942
- readonly plugins?: import("../../load").LoadPlugin[];
4942
+ readonly plugins?: import("../..").LoadPlugin[];
4943
4943
  readonly filename?: string;
4944
- readonly filesystem?: import("../../../types").Filesystem;
4944
+ readonly filesystem?: import("../../../index.js").Filesystem;
4945
4945
  throwOnError: boolean;
4946
4946
  };
4947
4947
  }, {
@@ -4967,14 +4967,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
4967
4967
  toYaml: () => Promise<string>;
4968
4968
  upgrade: () => {
4969
4969
  dereference: (dereferenceOptions?: DereferenceOptions) => {
4970
- details: () => Promise<import("../../../types").DetailsResult>;
4971
- files: () => Promise<import("../../../types").Filesystem>;
4972
- get: () => Promise<import("../../../types").CommandChain<[...T, {
4970
+ details: () => Promise<import("../../../index.js").DetailsResult>;
4971
+ files: () => Promise<import("../../../index.js").Filesystem>;
4972
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
4973
4973
  readonly name: "load";
4974
4974
  readonly options: {
4975
- readonly plugins?: import("../../load").LoadPlugin[];
4975
+ readonly plugins?: import("../..").LoadPlugin[];
4976
4976
  readonly filename?: string;
4977
- readonly filesystem?: import("../../../types").Filesystem;
4977
+ readonly filesystem?: import("../../../index.js").Filesystem;
4978
4978
  throwOnError: boolean;
4979
4979
  };
4980
4980
  }, {
@@ -5004,18 +5004,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
5004
5004
  toJson: () => Promise<string>;
5005
5005
  toYaml: () => Promise<string>;
5006
5006
  };
5007
- details: () => Promise<import("../../../types").DetailsResult>;
5008
- files: () => Promise<import("../../../types").Filesystem>;
5007
+ details: () => Promise<import("../../../index.js").DetailsResult>;
5008
+ files: () => Promise<import("../../../index.js").Filesystem>;
5009
5009
  filter: (callback: (specification: AnyObject) => boolean) => {
5010
5010
  dereference: (dereferenceOptions?: DereferenceOptions) => {
5011
- details: () => Promise<import("../../../types").DetailsResult>;
5012
- files: () => Promise<import("../../../types").Filesystem>;
5013
- get: () => Promise<import("../../../types").CommandChain<[...T, {
5011
+ details: () => Promise<import("../../../index.js").DetailsResult>;
5012
+ files: () => Promise<import("../../../index.js").Filesystem>;
5013
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
5014
5014
  readonly name: "load";
5015
5015
  readonly options: {
5016
- readonly plugins?: import("../../load").LoadPlugin[];
5016
+ readonly plugins?: import("../..").LoadPlugin[];
5017
5017
  readonly filename?: string;
5018
- readonly filesystem?: import("../../../types").Filesystem;
5018
+ readonly filesystem?: import("../../../index.js").Filesystem;
5019
5019
  throwOnError: boolean;
5020
5020
  };
5021
5021
  }, {
@@ -5048,14 +5048,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
5048
5048
  toJson: () => Promise<string>;
5049
5049
  toYaml: () => Promise<string>;
5050
5050
  };
5051
- details: () => Promise<import("../../../types").DetailsResult>;
5052
- files: () => Promise<import("../../../types").Filesystem>;
5053
- get: () => Promise<import("../../../types").CommandChain<[...T, {
5051
+ details: () => Promise<import("../../../index.js").DetailsResult>;
5052
+ files: () => Promise<import("../../../index.js").Filesystem>;
5053
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
5054
5054
  readonly name: "load";
5055
5055
  readonly options: {
5056
- readonly plugins?: import("../../load").LoadPlugin[];
5056
+ readonly plugins?: import("../..").LoadPlugin[];
5057
5057
  readonly filename?: string;
5058
- readonly filesystem?: import("../../../types").Filesystem;
5058
+ readonly filesystem?: import("../../../index.js").Filesystem;
5059
5059
  throwOnError: boolean;
5060
5060
  };
5061
5061
  }, {
@@ -5085,12 +5085,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
5085
5085
  toJson: () => Promise<string>;
5086
5086
  toYaml: () => Promise<string>;
5087
5087
  };
5088
- get: () => Promise<import("../../../types").CommandChain<[...T, {
5088
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
5089
5089
  readonly name: "load";
5090
5090
  readonly options: {
5091
- readonly plugins?: import("../../load").LoadPlugin[];
5091
+ readonly plugins?: import("../..").LoadPlugin[];
5092
5092
  readonly filename?: string;
5093
- readonly filesystem?: import("../../../types").Filesystem;
5093
+ readonly filesystem?: import("../../../index.js").Filesystem;
5094
5094
  throwOnError: boolean;
5095
5095
  };
5096
5096
  }, {
@@ -5118,14 +5118,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
5118
5118
  toYaml: () => Promise<string>;
5119
5119
  validate: (validateOptions?: ValidateOptions) => {
5120
5120
  dereference: (dereferenceOptions?: DereferenceOptions) => {
5121
- details: () => Promise<import("../../../types").DetailsResult>;
5122
- files: () => Promise<import("../../../types").Filesystem>;
5123
- get: () => Promise<import("../../../types").CommandChain<[...T, {
5121
+ details: () => Promise<import("../../../index.js").DetailsResult>;
5122
+ files: () => Promise<import("../../../index.js").Filesystem>;
5123
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
5124
5124
  readonly name: "load";
5125
5125
  readonly options: {
5126
- readonly plugins?: import("../../load").LoadPlugin[];
5126
+ readonly plugins?: import("../..").LoadPlugin[];
5127
5127
  readonly filename?: string;
5128
- readonly filesystem?: import("../../../types").Filesystem;
5128
+ readonly filesystem?: import("../../../index.js").Filesystem;
5129
5129
  throwOnError: boolean;
5130
5130
  };
5131
5131
  }, {
@@ -5158,18 +5158,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
5158
5158
  toJson: () => Promise<string>;
5159
5159
  toYaml: () => Promise<string>;
5160
5160
  };
5161
- details: () => Promise<import("../../../types").DetailsResult>;
5162
- files: () => Promise<import("../../../types").Filesystem>;
5161
+ details: () => Promise<import("../../../index.js").DetailsResult>;
5162
+ files: () => Promise<import("../../../index.js").Filesystem>;
5163
5163
  filter: (callback: (specification: AnyObject) => boolean) => {
5164
5164
  dereference: (dereferenceOptions?: DereferenceOptions) => {
5165
- details: () => Promise<import("../../../types").DetailsResult>;
5166
- files: () => Promise<import("../../../types").Filesystem>;
5167
- get: () => Promise<import("../../../types").CommandChain<[...T, {
5165
+ details: () => Promise<import("../../../index.js").DetailsResult>;
5166
+ files: () => Promise<import("../../../index.js").Filesystem>;
5167
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
5168
5168
  readonly name: "load";
5169
5169
  readonly options: {
5170
- readonly plugins?: import("../../load").LoadPlugin[];
5170
+ readonly plugins?: import("../..").LoadPlugin[];
5171
5171
  readonly filename?: string;
5172
- readonly filesystem?: import("../../../types").Filesystem;
5172
+ readonly filesystem?: import("../../../index.js").Filesystem;
5173
5173
  throwOnError: boolean;
5174
5174
  };
5175
5175
  }, {
@@ -5205,14 +5205,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
5205
5205
  toJson: () => Promise<string>;
5206
5206
  toYaml: () => Promise<string>;
5207
5207
  };
5208
- details: () => Promise<import("../../../types").DetailsResult>;
5209
- files: () => Promise<import("../../../types").Filesystem>;
5210
- get: () => Promise<import("../../../types").CommandChain<[...T, {
5208
+ details: () => Promise<import("../../../index.js").DetailsResult>;
5209
+ files: () => Promise<import("../../../index.js").Filesystem>;
5210
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
5211
5211
  readonly name: "load";
5212
5212
  readonly options: {
5213
- readonly plugins?: import("../../load").LoadPlugin[];
5213
+ readonly plugins?: import("../..").LoadPlugin[];
5214
5214
  readonly filename?: string;
5215
- readonly filesystem?: import("../../../types").Filesystem;
5215
+ readonly filesystem?: import("../../../index.js").Filesystem;
5216
5216
  throwOnError: boolean;
5217
5217
  };
5218
5218
  }, {
@@ -5245,12 +5245,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
5245
5245
  toJson: () => Promise<string>;
5246
5246
  toYaml: () => Promise<string>;
5247
5247
  };
5248
- get: () => Promise<import("../../../types").CommandChain<[...T, {
5248
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
5249
5249
  readonly name: "load";
5250
5250
  readonly options: {
5251
- readonly plugins?: import("../../load").LoadPlugin[];
5251
+ readonly plugins?: import("../..").LoadPlugin[];
5252
5252
  readonly filename?: string;
5253
- readonly filesystem?: import("../../../types").Filesystem;
5253
+ readonly filesystem?: import("../../../index.js").Filesystem;
5254
5254
  throwOnError: boolean;
5255
5255
  };
5256
5256
  }, {
@@ -5281,14 +5281,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
5281
5281
  toYaml: () => Promise<string>;
5282
5282
  upgrade: () => {
5283
5283
  dereference: (dereferenceOptions?: DereferenceOptions) => {
5284
- details: () => Promise<import("../../../types").DetailsResult>;
5285
- files: () => Promise<import("../../../types").Filesystem>;
5286
- get: () => Promise<import("../../../types").CommandChain<[...T, {
5284
+ details: () => Promise<import("../../../index.js").DetailsResult>;
5285
+ files: () => Promise<import("../../../index.js").Filesystem>;
5286
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
5287
5287
  readonly name: "load";
5288
5288
  readonly options: {
5289
- readonly plugins?: import("../../load").LoadPlugin[];
5289
+ readonly plugins?: import("../..").LoadPlugin[];
5290
5290
  readonly filename?: string;
5291
- readonly filesystem?: import("../../../types").Filesystem;
5291
+ readonly filesystem?: import("../../../index.js").Filesystem;
5292
5292
  throwOnError: boolean;
5293
5293
  };
5294
5294
  }, {
@@ -5323,18 +5323,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
5323
5323
  toJson: () => Promise<string>;
5324
5324
  toYaml: () => Promise<string>;
5325
5325
  };
5326
- details: () => Promise<import("../../../types").DetailsResult>;
5327
- files: () => Promise<import("../../../types").Filesystem>;
5326
+ details: () => Promise<import("../../../index.js").DetailsResult>;
5327
+ files: () => Promise<import("../../../index.js").Filesystem>;
5328
5328
  filter: (callback: (specification: AnyObject) => boolean) => {
5329
5329
  dereference: (dereferenceOptions?: DereferenceOptions) => {
5330
- details: () => Promise<import("../../../types").DetailsResult>;
5331
- files: () => Promise<import("../../../types").Filesystem>;
5332
- get: () => Promise<import("../../../types").CommandChain<[...T, {
5330
+ details: () => Promise<import("../../../index.js").DetailsResult>;
5331
+ files: () => Promise<import("../../../index.js").Filesystem>;
5332
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
5333
5333
  readonly name: "load";
5334
5334
  readonly options: {
5335
- readonly plugins?: import("../../load").LoadPlugin[];
5335
+ readonly plugins?: import("../..").LoadPlugin[];
5336
5336
  readonly filename?: string;
5337
- readonly filesystem?: import("../../../types").Filesystem;
5337
+ readonly filesystem?: import("../../../index.js").Filesystem;
5338
5338
  throwOnError: boolean;
5339
5339
  };
5340
5340
  }, {
@@ -5372,14 +5372,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
5372
5372
  toJson: () => Promise<string>;
5373
5373
  toYaml: () => Promise<string>;
5374
5374
  };
5375
- details: () => Promise<import("../../../types").DetailsResult>;
5376
- files: () => Promise<import("../../../types").Filesystem>;
5377
- get: () => Promise<import("../../../types").CommandChain<[...T, {
5375
+ details: () => Promise<import("../../../index.js").DetailsResult>;
5376
+ files: () => Promise<import("../../../index.js").Filesystem>;
5377
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
5378
5378
  readonly name: "load";
5379
5379
  readonly options: {
5380
- readonly plugins?: import("../../load").LoadPlugin[];
5380
+ readonly plugins?: import("../..").LoadPlugin[];
5381
5381
  readonly filename?: string;
5382
- readonly filesystem?: import("../../../types").Filesystem;
5382
+ readonly filesystem?: import("../../../index.js").Filesystem;
5383
5383
  throwOnError: boolean;
5384
5384
  };
5385
5385
  }, {
@@ -5414,12 +5414,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
5414
5414
  toJson: () => Promise<string>;
5415
5415
  toYaml: () => Promise<string>;
5416
5416
  };
5417
- get: () => Promise<import("../../../types").CommandChain<[...T, {
5417
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
5418
5418
  readonly name: "load";
5419
5419
  readonly options: {
5420
- readonly plugins?: import("../../load").LoadPlugin[];
5420
+ readonly plugins?: import("../..").LoadPlugin[];
5421
5421
  readonly filename?: string;
5422
- readonly filesystem?: import("../../../types").Filesystem;
5422
+ readonly filesystem?: import("../../../index.js").Filesystem;
5423
5423
  throwOnError: boolean;
5424
5424
  };
5425
5425
  }, {
@@ -5452,14 +5452,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
5452
5452
  toYaml: () => Promise<string>;
5453
5453
  validate: (validateOptions?: ValidateOptions) => {
5454
5454
  dereference: (dereferenceOptions?: DereferenceOptions) => {
5455
- details: () => Promise<import("../../../types").DetailsResult>;
5456
- files: () => Promise<import("../../../types").Filesystem>;
5457
- get: () => Promise<import("../../../types").CommandChain<[...T, {
5455
+ details: () => Promise<import("../../../index.js").DetailsResult>;
5456
+ files: () => Promise<import("../../../index.js").Filesystem>;
5457
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
5458
5458
  readonly name: "load";
5459
5459
  readonly options: {
5460
- readonly plugins?: import("../../load").LoadPlugin[];
5460
+ readonly plugins?: import("../..").LoadPlugin[];
5461
5461
  readonly filename?: string;
5462
- readonly filesystem?: import("../../../types").Filesystem;
5462
+ readonly filesystem?: import("../../../index.js").Filesystem;
5463
5463
  throwOnError: boolean;
5464
5464
  };
5465
5465
  }, {
@@ -5497,18 +5497,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
5497
5497
  toJson: () => Promise<string>;
5498
5498
  toYaml: () => Promise<string>;
5499
5499
  };
5500
- details: () => Promise<import("../../../types").DetailsResult>;
5501
- files: () => Promise<import("../../../types").Filesystem>;
5500
+ details: () => Promise<import("../../../index.js").DetailsResult>;
5501
+ files: () => Promise<import("../../../index.js").Filesystem>;
5502
5502
  filter: (callback: (specification: AnyObject) => boolean) => {
5503
5503
  dereference: (dereferenceOptions?: DereferenceOptions) => {
5504
- details: () => Promise<import("../../../types").DetailsResult>;
5505
- files: () => Promise<import("../../../types").Filesystem>;
5506
- get: () => Promise<import("../../../types").CommandChain<[...T, {
5504
+ details: () => Promise<import("../../../index.js").DetailsResult>;
5505
+ files: () => Promise<import("../../../index.js").Filesystem>;
5506
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
5507
5507
  readonly name: "load";
5508
5508
  readonly options: {
5509
- readonly plugins?: import("../../load").LoadPlugin[];
5509
+ readonly plugins?: import("../..").LoadPlugin[];
5510
5510
  readonly filename?: string;
5511
- readonly filesystem?: import("../../../types").Filesystem;
5511
+ readonly filesystem?: import("../../../index.js").Filesystem;
5512
5512
  throwOnError: boolean;
5513
5513
  };
5514
5514
  }, {
@@ -5549,14 +5549,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
5549
5549
  toJson: () => Promise<string>;
5550
5550
  toYaml: () => Promise<string>;
5551
5551
  };
5552
- details: () => Promise<import("../../../types").DetailsResult>;
5553
- files: () => Promise<import("../../../types").Filesystem>;
5554
- get: () => Promise<import("../../../types").CommandChain<[...T, {
5552
+ details: () => Promise<import("../../../index.js").DetailsResult>;
5553
+ files: () => Promise<import("../../../index.js").Filesystem>;
5554
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
5555
5555
  readonly name: "load";
5556
5556
  readonly options: {
5557
- readonly plugins?: import("../../load").LoadPlugin[];
5557
+ readonly plugins?: import("../..").LoadPlugin[];
5558
5558
  readonly filename?: string;
5559
- readonly filesystem?: import("../../../types").Filesystem;
5559
+ readonly filesystem?: import("../../../index.js").Filesystem;
5560
5560
  throwOnError: boolean;
5561
5561
  };
5562
5562
  }, {
@@ -5594,12 +5594,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
5594
5594
  toJson: () => Promise<string>;
5595
5595
  toYaml: () => Promise<string>;
5596
5596
  };
5597
- get: () => Promise<import("../../../types").CommandChain<[...T, {
5597
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
5598
5598
  readonly name: "load";
5599
5599
  readonly options: {
5600
- readonly plugins?: import("../../load").LoadPlugin[];
5600
+ readonly plugins?: import("../..").LoadPlugin[];
5601
5601
  readonly filename?: string;
5602
- readonly filesystem?: import("../../../types").Filesystem;
5602
+ readonly filesystem?: import("../../../index.js").Filesystem;
5603
5603
  throwOnError: boolean;
5604
5604
  };
5605
5605
  }, {
@@ -5635,14 +5635,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
5635
5635
  toYaml: () => Promise<string>;
5636
5636
  upgrade: () => {
5637
5637
  dereference: (dereferenceOptions?: DereferenceOptions) => {
5638
- details: () => Promise<import("../../../types").DetailsResult>;
5639
- files: () => Promise<import("../../../types").Filesystem>;
5640
- get: () => Promise<import("../../../types").CommandChain<[...T, {
5638
+ details: () => Promise<import("../../../index.js").DetailsResult>;
5639
+ files: () => Promise<import("../../../index.js").Filesystem>;
5640
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
5641
5641
  readonly name: "load";
5642
5642
  readonly options: {
5643
- readonly plugins?: import("../../load").LoadPlugin[];
5643
+ readonly plugins?: import("../..").LoadPlugin[];
5644
5644
  readonly filename?: string;
5645
- readonly filesystem?: import("../../../types").Filesystem;
5645
+ readonly filesystem?: import("../../../index.js").Filesystem;
5646
5646
  throwOnError: boolean;
5647
5647
  };
5648
5648
  }, {
@@ -5682,18 +5682,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
5682
5682
  toJson: () => Promise<string>;
5683
5683
  toYaml: () => Promise<string>;
5684
5684
  };
5685
- details: () => Promise<import("../../../types").DetailsResult>;
5686
- files: () => Promise<import("../../../types").Filesystem>;
5685
+ details: () => Promise<import("../../../index.js").DetailsResult>;
5686
+ files: () => Promise<import("../../../index.js").Filesystem>;
5687
5687
  filter: (callback: (specification: AnyObject) => boolean) => {
5688
5688
  dereference: (dereferenceOptions?: DereferenceOptions) => {
5689
- details: () => Promise<import("../../../types").DetailsResult>;
5690
- files: () => Promise<import("../../../types").Filesystem>;
5691
- get: () => Promise<import("../../../types").CommandChain<[...T, {
5689
+ details: () => Promise<import("../../../index.js").DetailsResult>;
5690
+ files: () => Promise<import("../../../index.js").Filesystem>;
5691
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
5692
5692
  readonly name: "load";
5693
5693
  readonly options: {
5694
- readonly plugins?: import("../../load").LoadPlugin[];
5694
+ readonly plugins?: import("../..").LoadPlugin[];
5695
5695
  readonly filename?: string;
5696
- readonly filesystem?: import("../../../types").Filesystem;
5696
+ readonly filesystem?: import("../../../index.js").Filesystem;
5697
5697
  throwOnError: boolean;
5698
5698
  };
5699
5699
  }, {
@@ -5736,14 +5736,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
5736
5736
  toJson: () => Promise<string>;
5737
5737
  toYaml: () => Promise<string>;
5738
5738
  };
5739
- details: () => Promise<import("../../../types").DetailsResult>;
5740
- files: () => Promise<import("../../../types").Filesystem>;
5741
- get: () => Promise<import("../../../types").CommandChain<[...T, {
5739
+ details: () => Promise<import("../../../index.js").DetailsResult>;
5740
+ files: () => Promise<import("../../../index.js").Filesystem>;
5741
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
5742
5742
  readonly name: "load";
5743
5743
  readonly options: {
5744
- readonly plugins?: import("../../load").LoadPlugin[];
5744
+ readonly plugins?: import("../..").LoadPlugin[];
5745
5745
  readonly filename?: string;
5746
- readonly filesystem?: import("../../../types").Filesystem;
5746
+ readonly filesystem?: import("../../../index.js").Filesystem;
5747
5747
  throwOnError: boolean;
5748
5748
  };
5749
5749
  }, {
@@ -5783,12 +5783,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
5783
5783
  toJson: () => Promise<string>;
5784
5784
  toYaml: () => Promise<string>;
5785
5785
  };
5786
- get: () => Promise<import("../../../types").CommandChain<[...T, {
5786
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
5787
5787
  readonly name: "load";
5788
5788
  readonly options: {
5789
- readonly plugins?: import("../../load").LoadPlugin[];
5789
+ readonly plugins?: import("../..").LoadPlugin[];
5790
5790
  readonly filename?: string;
5791
- readonly filesystem?: import("../../../types").Filesystem;
5791
+ readonly filesystem?: import("../../../index.js").Filesystem;
5792
5792
  throwOnError: boolean;
5793
5793
  };
5794
5794
  }, {
@@ -5826,14 +5826,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
5826
5826
  toYaml: () => Promise<string>;
5827
5827
  validate: (validateOptions?: ValidateOptions) => {
5828
5828
  dereference: (dereferenceOptions?: DereferenceOptions) => {
5829
- details: () => Promise<import("../../../types").DetailsResult>;
5830
- files: () => Promise<import("../../../types").Filesystem>;
5831
- get: () => Promise<import("../../../types").CommandChain<[...T, {
5829
+ details: () => Promise<import("../../../index.js").DetailsResult>;
5830
+ files: () => Promise<import("../../../index.js").Filesystem>;
5831
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
5832
5832
  readonly name: "load";
5833
5833
  readonly options: {
5834
- readonly plugins?: import("../../load").LoadPlugin[];
5834
+ readonly plugins?: import("../..").LoadPlugin[];
5835
5835
  readonly filename?: string;
5836
- readonly filesystem?: import("../../../types").Filesystem;
5836
+ readonly filesystem?: import("../../../index.js").Filesystem;
5837
5837
  throwOnError: boolean;
5838
5838
  };
5839
5839
  }, {
@@ -5876,18 +5876,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
5876
5876
  toJson: () => Promise<string>;
5877
5877
  toYaml: () => Promise<string>;
5878
5878
  };
5879
- details: () => Promise<import("../../../types").DetailsResult>;
5880
- files: () => Promise<import("../../../types").Filesystem>;
5879
+ details: () => Promise<import("../../../index.js").DetailsResult>;
5880
+ files: () => Promise<import("../../../index.js").Filesystem>;
5881
5881
  filter: (callback: (specification: AnyObject) => boolean) => {
5882
5882
  dereference: (dereferenceOptions?: DereferenceOptions) => {
5883
- details: () => Promise<import("../../../types").DetailsResult>;
5884
- files: () => Promise<import("../../../types").Filesystem>;
5885
- get: () => Promise<import("../../../types").CommandChain<[...T, {
5883
+ details: () => Promise<import("../../../index.js").DetailsResult>;
5884
+ files: () => Promise<import("../../../index.js").Filesystem>;
5885
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
5886
5886
  readonly name: "load";
5887
5887
  readonly options: {
5888
- readonly plugins?: import("../../load").LoadPlugin[];
5888
+ readonly plugins?: import("../..").LoadPlugin[];
5889
5889
  readonly filename?: string;
5890
- readonly filesystem?: import("../../../types").Filesystem;
5890
+ readonly filesystem?: import("../../../index.js").Filesystem;
5891
5891
  throwOnError: boolean;
5892
5892
  };
5893
5893
  }, {
@@ -5933,14 +5933,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
5933
5933
  toJson: () => Promise<string>;
5934
5934
  toYaml: () => Promise<string>;
5935
5935
  };
5936
- details: () => Promise<import("../../../types").DetailsResult>;
5937
- files: () => Promise<import("../../../types").Filesystem>;
5938
- get: () => Promise<import("../../../types").CommandChain<[...T, {
5936
+ details: () => Promise<import("../../../index.js").DetailsResult>;
5937
+ files: () => Promise<import("../../../index.js").Filesystem>;
5938
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
5939
5939
  readonly name: "load";
5940
5940
  readonly options: {
5941
- readonly plugins?: import("../../load").LoadPlugin[];
5941
+ readonly plugins?: import("../..").LoadPlugin[];
5942
5942
  readonly filename?: string;
5943
- readonly filesystem?: import("../../../types").Filesystem;
5943
+ readonly filesystem?: import("../../../index.js").Filesystem;
5944
5944
  throwOnError: boolean;
5945
5945
  };
5946
5946
  }, {
@@ -5983,12 +5983,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
5983
5983
  toJson: () => Promise<string>;
5984
5984
  toYaml: () => Promise<string>;
5985
5985
  };
5986
- get: () => Promise<import("../../../types").CommandChain<[...T, {
5986
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
5987
5987
  readonly name: "load";
5988
5988
  readonly options: {
5989
- readonly plugins?: import("../../load").LoadPlugin[];
5989
+ readonly plugins?: import("../..").LoadPlugin[];
5990
5990
  readonly filename?: string;
5991
- readonly filesystem?: import("../../../types").Filesystem;
5991
+ readonly filesystem?: import("../../../index.js").Filesystem;
5992
5992
  throwOnError: boolean;
5993
5993
  };
5994
5994
  }, {
@@ -6029,14 +6029,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
6029
6029
  toYaml: () => Promise<string>;
6030
6030
  upgrade: () => {
6031
6031
  dereference: (dereferenceOptions?: DereferenceOptions) => {
6032
- details: () => Promise<import("../../../types").DetailsResult>;
6033
- files: () => Promise<import("../../../types").Filesystem>;
6034
- get: () => Promise<import("../../../types").CommandChain<[...T, {
6032
+ details: () => Promise<import("../../../index.js").DetailsResult>;
6033
+ files: () => Promise<import("../../../index.js").Filesystem>;
6034
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
6035
6035
  readonly name: "load";
6036
6036
  readonly options: {
6037
- readonly plugins?: import("../../load").LoadPlugin[];
6037
+ readonly plugins?: import("../..").LoadPlugin[];
6038
6038
  readonly filename?: string;
6039
- readonly filesystem?: import("../../../types").Filesystem;
6039
+ readonly filesystem?: import("../../../index.js").Filesystem;
6040
6040
  throwOnError: boolean;
6041
6041
  };
6042
6042
  }, {
@@ -6081,18 +6081,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
6081
6081
  toJson: () => Promise<string>;
6082
6082
  toYaml: () => Promise<string>;
6083
6083
  };
6084
- details: () => Promise<import("../../../types").DetailsResult>;
6085
- files: () => Promise<import("../../../types").Filesystem>;
6084
+ details: () => Promise<import("../../../index.js").DetailsResult>;
6085
+ files: () => Promise<import("../../../index.js").Filesystem>;
6086
6086
  filter: (callback: (specification: AnyObject) => boolean) => {
6087
6087
  dereference: (dereferenceOptions?: DereferenceOptions) => {
6088
- details: () => Promise<import("../../../types").DetailsResult>;
6089
- files: () => Promise<import("../../../types").Filesystem>;
6090
- get: () => Promise<import("../../../types").CommandChain<[...T, {
6088
+ details: () => Promise<import("../../../index.js").DetailsResult>;
6089
+ files: () => Promise<import("../../../index.js").Filesystem>;
6090
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
6091
6091
  readonly name: "load";
6092
6092
  readonly options: {
6093
- readonly plugins?: import("../../load").LoadPlugin[];
6093
+ readonly plugins?: import("../..").LoadPlugin[];
6094
6094
  readonly filename?: string;
6095
- readonly filesystem?: import("../../../types").Filesystem;
6095
+ readonly filesystem?: import("../../../index.js").Filesystem;
6096
6096
  throwOnError: boolean;
6097
6097
  };
6098
6098
  }, {
@@ -6140,14 +6140,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
6140
6140
  toJson: () => Promise<string>;
6141
6141
  toYaml: () => Promise<string>;
6142
6142
  };
6143
- details: () => Promise<import("../../../types").DetailsResult>;
6144
- files: () => Promise<import("../../../types").Filesystem>;
6145
- get: () => Promise<import("../../../types").CommandChain<[...T, {
6143
+ details: () => Promise<import("../../../index.js").DetailsResult>;
6144
+ files: () => Promise<import("../../../index.js").Filesystem>;
6145
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
6146
6146
  readonly name: "load";
6147
6147
  readonly options: {
6148
- readonly plugins?: import("../../load").LoadPlugin[];
6148
+ readonly plugins?: import("../..").LoadPlugin[];
6149
6149
  readonly filename?: string;
6150
- readonly filesystem?: import("../../../types").Filesystem;
6150
+ readonly filesystem?: import("../../../index.js").Filesystem;
6151
6151
  throwOnError: boolean;
6152
6152
  };
6153
6153
  }, {
@@ -6192,12 +6192,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
6192
6192
  toJson: () => Promise<string>;
6193
6193
  toYaml: () => Promise<string>;
6194
6194
  };
6195
- get: () => Promise<import("../../../types").CommandChain<[...T, {
6195
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
6196
6196
  readonly name: "load";
6197
6197
  readonly options: {
6198
- readonly plugins?: import("../../load").LoadPlugin[];
6198
+ readonly plugins?: import("../..").LoadPlugin[];
6199
6199
  readonly filename?: string;
6200
- readonly filesystem?: import("../../../types").Filesystem;
6200
+ readonly filesystem?: import("../../../index.js").Filesystem;
6201
6201
  throwOnError: boolean;
6202
6202
  };
6203
6203
  }, {
@@ -6240,14 +6240,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
6240
6240
  toYaml: () => Promise<string>;
6241
6241
  validate: (validateOptions?: ValidateOptions) => {
6242
6242
  dereference: (dereferenceOptions?: DereferenceOptions) => {
6243
- details: () => Promise<import("../../../types").DetailsResult>;
6244
- files: () => Promise<import("../../../types").Filesystem>;
6245
- get: () => Promise<import("../../../types").CommandChain<[...T, {
6243
+ details: () => Promise<import("../../../index.js").DetailsResult>;
6244
+ files: () => Promise<import("../../../index.js").Filesystem>;
6245
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
6246
6246
  readonly name: "load";
6247
6247
  readonly options: {
6248
- readonly plugins?: import("../../load").LoadPlugin[];
6248
+ readonly plugins?: import("../..").LoadPlugin[];
6249
6249
  readonly filename?: string;
6250
- readonly filesystem?: import("../../../types").Filesystem;
6250
+ readonly filesystem?: import("../../../index.js").Filesystem;
6251
6251
  throwOnError: boolean;
6252
6252
  };
6253
6253
  }, {
@@ -6295,18 +6295,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
6295
6295
  toJson: () => Promise<string>;
6296
6296
  toYaml: () => Promise<string>;
6297
6297
  };
6298
- details: () => Promise<import("../../../types").DetailsResult>;
6299
- files: () => Promise<import("../../../types").Filesystem>;
6298
+ details: () => Promise<import("../../../index.js").DetailsResult>;
6299
+ files: () => Promise<import("../../../index.js").Filesystem>;
6300
6300
  filter: (callback: (specification: AnyObject) => boolean) => {
6301
6301
  dereference: (dereferenceOptions?: DereferenceOptions) => {
6302
- details: () => Promise<import("../../../types").DetailsResult>;
6303
- files: () => Promise<import("../../../types").Filesystem>;
6304
- get: () => Promise<import("../../../types").CommandChain<[...T, {
6302
+ details: () => Promise<import("../../../index.js").DetailsResult>;
6303
+ files: () => Promise<import("../../../index.js").Filesystem>;
6304
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
6305
6305
  readonly name: "load";
6306
6306
  readonly options: {
6307
- readonly plugins?: import("../../load").LoadPlugin[];
6307
+ readonly plugins?: import("../..").LoadPlugin[];
6308
6308
  readonly filename?: string;
6309
- readonly filesystem?: import("../../../types").Filesystem;
6309
+ readonly filesystem?: import("../../../index.js").Filesystem;
6310
6310
  throwOnError: boolean;
6311
6311
  };
6312
6312
  }, {
@@ -6357,14 +6357,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
6357
6357
  toJson: () => Promise<string>;
6358
6358
  toYaml: () => Promise<string>;
6359
6359
  };
6360
- details: () => Promise<import("../../../types").DetailsResult>;
6361
- files: () => Promise<import("../../../types").Filesystem>;
6362
- get: () => Promise<import("../../../types").CommandChain<[...T, {
6360
+ details: () => Promise<import("../../../index.js").DetailsResult>;
6361
+ files: () => Promise<import("../../../index.js").Filesystem>;
6362
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
6363
6363
  readonly name: "load";
6364
6364
  readonly options: {
6365
- readonly plugins?: import("../../load").LoadPlugin[];
6365
+ readonly plugins?: import("../..").LoadPlugin[];
6366
6366
  readonly filename?: string;
6367
- readonly filesystem?: import("../../../types").Filesystem;
6367
+ readonly filesystem?: import("../../../index.js").Filesystem;
6368
6368
  throwOnError: boolean;
6369
6369
  };
6370
6370
  }, {
@@ -6412,12 +6412,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
6412
6412
  toJson: () => Promise<string>;
6413
6413
  toYaml: () => Promise<string>;
6414
6414
  };
6415
- get: () => Promise<import("../../../types").CommandChain<[...T, {
6415
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
6416
6416
  readonly name: "load";
6417
6417
  readonly options: {
6418
- readonly plugins?: import("../../load").LoadPlugin[];
6418
+ readonly plugins?: import("../..").LoadPlugin[];
6419
6419
  readonly filename?: string;
6420
- readonly filesystem?: import("../../../types").Filesystem;
6420
+ readonly filesystem?: import("../../../index.js").Filesystem;
6421
6421
  throwOnError: boolean;
6422
6422
  };
6423
6423
  }, {
@@ -6463,14 +6463,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
6463
6463
  toYaml: () => Promise<string>;
6464
6464
  upgrade: () => {
6465
6465
  dereference: (dereferenceOptions?: DereferenceOptions) => {
6466
- details: () => Promise<import("../../../types").DetailsResult>;
6467
- files: () => Promise<import("../../../types").Filesystem>;
6468
- get: () => Promise<import("../../../types").CommandChain<[...T, {
6466
+ details: () => Promise<import("../../../index.js").DetailsResult>;
6467
+ files: () => Promise<import("../../../index.js").Filesystem>;
6468
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
6469
6469
  readonly name: "load";
6470
6470
  readonly options: {
6471
- readonly plugins?: import("../../load").LoadPlugin[];
6471
+ readonly plugins?: import("../..").LoadPlugin[];
6472
6472
  readonly filename?: string;
6473
- readonly filesystem?: import("../../../types").Filesystem;
6473
+ readonly filesystem?: import("../../../index.js").Filesystem;
6474
6474
  throwOnError: boolean;
6475
6475
  };
6476
6476
  }, {
@@ -6520,18 +6520,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
6520
6520
  toJson: () => Promise<string>;
6521
6521
  toYaml: () => Promise<string>;
6522
6522
  };
6523
- details: () => Promise<import("../../../types").DetailsResult>;
6524
- files: () => Promise<import("../../../types").Filesystem>;
6523
+ details: () => Promise<import("../../../index.js").DetailsResult>;
6524
+ files: () => Promise<import("../../../index.js").Filesystem>;
6525
6525
  filter: (callback: (specification: AnyObject) => boolean) => {
6526
6526
  dereference: (dereferenceOptions?: DereferenceOptions) => {
6527
- details: () => Promise<import("../../../types").DetailsResult>;
6528
- files: () => Promise<import("../../../types").Filesystem>;
6529
- get: () => Promise<import("../../../types").CommandChain<[...T, {
6527
+ details: () => Promise<import("../../../index.js").DetailsResult>;
6528
+ files: () => Promise<import("../../../index.js").Filesystem>;
6529
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
6530
6530
  readonly name: "load";
6531
6531
  readonly options: {
6532
- readonly plugins?: import("../../load").LoadPlugin[];
6532
+ readonly plugins?: import("../..").LoadPlugin[];
6533
6533
  readonly filename?: string;
6534
- readonly filesystem?: import("../../../types").Filesystem;
6534
+ readonly filesystem?: import("../../../index.js").Filesystem;
6535
6535
  throwOnError: boolean;
6536
6536
  };
6537
6537
  }, {
@@ -6584,14 +6584,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
6584
6584
  toJson: () => Promise<string>;
6585
6585
  toYaml: () => Promise<string>;
6586
6586
  };
6587
- details: () => Promise<import("../../../types").DetailsResult>;
6588
- files: () => Promise<import("../../../types").Filesystem>;
6589
- get: () => Promise<import("../../../types").CommandChain<[...T, {
6587
+ details: () => Promise<import("../../../index.js").DetailsResult>;
6588
+ files: () => Promise<import("../../../index.js").Filesystem>;
6589
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
6590
6590
  readonly name: "load";
6591
6591
  readonly options: {
6592
- readonly plugins?: import("../../load").LoadPlugin[];
6592
+ readonly plugins?: import("../..").LoadPlugin[];
6593
6593
  readonly filename?: string;
6594
- readonly filesystem?: import("../../../types").Filesystem;
6594
+ readonly filesystem?: import("../../../index.js").Filesystem;
6595
6595
  throwOnError: boolean;
6596
6596
  };
6597
6597
  }, {
@@ -6641,12 +6641,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
6641
6641
  toJson: () => Promise<string>;
6642
6642
  toYaml: () => Promise<string>;
6643
6643
  };
6644
- get: () => Promise<import("../../../types").CommandChain<[...T, {
6644
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
6645
6645
  readonly name: "load";
6646
6646
  readonly options: {
6647
- readonly plugins?: import("../../load").LoadPlugin[];
6647
+ readonly plugins?: import("../..").LoadPlugin[];
6648
6648
  readonly filename?: string;
6649
- readonly filesystem?: import("../../../types").Filesystem;
6649
+ readonly filesystem?: import("../../../index.js").Filesystem;
6650
6650
  throwOnError: boolean;
6651
6651
  };
6652
6652
  }, {
@@ -6694,14 +6694,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
6694
6694
  toYaml: () => Promise<string>;
6695
6695
  validate: (validateOptions?: ValidateOptions) => {
6696
6696
  dereference: (dereferenceOptions?: DereferenceOptions) => {
6697
- details: () => Promise<import("../../../types").DetailsResult>;
6698
- files: () => Promise<import("../../../types").Filesystem>;
6699
- get: () => Promise<import("../../../types").CommandChain<[...T, {
6697
+ details: () => Promise<import("../../../index.js").DetailsResult>;
6698
+ files: () => Promise<import("../../../index.js").Filesystem>;
6699
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
6700
6700
  readonly name: "load";
6701
6701
  readonly options: {
6702
- readonly plugins?: import("../../load").LoadPlugin[];
6702
+ readonly plugins?: import("../..").LoadPlugin[];
6703
6703
  readonly filename?: string;
6704
- readonly filesystem?: import("../../../types").Filesystem;
6704
+ readonly filesystem?: import("../../../index.js").Filesystem;
6705
6705
  throwOnError: boolean;
6706
6706
  };
6707
6707
  }, {
@@ -6754,18 +6754,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
6754
6754
  toJson: () => Promise<string>;
6755
6755
  toYaml: () => Promise<string>;
6756
6756
  };
6757
- details: () => Promise<import("../../../types").DetailsResult>;
6758
- files: () => Promise<import("../../../types").Filesystem>;
6757
+ details: () => Promise<import("../../../index.js").DetailsResult>;
6758
+ files: () => Promise<import("../../../index.js").Filesystem>;
6759
6759
  filter: (callback: (specification: AnyObject) => boolean) => {
6760
6760
  dereference: (dereferenceOptions?: DereferenceOptions) => {
6761
- details: () => Promise<import("../../../types").DetailsResult>;
6762
- files: () => Promise<import("../../../types").Filesystem>;
6763
- get: () => Promise<import("../../../types").CommandChain<[...T, {
6761
+ details: () => Promise<import("../../../index.js").DetailsResult>;
6762
+ files: () => Promise<import("../../../index.js").Filesystem>;
6763
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
6764
6764
  readonly name: "load";
6765
6765
  readonly options: {
6766
- readonly plugins?: import("../../load").LoadPlugin[];
6766
+ readonly plugins?: import("../..").LoadPlugin[];
6767
6767
  readonly filename?: string;
6768
- readonly filesystem?: import("../../../types").Filesystem;
6768
+ readonly filesystem?: import("../../../index.js").Filesystem;
6769
6769
  throwOnError: boolean;
6770
6770
  };
6771
6771
  }, {
@@ -6821,14 +6821,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
6821
6821
  toJson: () => Promise<string>;
6822
6822
  toYaml: () => Promise<string>;
6823
6823
  };
6824
- details: () => Promise<import("../../../types").DetailsResult>;
6825
- files: () => Promise<import("../../../types").Filesystem>;
6826
- get: () => Promise<import("../../../types").CommandChain<[...T, {
6824
+ details: () => Promise<import("../../../index.js").DetailsResult>;
6825
+ files: () => Promise<import("../../../index.js").Filesystem>;
6826
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
6827
6827
  readonly name: "load";
6828
6828
  readonly options: {
6829
- readonly plugins?: import("../../load").LoadPlugin[];
6829
+ readonly plugins?: import("../..").LoadPlugin[];
6830
6830
  readonly filename?: string;
6831
- readonly filesystem?: import("../../../types").Filesystem;
6831
+ readonly filesystem?: import("../../../index.js").Filesystem;
6832
6832
  throwOnError: boolean;
6833
6833
  };
6834
6834
  }, {
@@ -6881,12 +6881,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
6881
6881
  toJson: () => Promise<string>;
6882
6882
  toYaml: () => Promise<string>;
6883
6883
  };
6884
- get: () => Promise<import("../../../types").CommandChain<[...T, {
6884
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
6885
6885
  readonly name: "load";
6886
6886
  readonly options: {
6887
- readonly plugins?: import("../../load").LoadPlugin[];
6887
+ readonly plugins?: import("../..").LoadPlugin[];
6888
6888
  readonly filename?: string;
6889
- readonly filesystem?: import("../../../types").Filesystem;
6889
+ readonly filesystem?: import("../../../index.js").Filesystem;
6890
6890
  throwOnError: boolean;
6891
6891
  };
6892
6892
  }, {
@@ -6937,14 +6937,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
6937
6937
  toYaml: () => Promise<string>;
6938
6938
  upgrade: () => {
6939
6939
  dereference: (dereferenceOptions?: DereferenceOptions) => {
6940
- details: () => Promise<import("../../../types").DetailsResult>;
6941
- files: () => Promise<import("../../../types").Filesystem>;
6942
- get: () => Promise<import("../../../types").CommandChain<[...T, {
6940
+ details: () => Promise<import("../../../index.js").DetailsResult>;
6941
+ files: () => Promise<import("../../../index.js").Filesystem>;
6942
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
6943
6943
  readonly name: "load";
6944
6944
  readonly options: {
6945
- readonly plugins?: import("../../load").LoadPlugin[];
6945
+ readonly plugins?: import("../..").LoadPlugin[];
6946
6946
  readonly filename?: string;
6947
- readonly filesystem?: import("../../../types").Filesystem;
6947
+ readonly filesystem?: import("../../../index.js").Filesystem;
6948
6948
  throwOnError: boolean;
6949
6949
  };
6950
6950
  }, {
@@ -6999,18 +6999,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
6999
6999
  toJson: () => Promise<string>;
7000
7000
  toYaml: () => Promise<string>;
7001
7001
  };
7002
- details: () => Promise<import("../../../types").DetailsResult>;
7003
- files: () => Promise<import("../../../types").Filesystem>;
7002
+ details: () => Promise<import("../../../index.js").DetailsResult>;
7003
+ files: () => Promise<import("../../../index.js").Filesystem>;
7004
7004
  filter: (callback: (specification: AnyObject) => boolean) => {
7005
7005
  dereference: (dereferenceOptions?: DereferenceOptions) => {
7006
- details: () => Promise<import("../../../types").DetailsResult>;
7007
- files: () => Promise<import("../../../types").Filesystem>;
7008
- get: () => Promise<import("../../../types").CommandChain<[...T, {
7006
+ details: () => Promise<import("../../../index.js").DetailsResult>;
7007
+ files: () => Promise<import("../../../index.js").Filesystem>;
7008
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
7009
7009
  readonly name: "load";
7010
7010
  readonly options: {
7011
- readonly plugins?: import("../../load").LoadPlugin[];
7011
+ readonly plugins?: import("../..").LoadPlugin[];
7012
7012
  readonly filename?: string;
7013
- readonly filesystem?: import("../../../types").Filesystem;
7013
+ readonly filesystem?: import("../../../index.js").Filesystem;
7014
7014
  throwOnError: boolean;
7015
7015
  };
7016
7016
  }, {
@@ -7068,14 +7068,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
7068
7068
  toJson: () => Promise<string>;
7069
7069
  toYaml: () => Promise<string>;
7070
7070
  };
7071
- details: () => Promise<import("../../../types").DetailsResult>;
7072
- files: () => Promise<import("../../../types").Filesystem>;
7073
- get: () => Promise<import("../../../types").CommandChain<[...T, {
7071
+ details: () => Promise<import("../../../index.js").DetailsResult>;
7072
+ files: () => Promise<import("../../../index.js").Filesystem>;
7073
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
7074
7074
  readonly name: "load";
7075
7075
  readonly options: {
7076
- readonly plugins?: import("../../load").LoadPlugin[];
7076
+ readonly plugins?: import("../..").LoadPlugin[];
7077
7077
  readonly filename?: string;
7078
- readonly filesystem?: import("../../../types").Filesystem;
7078
+ readonly filesystem?: import("../../../index.js").Filesystem;
7079
7079
  throwOnError: boolean;
7080
7080
  };
7081
7081
  }, {
@@ -7130,12 +7130,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
7130
7130
  toJson: () => Promise<string>;
7131
7131
  toYaml: () => Promise<string>;
7132
7132
  };
7133
- get: () => Promise<import("../../../types").CommandChain<[...T, {
7133
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
7134
7134
  readonly name: "load";
7135
7135
  readonly options: {
7136
- readonly plugins?: import("../../load").LoadPlugin[];
7136
+ readonly plugins?: import("../..").LoadPlugin[];
7137
7137
  readonly filename?: string;
7138
- readonly filesystem?: import("../../../types").Filesystem;
7138
+ readonly filesystem?: import("../../../index.js").Filesystem;
7139
7139
  throwOnError: boolean;
7140
7140
  };
7141
7141
  }, {
@@ -7188,14 +7188,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
7188
7188
  toYaml: () => Promise<string>;
7189
7189
  validate: (validateOptions?: ValidateOptions) => {
7190
7190
  dereference: (dereferenceOptions?: DereferenceOptions) => {
7191
- details: () => Promise<import("../../../types").DetailsResult>;
7192
- files: () => Promise<import("../../../types").Filesystem>;
7193
- get: () => Promise<import("../../../types").CommandChain<[...T, {
7191
+ details: () => Promise<import("../../../index.js").DetailsResult>;
7192
+ files: () => Promise<import("../../../index.js").Filesystem>;
7193
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
7194
7194
  readonly name: "load";
7195
7195
  readonly options: {
7196
- readonly plugins?: import("../../load").LoadPlugin[];
7196
+ readonly plugins?: import("../..").LoadPlugin[];
7197
7197
  readonly filename?: string;
7198
- readonly filesystem?: import("../../../types").Filesystem;
7198
+ readonly filesystem?: import("../../../index.js").Filesystem;
7199
7199
  throwOnError: boolean;
7200
7200
  };
7201
7201
  }, {
@@ -7253,18 +7253,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
7253
7253
  toJson: () => Promise<string>;
7254
7254
  toYaml: () => Promise<string>;
7255
7255
  };
7256
- details: () => Promise<import("../../../types").DetailsResult>;
7257
- files: () => Promise<import("../../../types").Filesystem>;
7256
+ details: () => Promise<import("../../../index.js").DetailsResult>;
7257
+ files: () => Promise<import("../../../index.js").Filesystem>;
7258
7258
  filter: (callback: (specification: AnyObject) => boolean) => {
7259
7259
  dereference: (dereferenceOptions?: DereferenceOptions) => {
7260
- details: () => Promise<import("../../../types").DetailsResult>;
7261
- files: () => Promise<import("../../../types").Filesystem>;
7262
- get: () => Promise<import("../../../types").CommandChain<[...T, {
7260
+ details: () => Promise<import("../../../index.js").DetailsResult>;
7261
+ files: () => Promise<import("../../../index.js").Filesystem>;
7262
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
7263
7263
  readonly name: "load";
7264
7264
  readonly options: {
7265
- readonly plugins?: import("../../load").LoadPlugin[];
7265
+ readonly plugins?: import("../..").LoadPlugin[];
7266
7266
  readonly filename?: string;
7267
- readonly filesystem?: import("../../../types").Filesystem;
7267
+ readonly filesystem?: import("../../../index.js").Filesystem;
7268
7268
  throwOnError: boolean;
7269
7269
  };
7270
7270
  }, {
@@ -7325,14 +7325,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
7325
7325
  toJson: () => Promise<string>;
7326
7326
  toYaml: () => Promise<string>;
7327
7327
  };
7328
- details: () => Promise<import("../../../types").DetailsResult>;
7329
- files: () => Promise<import("../../../types").Filesystem>;
7330
- get: () => Promise<import("../../../types").CommandChain<[...T, {
7328
+ details: () => Promise<import("../../../index.js").DetailsResult>;
7329
+ files: () => Promise<import("../../../index.js").Filesystem>;
7330
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
7331
7331
  readonly name: "load";
7332
7332
  readonly options: {
7333
- readonly plugins?: import("../../load").LoadPlugin[];
7333
+ readonly plugins?: import("../..").LoadPlugin[];
7334
7334
  readonly filename?: string;
7335
- readonly filesystem?: import("../../../types").Filesystem;
7335
+ readonly filesystem?: import("../../../index.js").Filesystem;
7336
7336
  throwOnError: boolean;
7337
7337
  };
7338
7338
  }, {
@@ -7390,12 +7390,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
7390
7390
  toJson: () => Promise<string>;
7391
7391
  toYaml: () => Promise<string>;
7392
7392
  };
7393
- get: () => Promise<import("../../../types").CommandChain<[...T, {
7393
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
7394
7394
  readonly name: "load";
7395
7395
  readonly options: {
7396
- readonly plugins?: import("../../load").LoadPlugin[];
7396
+ readonly plugins?: import("../..").LoadPlugin[];
7397
7397
  readonly filename?: string;
7398
- readonly filesystem?: import("../../../types").Filesystem;
7398
+ readonly filesystem?: import("../../../index.js").Filesystem;
7399
7399
  throwOnError: boolean;
7400
7400
  };
7401
7401
  }, {
@@ -7451,14 +7451,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
7451
7451
  toYaml: () => Promise<string>;
7452
7452
  upgrade: () => {
7453
7453
  dereference: (dereferenceOptions?: DereferenceOptions) => {
7454
- details: () => Promise<import("../../../types").DetailsResult>;
7455
- files: () => Promise<import("../../../types").Filesystem>;
7456
- get: () => Promise<import("../../../types").CommandChain<[...T, {
7454
+ details: () => Promise<import("../../../index.js").DetailsResult>;
7455
+ files: () => Promise<import("../../../index.js").Filesystem>;
7456
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
7457
7457
  readonly name: "load";
7458
7458
  readonly options: {
7459
- readonly plugins?: import("../../load").LoadPlugin[];
7459
+ readonly plugins?: import("../..").LoadPlugin[];
7460
7460
  readonly filename?: string;
7461
- readonly filesystem?: import("../../../types").Filesystem;
7461
+ readonly filesystem?: import("../../../index.js").Filesystem;
7462
7462
  throwOnError: boolean;
7463
7463
  };
7464
7464
  }, {
@@ -7518,18 +7518,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
7518
7518
  toJson: () => Promise<string>;
7519
7519
  toYaml: () => Promise<string>;
7520
7520
  };
7521
- details: () => Promise<import("../../../types").DetailsResult>;
7522
- files: () => Promise<import("../../../types").Filesystem>;
7521
+ details: () => Promise<import("../../../index.js").DetailsResult>;
7522
+ files: () => Promise<import("../../../index.js").Filesystem>;
7523
7523
  filter: (callback: (specification: AnyObject) => boolean) => {
7524
7524
  dereference: (dereferenceOptions?: DereferenceOptions) => {
7525
- details: () => Promise<import("../../../types").DetailsResult>;
7526
- files: () => Promise<import("../../../types").Filesystem>;
7527
- get: () => Promise<import("../../../types").CommandChain<[...T, {
7525
+ details: () => Promise<import("../../../index.js").DetailsResult>;
7526
+ files: () => Promise<import("../../../index.js").Filesystem>;
7527
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
7528
7528
  readonly name: "load";
7529
7529
  readonly options: {
7530
- readonly plugins?: import("../../load").LoadPlugin[];
7530
+ readonly plugins?: import("../..").LoadPlugin[];
7531
7531
  readonly filename?: string;
7532
- readonly filesystem?: import("../../../types").Filesystem;
7532
+ readonly filesystem?: import("../../../index.js").Filesystem;
7533
7533
  throwOnError: boolean;
7534
7534
  };
7535
7535
  }, {
@@ -7592,14 +7592,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
7592
7592
  toJson: () => Promise<string>;
7593
7593
  toYaml: () => Promise<string>;
7594
7594
  };
7595
- details: () => Promise<import("../../../types").DetailsResult>;
7596
- files: () => Promise<import("../../../types").Filesystem>;
7597
- get: () => Promise<import("../../../types").CommandChain<[...T, {
7595
+ details: () => Promise<import("../../../index.js").DetailsResult>;
7596
+ files: () => Promise<import("../../../index.js").Filesystem>;
7597
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
7598
7598
  readonly name: "load";
7599
7599
  readonly options: {
7600
- readonly plugins?: import("../../load").LoadPlugin[];
7600
+ readonly plugins?: import("../..").LoadPlugin[];
7601
7601
  readonly filename?: string;
7602
- readonly filesystem?: import("../../../types").Filesystem;
7602
+ readonly filesystem?: import("../../../index.js").Filesystem;
7603
7603
  throwOnError: boolean;
7604
7604
  };
7605
7605
  }, {
@@ -7659,12 +7659,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
7659
7659
  toJson: () => Promise<string>;
7660
7660
  toYaml: () => Promise<string>;
7661
7661
  };
7662
- get: () => Promise<import("../../../types").CommandChain<[...T, {
7662
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
7663
7663
  readonly name: "load";
7664
7664
  readonly options: {
7665
- readonly plugins?: import("../../load").LoadPlugin[];
7665
+ readonly plugins?: import("../..").LoadPlugin[];
7666
7666
  readonly filename?: string;
7667
- readonly filesystem?: import("../../../types").Filesystem;
7667
+ readonly filesystem?: import("../../../index.js").Filesystem;
7668
7668
  throwOnError: boolean;
7669
7669
  };
7670
7670
  }, {
@@ -7722,14 +7722,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
7722
7722
  toYaml: () => Promise<string>;
7723
7723
  validate: (validateOptions?: ValidateOptions) => {
7724
7724
  dereference: (dereferenceOptions?: DereferenceOptions) => {
7725
- details: () => Promise<import("../../../types").DetailsResult>;
7726
- files: () => Promise<import("../../../types").Filesystem>;
7727
- get: () => Promise<import("../../../types").CommandChain<[...T, {
7725
+ details: () => Promise<import("../../../index.js").DetailsResult>;
7726
+ files: () => Promise<import("../../../index.js").Filesystem>;
7727
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
7728
7728
  readonly name: "load";
7729
7729
  readonly options: {
7730
- readonly plugins?: import("../../load").LoadPlugin[];
7730
+ readonly plugins?: import("../..").LoadPlugin[];
7731
7731
  readonly filename?: string;
7732
- readonly filesystem?: import("../../../types").Filesystem;
7732
+ readonly filesystem?: import("../../../index.js").Filesystem;
7733
7733
  throwOnError: boolean;
7734
7734
  };
7735
7735
  }, {
@@ -7792,18 +7792,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
7792
7792
  toJson: () => Promise<string>;
7793
7793
  toYaml: () => Promise<string>;
7794
7794
  };
7795
- details: () => Promise<import("../../../types").DetailsResult>;
7796
- files: () => Promise<import("../../../types").Filesystem>;
7795
+ details: () => Promise<import("../../../index.js").DetailsResult>;
7796
+ files: () => Promise<import("../../../index.js").Filesystem>;
7797
7797
  filter: (callback: (specification: AnyObject) => boolean) => {
7798
7798
  dereference: (dereferenceOptions?: DereferenceOptions) => {
7799
- details: () => Promise<import("../../../types").DetailsResult>;
7800
- files: () => Promise<import("../../../types").Filesystem>;
7801
- get: () => Promise<import("../../../types").CommandChain<[...T, {
7799
+ details: () => Promise<import("../../../index.js").DetailsResult>;
7800
+ files: () => Promise<import("../../../index.js").Filesystem>;
7801
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
7802
7802
  readonly name: "load";
7803
7803
  readonly options: {
7804
- readonly plugins?: import("../../load").LoadPlugin[];
7804
+ readonly plugins?: import("../..").LoadPlugin[];
7805
7805
  readonly filename?: string;
7806
- readonly filesystem?: import("../../../types").Filesystem;
7806
+ readonly filesystem?: import("../../../index.js").Filesystem;
7807
7807
  throwOnError: boolean;
7808
7808
  };
7809
7809
  }, {
@@ -7869,14 +7869,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
7869
7869
  toJson: () => Promise<string>;
7870
7870
  toYaml: () => Promise<string>;
7871
7871
  };
7872
- details: () => Promise<import("../../../types").DetailsResult>;
7873
- files: () => Promise<import("../../../types").Filesystem>;
7874
- get: () => Promise<import("../../../types").CommandChain<[...T, {
7872
+ details: () => Promise<import("../../../index.js").DetailsResult>;
7873
+ files: () => Promise<import("../../../index.js").Filesystem>;
7874
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
7875
7875
  readonly name: "load";
7876
7876
  readonly options: {
7877
- readonly plugins?: import("../../load").LoadPlugin[];
7877
+ readonly plugins?: import("../..").LoadPlugin[];
7878
7878
  readonly filename?: string;
7879
- readonly filesystem?: import("../../../types").Filesystem;
7879
+ readonly filesystem?: import("../../../index.js").Filesystem;
7880
7880
  throwOnError: boolean;
7881
7881
  };
7882
7882
  }, {
@@ -7939,12 +7939,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
7939
7939
  toJson: () => Promise<string>;
7940
7940
  toYaml: () => Promise<string>;
7941
7941
  };
7942
- get: () => Promise<import("../../../types").CommandChain<[...T, {
7942
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
7943
7943
  readonly name: "load";
7944
7944
  readonly options: {
7945
- readonly plugins?: import("../../load").LoadPlugin[];
7945
+ readonly plugins?: import("../..").LoadPlugin[];
7946
7946
  readonly filename?: string;
7947
- readonly filesystem?: import("../../../types").Filesystem;
7947
+ readonly filesystem?: import("../../../index.js").Filesystem;
7948
7948
  throwOnError: boolean;
7949
7949
  };
7950
7950
  }, {
@@ -8005,14 +8005,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
8005
8005
  toYaml: () => Promise<string>;
8006
8006
  upgrade: () => {
8007
8007
  dereference: (dereferenceOptions?: DereferenceOptions) => {
8008
- details: () => Promise<import("../../../types").DetailsResult>;
8009
- files: () => Promise<import("../../../types").Filesystem>;
8010
- get: () => Promise<import("../../../types").CommandChain<[...T, {
8008
+ details: () => Promise<import("../../../index.js").DetailsResult>;
8009
+ files: () => Promise<import("../../../index.js").Filesystem>;
8010
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
8011
8011
  readonly name: "load";
8012
8012
  readonly options: {
8013
- readonly plugins?: import("../../load").LoadPlugin[];
8013
+ readonly plugins?: import("../..").LoadPlugin[];
8014
8014
  readonly filename?: string;
8015
- readonly filesystem?: import("../../../types").Filesystem;
8015
+ readonly filesystem?: import("../../../index.js").Filesystem;
8016
8016
  throwOnError: boolean;
8017
8017
  };
8018
8018
  }, {
@@ -8077,18 +8077,18 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
8077
8077
  toJson: () => Promise<string>;
8078
8078
  toYaml: () => Promise<string>;
8079
8079
  };
8080
- details: () => Promise<import("../../../types").DetailsResult>;
8081
- files: () => Promise<import("../../../types").Filesystem>;
8080
+ details: () => Promise<import("../../../index.js").DetailsResult>;
8081
+ files: () => Promise<import("../../../index.js").Filesystem>;
8082
8082
  filter: (callback: (specification: AnyObject) => boolean) => {
8083
8083
  dereference: (dereferenceOptions?: DereferenceOptions) => {
8084
- details: () => Promise<import("../../../types").DetailsResult>;
8085
- files: () => Promise<import("../../../types").Filesystem>;
8086
- get: () => Promise<import("../../../types").CommandChain<[...T, {
8084
+ details: () => Promise<import("../../../index.js").DetailsResult>;
8085
+ files: () => Promise<import("../../../index.js").Filesystem>;
8086
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
8087
8087
  readonly name: "load";
8088
8088
  readonly options: {
8089
- readonly plugins?: import("../../load").LoadPlugin[];
8089
+ readonly plugins?: import("../..").LoadPlugin[];
8090
8090
  readonly filename?: string;
8091
- readonly filesystem?: import("../../../types").Filesystem;
8091
+ readonly filesystem?: import("../../../index.js").Filesystem;
8092
8092
  throwOnError: boolean;
8093
8093
  };
8094
8094
  }, {
@@ -8156,14 +8156,14 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
8156
8156
  toJson: () => Promise<string>;
8157
8157
  toYaml: () => Promise<string>;
8158
8158
  };
8159
- details: () => Promise<import("../../../types").DetailsResult>;
8160
- files: () => Promise<import("../../../types").Filesystem>;
8161
- get: () => Promise<import("../../../types").CommandChain<[...T, {
8159
+ details: () => Promise<import("../../../index.js").DetailsResult>;
8160
+ files: () => Promise<import("../../../index.js").Filesystem>;
8161
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
8162
8162
  readonly name: "load";
8163
8163
  readonly options: {
8164
- readonly plugins?: import("../../load").LoadPlugin[];
8164
+ readonly plugins?: import("../..").LoadPlugin[];
8165
8165
  readonly filename?: string;
8166
- readonly filesystem?: import("../../../types").Filesystem;
8166
+ readonly filesystem?: import("../../../index.js").Filesystem;
8167
8167
  throwOnError: boolean;
8168
8168
  };
8169
8169
  }, {
@@ -8228,12 +8228,12 @@ export declare function loadCommand<T extends Task[]>(previousQueue: Queue<T>, i
8228
8228
  toJson: () => Promise<string>;
8229
8229
  toYaml: () => Promise<string>;
8230
8230
  };
8231
- get: () => Promise<import("../../../types").CommandChain<[...T, {
8231
+ get: () => Promise<import("../../../index.js").CommandChain<[...T, {
8232
8232
  readonly name: "load";
8233
8233
  readonly options: {
8234
- readonly plugins?: import("../../load").LoadPlugin[];
8234
+ readonly plugins?: import("../..").LoadPlugin[];
8235
8235
  readonly filename?: string;
8236
- readonly filesystem?: import("../../../types").Filesystem;
8236
+ readonly filesystem?: import("../../../index.js").Filesystem;
8237
8237
  throwOnError: boolean;
8238
8238
  };
8239
8239
  }, {