depflow 3.0.0-dev.5 → 3.0.0-dev.6

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