@vercel/routing-utils 5.0.6 → 5.0.8

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 (4) hide show
  1. package/dist/schemas.d.ts +1406 -1326
  2. package/dist/schemas.js +191 -1
  3. package/dist/types.d.ts +20 -0
  4. package/package.json +1 -1
package/dist/schemas.d.ts CHANGED
@@ -14,85 +14,80 @@ export declare const hasSchema: {
14
14
  readonly enum: readonly ["host"];
15
15
  };
16
16
  readonly value: {
17
- description: string;
18
- anyOf: ({
19
- description: string;
20
- type: string;
21
- maxLength: number;
22
- additionalProperties?: undefined;
23
- minProperties?: undefined;
24
- properties?: undefined;
25
- } | {
26
- description: string;
27
- type: string;
28
- additionalProperties: boolean;
29
- minProperties: number;
30
- properties: {
31
- eq: {
32
- description: string;
33
- anyOf: ({
34
- type: string;
35
- maxLength: number;
36
- } | {
37
- type: string;
38
- maxLength?: undefined;
39
- })[];
40
- };
41
- neq: {
42
- description: string;
43
- type: string;
44
- maxLength: number;
45
- };
46
- inc: {
47
- description: string;
48
- type: string;
49
- items: {
50
- type: string;
51
- maxLength: number;
17
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
18
+ readonly anyOf: readonly [{
19
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
20
+ readonly type: "string";
21
+ readonly maxLength: 4096;
22
+ }, {
23
+ readonly description: "A condition operation object";
24
+ readonly type: "object";
25
+ readonly additionalProperties: false;
26
+ readonly minProperties: 1;
27
+ readonly properties: {
28
+ readonly eq: {
29
+ readonly description: "Equal to";
30
+ readonly anyOf: readonly [{
31
+ readonly type: "string";
32
+ readonly maxLength: 4096;
33
+ }, {
34
+ readonly type: "number";
35
+ }];
36
+ };
37
+ readonly neq: {
38
+ readonly description: "Not equal";
39
+ readonly type: "string";
40
+ readonly maxLength: 4096;
41
+ };
42
+ readonly inc: {
43
+ readonly description: "In array";
44
+ readonly type: "array";
45
+ readonly items: {
46
+ readonly type: "string";
47
+ readonly maxLength: 4096;
52
48
  };
53
49
  };
54
- ninc: {
55
- description: string;
56
- type: string;
57
- items: {
58
- type: string;
59
- maxLength: number;
50
+ readonly ninc: {
51
+ readonly description: "Not in array";
52
+ readonly type: "array";
53
+ readonly items: {
54
+ readonly type: "string";
55
+ readonly maxLength: 4096;
60
56
  };
61
57
  };
62
- pre: {
63
- description: string;
64
- type: string;
65
- maxLength: number;
58
+ readonly pre: {
59
+ readonly description: "Starts with";
60
+ readonly type: "string";
61
+ readonly maxLength: 4096;
66
62
  };
67
- suf: {
68
- description: string;
69
- type: string;
70
- maxLength: number;
63
+ readonly suf: {
64
+ readonly description: "Ends with";
65
+ readonly type: "string";
66
+ readonly maxLength: 4096;
71
67
  };
72
- re: {
73
- description: string;
74
- type: string;
75
- maxLength: number;
68
+ readonly re: {
69
+ readonly description: "Regex";
70
+ readonly type: "string";
71
+ readonly maxLength: 4096;
76
72
  };
77
- gt: {
78
- description: string;
79
- type: string;
73
+ readonly gt: {
74
+ readonly description: "Greater than";
75
+ readonly type: "number";
80
76
  };
81
- gte: {
82
- description: string;
83
- type: string;
77
+ readonly gte: {
78
+ readonly description: "Greater than or equal to";
79
+ readonly type: "number";
84
80
  };
85
- lt: {
86
- description: string;
87
- type: string;
81
+ readonly lt: {
82
+ readonly description: "Less than";
83
+ readonly type: "number";
88
84
  };
89
- lte: {
90
- description: string;
91
- type: string;
85
+ readonly lte: {
86
+ readonly description: "Less than or equal to";
87
+ readonly type: "number";
92
88
  };
93
89
  };
94
- maxLength?: undefined;
95
- })[];
90
+ }];
96
91
  };
97
92
  };
98
93
  }, {
@@ -111,85 +106,80 @@ export declare const hasSchema: {
111
106
  readonly maxLength: 4096;
112
107
  };
113
108
  readonly value: {
114
- description: string;
115
- anyOf: ({
116
- description: string;
117
- type: string;
118
- maxLength: number;
119
- additionalProperties?: undefined;
120
- minProperties?: undefined;
121
- properties?: undefined;
122
- } | {
123
- description: string;
124
- type: string;
125
- additionalProperties: boolean;
126
- minProperties: number;
127
- properties: {
128
- eq: {
129
- description: string;
130
- anyOf: ({
131
- type: string;
132
- maxLength: number;
133
- } | {
134
- type: string;
135
- maxLength?: undefined;
136
- })[];
137
- };
138
- neq: {
139
- description: string;
140
- type: string;
141
- maxLength: number;
142
- };
143
- inc: {
144
- description: string;
145
- type: string;
146
- items: {
147
- type: string;
148
- maxLength: number;
109
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
110
+ readonly anyOf: readonly [{
111
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
112
+ readonly type: "string";
113
+ readonly maxLength: 4096;
114
+ }, {
115
+ readonly description: "A condition operation object";
116
+ readonly type: "object";
117
+ readonly additionalProperties: false;
118
+ readonly minProperties: 1;
119
+ readonly properties: {
120
+ readonly eq: {
121
+ readonly description: "Equal to";
122
+ readonly anyOf: readonly [{
123
+ readonly type: "string";
124
+ readonly maxLength: 4096;
125
+ }, {
126
+ readonly type: "number";
127
+ }];
128
+ };
129
+ readonly neq: {
130
+ readonly description: "Not equal";
131
+ readonly type: "string";
132
+ readonly maxLength: 4096;
133
+ };
134
+ readonly inc: {
135
+ readonly description: "In array";
136
+ readonly type: "array";
137
+ readonly items: {
138
+ readonly type: "string";
139
+ readonly maxLength: 4096;
149
140
  };
150
141
  };
151
- ninc: {
152
- description: string;
153
- type: string;
154
- items: {
155
- type: string;
156
- maxLength: number;
142
+ readonly ninc: {
143
+ readonly description: "Not in array";
144
+ readonly type: "array";
145
+ readonly items: {
146
+ readonly type: "string";
147
+ readonly maxLength: 4096;
157
148
  };
158
149
  };
159
- pre: {
160
- description: string;
161
- type: string;
162
- maxLength: number;
150
+ readonly pre: {
151
+ readonly description: "Starts with";
152
+ readonly type: "string";
153
+ readonly maxLength: 4096;
163
154
  };
164
- suf: {
165
- description: string;
166
- type: string;
167
- maxLength: number;
155
+ readonly suf: {
156
+ readonly description: "Ends with";
157
+ readonly type: "string";
158
+ readonly maxLength: 4096;
168
159
  };
169
- re: {
170
- description: string;
171
- type: string;
172
- maxLength: number;
160
+ readonly re: {
161
+ readonly description: "Regex";
162
+ readonly type: "string";
163
+ readonly maxLength: 4096;
173
164
  };
174
- gt: {
175
- description: string;
176
- type: string;
165
+ readonly gt: {
166
+ readonly description: "Greater than";
167
+ readonly type: "number";
177
168
  };
178
- gte: {
179
- description: string;
180
- type: string;
169
+ readonly gte: {
170
+ readonly description: "Greater than or equal to";
171
+ readonly type: "number";
181
172
  };
182
- lt: {
183
- description: string;
184
- type: string;
173
+ readonly lt: {
174
+ readonly description: "Less than";
175
+ readonly type: "number";
185
176
  };
186
- lte: {
187
- description: string;
188
- type: string;
177
+ readonly lte: {
178
+ readonly description: "Less than or equal to";
179
+ readonly type: "number";
189
180
  };
190
181
  };
191
- maxLength?: undefined;
192
- })[];
182
+ }];
193
183
  };
194
184
  };
195
185
  }];
@@ -330,85 +320,80 @@ export declare const routesSchema: {
330
320
  readonly enum: readonly ["host"];
331
321
  };
332
322
  readonly value: {
333
- description: string;
334
- anyOf: ({
335
- description: string;
336
- type: string;
337
- maxLength: number;
338
- additionalProperties?: undefined;
339
- minProperties?: undefined;
340
- properties?: undefined;
341
- } | {
342
- description: string;
343
- type: string;
344
- additionalProperties: boolean;
345
- minProperties: number;
346
- properties: {
347
- eq: {
348
- description: string;
349
- anyOf: ({
350
- type: string;
351
- maxLength: number;
352
- } | {
353
- type: string;
354
- maxLength?: undefined;
355
- })[];
356
- };
357
- neq: {
358
- description: string;
359
- type: string;
360
- maxLength: number;
361
- };
362
- inc: {
363
- description: string;
364
- type: string;
365
- items: {
366
- type: string;
367
- maxLength: number;
323
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
324
+ readonly anyOf: readonly [{
325
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
326
+ readonly type: "string";
327
+ readonly maxLength: 4096;
328
+ }, {
329
+ readonly description: "A condition operation object";
330
+ readonly type: "object";
331
+ readonly additionalProperties: false;
332
+ readonly minProperties: 1;
333
+ readonly properties: {
334
+ readonly eq: {
335
+ readonly description: "Equal to";
336
+ readonly anyOf: readonly [{
337
+ readonly type: "string";
338
+ readonly maxLength: 4096;
339
+ }, {
340
+ readonly type: "number";
341
+ }];
342
+ };
343
+ readonly neq: {
344
+ readonly description: "Not equal";
345
+ readonly type: "string";
346
+ readonly maxLength: 4096;
347
+ };
348
+ readonly inc: {
349
+ readonly description: "In array";
350
+ readonly type: "array";
351
+ readonly items: {
352
+ readonly type: "string";
353
+ readonly maxLength: 4096;
368
354
  };
369
355
  };
370
- ninc: {
371
- description: string;
372
- type: string;
373
- items: {
374
- type: string;
375
- maxLength: number;
356
+ readonly ninc: {
357
+ readonly description: "Not in array";
358
+ readonly type: "array";
359
+ readonly items: {
360
+ readonly type: "string";
361
+ readonly maxLength: 4096;
376
362
  };
377
363
  };
378
- pre: {
379
- description: string;
380
- type: string;
381
- maxLength: number;
364
+ readonly pre: {
365
+ readonly description: "Starts with";
366
+ readonly type: "string";
367
+ readonly maxLength: 4096;
382
368
  };
383
- suf: {
384
- description: string;
385
- type: string;
386
- maxLength: number;
369
+ readonly suf: {
370
+ readonly description: "Ends with";
371
+ readonly type: "string";
372
+ readonly maxLength: 4096;
387
373
  };
388
- re: {
389
- description: string;
390
- type: string;
391
- maxLength: number;
374
+ readonly re: {
375
+ readonly description: "Regex";
376
+ readonly type: "string";
377
+ readonly maxLength: 4096;
392
378
  };
393
- gt: {
394
- description: string;
395
- type: string;
379
+ readonly gt: {
380
+ readonly description: "Greater than";
381
+ readonly type: "number";
396
382
  };
397
- gte: {
398
- description: string;
399
- type: string;
383
+ readonly gte: {
384
+ readonly description: "Greater than or equal to";
385
+ readonly type: "number";
400
386
  };
401
- lt: {
402
- description: string;
403
- type: string;
387
+ readonly lt: {
388
+ readonly description: "Less than";
389
+ readonly type: "number";
404
390
  };
405
- lte: {
406
- description: string;
407
- type: string;
391
+ readonly lte: {
392
+ readonly description: "Less than or equal to";
393
+ readonly type: "number";
408
394
  };
409
395
  };
410
- maxLength?: undefined;
411
- })[];
396
+ }];
412
397
  };
413
398
  };
414
399
  }, {
@@ -427,85 +412,80 @@ export declare const routesSchema: {
427
412
  readonly maxLength: 4096;
428
413
  };
429
414
  readonly value: {
430
- description: string;
431
- anyOf: ({
432
- description: string;
433
- type: string;
434
- maxLength: number;
435
- additionalProperties?: undefined;
436
- minProperties?: undefined;
437
- properties?: undefined;
438
- } | {
439
- description: string;
440
- type: string;
441
- additionalProperties: boolean;
442
- minProperties: number;
443
- properties: {
444
- eq: {
445
- description: string;
446
- anyOf: ({
447
- type: string;
448
- maxLength: number;
449
- } | {
450
- type: string;
451
- maxLength?: undefined;
452
- })[];
453
- };
454
- neq: {
455
- description: string;
456
- type: string;
457
- maxLength: number;
458
- };
459
- inc: {
460
- description: string;
461
- type: string;
462
- items: {
463
- type: string;
464
- maxLength: number;
415
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
416
+ readonly anyOf: readonly [{
417
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
418
+ readonly type: "string";
419
+ readonly maxLength: 4096;
420
+ }, {
421
+ readonly description: "A condition operation object";
422
+ readonly type: "object";
423
+ readonly additionalProperties: false;
424
+ readonly minProperties: 1;
425
+ readonly properties: {
426
+ readonly eq: {
427
+ readonly description: "Equal to";
428
+ readonly anyOf: readonly [{
429
+ readonly type: "string";
430
+ readonly maxLength: 4096;
431
+ }, {
432
+ readonly type: "number";
433
+ }];
434
+ };
435
+ readonly neq: {
436
+ readonly description: "Not equal";
437
+ readonly type: "string";
438
+ readonly maxLength: 4096;
439
+ };
440
+ readonly inc: {
441
+ readonly description: "In array";
442
+ readonly type: "array";
443
+ readonly items: {
444
+ readonly type: "string";
445
+ readonly maxLength: 4096;
465
446
  };
466
447
  };
467
- ninc: {
468
- description: string;
469
- type: string;
470
- items: {
471
- type: string;
472
- maxLength: number;
448
+ readonly ninc: {
449
+ readonly description: "Not in array";
450
+ readonly type: "array";
451
+ readonly items: {
452
+ readonly type: "string";
453
+ readonly maxLength: 4096;
473
454
  };
474
455
  };
475
- pre: {
476
- description: string;
477
- type: string;
478
- maxLength: number;
456
+ readonly pre: {
457
+ readonly description: "Starts with";
458
+ readonly type: "string";
459
+ readonly maxLength: 4096;
479
460
  };
480
- suf: {
481
- description: string;
482
- type: string;
483
- maxLength: number;
461
+ readonly suf: {
462
+ readonly description: "Ends with";
463
+ readonly type: "string";
464
+ readonly maxLength: 4096;
484
465
  };
485
- re: {
486
- description: string;
487
- type: string;
488
- maxLength: number;
466
+ readonly re: {
467
+ readonly description: "Regex";
468
+ readonly type: "string";
469
+ readonly maxLength: 4096;
489
470
  };
490
- gt: {
491
- description: string;
492
- type: string;
471
+ readonly gt: {
472
+ readonly description: "Greater than";
473
+ readonly type: "number";
493
474
  };
494
- gte: {
495
- description: string;
496
- type: string;
475
+ readonly gte: {
476
+ readonly description: "Greater than or equal to";
477
+ readonly type: "number";
497
478
  };
498
- lt: {
499
- description: string;
500
- type: string;
479
+ readonly lt: {
480
+ readonly description: "Less than";
481
+ readonly type: "number";
501
482
  };
502
- lte: {
503
- description: string;
504
- type: string;
483
+ readonly lte: {
484
+ readonly description: "Less than or equal to";
485
+ readonly type: "number";
505
486
  };
506
487
  };
507
- maxLength?: undefined;
508
- })[];
488
+ }];
509
489
  };
510
490
  };
511
491
  }];
@@ -527,85 +507,80 @@ export declare const routesSchema: {
527
507
  readonly enum: readonly ["host"];
528
508
  };
529
509
  readonly value: {
530
- description: string;
531
- anyOf: ({
532
- description: string;
533
- type: string;
534
- maxLength: number;
535
- additionalProperties?: undefined;
536
- minProperties?: undefined;
537
- properties?: undefined;
538
- } | {
539
- description: string;
540
- type: string;
541
- additionalProperties: boolean;
542
- minProperties: number;
543
- properties: {
544
- eq: {
545
- description: string;
546
- anyOf: ({
547
- type: string;
548
- maxLength: number;
549
- } | {
550
- type: string;
551
- maxLength?: undefined;
552
- })[];
553
- };
554
- neq: {
555
- description: string;
556
- type: string;
557
- maxLength: number;
558
- };
559
- inc: {
560
- description: string;
561
- type: string;
562
- items: {
563
- type: string;
564
- maxLength: number;
510
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
511
+ readonly anyOf: readonly [{
512
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
513
+ readonly type: "string";
514
+ readonly maxLength: 4096;
515
+ }, {
516
+ readonly description: "A condition operation object";
517
+ readonly type: "object";
518
+ readonly additionalProperties: false;
519
+ readonly minProperties: 1;
520
+ readonly properties: {
521
+ readonly eq: {
522
+ readonly description: "Equal to";
523
+ readonly anyOf: readonly [{
524
+ readonly type: "string";
525
+ readonly maxLength: 4096;
526
+ }, {
527
+ readonly type: "number";
528
+ }];
529
+ };
530
+ readonly neq: {
531
+ readonly description: "Not equal";
532
+ readonly type: "string";
533
+ readonly maxLength: 4096;
534
+ };
535
+ readonly inc: {
536
+ readonly description: "In array";
537
+ readonly type: "array";
538
+ readonly items: {
539
+ readonly type: "string";
540
+ readonly maxLength: 4096;
565
541
  };
566
542
  };
567
- ninc: {
568
- description: string;
569
- type: string;
570
- items: {
571
- type: string;
572
- maxLength: number;
543
+ readonly ninc: {
544
+ readonly description: "Not in array";
545
+ readonly type: "array";
546
+ readonly items: {
547
+ readonly type: "string";
548
+ readonly maxLength: 4096;
573
549
  };
574
550
  };
575
- pre: {
576
- description: string;
577
- type: string;
578
- maxLength: number;
551
+ readonly pre: {
552
+ readonly description: "Starts with";
553
+ readonly type: "string";
554
+ readonly maxLength: 4096;
579
555
  };
580
- suf: {
581
- description: string;
582
- type: string;
583
- maxLength: number;
556
+ readonly suf: {
557
+ readonly description: "Ends with";
558
+ readonly type: "string";
559
+ readonly maxLength: 4096;
584
560
  };
585
- re: {
586
- description: string;
587
- type: string;
588
- maxLength: number;
561
+ readonly re: {
562
+ readonly description: "Regex";
563
+ readonly type: "string";
564
+ readonly maxLength: 4096;
589
565
  };
590
- gt: {
591
- description: string;
592
- type: string;
566
+ readonly gt: {
567
+ readonly description: "Greater than";
568
+ readonly type: "number";
593
569
  };
594
- gte: {
595
- description: string;
596
- type: string;
570
+ readonly gte: {
571
+ readonly description: "Greater than or equal to";
572
+ readonly type: "number";
597
573
  };
598
- lt: {
599
- description: string;
600
- type: string;
574
+ readonly lt: {
575
+ readonly description: "Less than";
576
+ readonly type: "number";
601
577
  };
602
- lte: {
603
- description: string;
604
- type: string;
578
+ readonly lte: {
579
+ readonly description: "Less than or equal to";
580
+ readonly type: "number";
605
581
  };
606
582
  };
607
- maxLength?: undefined;
608
- })[];
583
+ }];
609
584
  };
610
585
  };
611
586
  }, {
@@ -624,85 +599,80 @@ export declare const routesSchema: {
624
599
  readonly maxLength: 4096;
625
600
  };
626
601
  readonly value: {
627
- description: string;
628
- anyOf: ({
629
- description: string;
630
- type: string;
631
- maxLength: number;
632
- additionalProperties?: undefined;
633
- minProperties?: undefined;
634
- properties?: undefined;
635
- } | {
636
- description: string;
637
- type: string;
638
- additionalProperties: boolean;
639
- minProperties: number;
640
- properties: {
641
- eq: {
642
- description: string;
643
- anyOf: ({
644
- type: string;
645
- maxLength: number;
646
- } | {
647
- type: string;
648
- maxLength?: undefined;
649
- })[];
650
- };
651
- neq: {
652
- description: string;
653
- type: string;
654
- maxLength: number;
655
- };
656
- inc: {
657
- description: string;
658
- type: string;
659
- items: {
660
- type: string;
661
- maxLength: number;
602
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
603
+ readonly anyOf: readonly [{
604
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
605
+ readonly type: "string";
606
+ readonly maxLength: 4096;
607
+ }, {
608
+ readonly description: "A condition operation object";
609
+ readonly type: "object";
610
+ readonly additionalProperties: false;
611
+ readonly minProperties: 1;
612
+ readonly properties: {
613
+ readonly eq: {
614
+ readonly description: "Equal to";
615
+ readonly anyOf: readonly [{
616
+ readonly type: "string";
617
+ readonly maxLength: 4096;
618
+ }, {
619
+ readonly type: "number";
620
+ }];
621
+ };
622
+ readonly neq: {
623
+ readonly description: "Not equal";
624
+ readonly type: "string";
625
+ readonly maxLength: 4096;
626
+ };
627
+ readonly inc: {
628
+ readonly description: "In array";
629
+ readonly type: "array";
630
+ readonly items: {
631
+ readonly type: "string";
632
+ readonly maxLength: 4096;
662
633
  };
663
634
  };
664
- ninc: {
665
- description: string;
666
- type: string;
667
- items: {
668
- type: string;
669
- maxLength: number;
635
+ readonly ninc: {
636
+ readonly description: "Not in array";
637
+ readonly type: "array";
638
+ readonly items: {
639
+ readonly type: "string";
640
+ readonly maxLength: 4096;
670
641
  };
671
642
  };
672
- pre: {
673
- description: string;
674
- type: string;
675
- maxLength: number;
643
+ readonly pre: {
644
+ readonly description: "Starts with";
645
+ readonly type: "string";
646
+ readonly maxLength: 4096;
676
647
  };
677
- suf: {
678
- description: string;
679
- type: string;
680
- maxLength: number;
648
+ readonly suf: {
649
+ readonly description: "Ends with";
650
+ readonly type: "string";
651
+ readonly maxLength: 4096;
681
652
  };
682
- re: {
683
- description: string;
684
- type: string;
685
- maxLength: number;
653
+ readonly re: {
654
+ readonly description: "Regex";
655
+ readonly type: "string";
656
+ readonly maxLength: 4096;
686
657
  };
687
- gt: {
688
- description: string;
689
- type: string;
658
+ readonly gt: {
659
+ readonly description: "Greater than";
660
+ readonly type: "number";
690
661
  };
691
- gte: {
692
- description: string;
693
- type: string;
662
+ readonly gte: {
663
+ readonly description: "Greater than or equal to";
664
+ readonly type: "number";
694
665
  };
695
- lt: {
696
- description: string;
697
- type: string;
666
+ readonly lt: {
667
+ readonly description: "Less than";
668
+ readonly type: "number";
698
669
  };
699
- lte: {
700
- description: string;
701
- type: string;
670
+ readonly lte: {
671
+ readonly description: "Less than or equal to";
672
+ readonly type: "number";
702
673
  };
703
674
  };
704
- maxLength?: undefined;
705
- })[];
675
+ }];
706
676
  };
707
677
  };
708
678
  }];
@@ -721,6 +691,176 @@ export declare const routesSchema: {
721
691
  };
722
692
  };
723
693
  };
694
+ readonly transforms: {
695
+ readonly description: "A list of transform rules to adjust the query parameters of a request or HTTP headers of request or response";
696
+ readonly type: "array";
697
+ readonly minItems: 1;
698
+ readonly items: {
699
+ readonly type: "object";
700
+ readonly additionalProperties: false;
701
+ readonly required: readonly ["type", "op", "target"];
702
+ readonly properties: {
703
+ readonly type: {
704
+ readonly description: "The scope of the transform to apply";
705
+ readonly type: "string";
706
+ readonly enum: readonly ["request.headers", "request.query", "response.headers"];
707
+ };
708
+ readonly op: {
709
+ readonly description: "The operation to perform on the target";
710
+ readonly type: "string";
711
+ readonly enum: readonly ["append", "set", "delete"];
712
+ };
713
+ readonly target: {
714
+ readonly description: "The target of the transform";
715
+ readonly type: "object";
716
+ readonly required: readonly ["key"];
717
+ readonly properties: {
718
+ readonly key: {
719
+ readonly description: "A value to match against. Can be a string or a condition operation object (without regex support)";
720
+ readonly anyOf: readonly [{
721
+ readonly description: "A valid header name (letters, numbers, hyphens, underscores)";
722
+ readonly type: "string";
723
+ readonly maxLength: 4096;
724
+ }, {
725
+ readonly description: "A condition operation object";
726
+ readonly type: "object";
727
+ readonly additionalProperties: false;
728
+ readonly minProperties: 1;
729
+ readonly properties: {
730
+ readonly eq: {
731
+ readonly description: "Equal to";
732
+ readonly anyOf: readonly [{
733
+ readonly type: "string";
734
+ readonly maxLength: 4096;
735
+ }, {
736
+ readonly type: "number";
737
+ }];
738
+ };
739
+ readonly neq: {
740
+ readonly description: "Not equal";
741
+ readonly type: "string";
742
+ readonly maxLength: 4096;
743
+ };
744
+ readonly inc: {
745
+ readonly description: "In array";
746
+ readonly type: "array";
747
+ readonly items: {
748
+ readonly type: "string";
749
+ readonly maxLength: 4096;
750
+ };
751
+ };
752
+ readonly ninc: {
753
+ readonly description: "Not in array";
754
+ readonly type: "array";
755
+ readonly items: {
756
+ readonly type: "string";
757
+ readonly maxLength: 4096;
758
+ };
759
+ };
760
+ readonly pre: {
761
+ readonly description: "Starts with";
762
+ readonly type: "string";
763
+ readonly maxLength: 4096;
764
+ };
765
+ readonly suf: {
766
+ readonly description: "Ends with";
767
+ readonly type: "string";
768
+ readonly maxLength: 4096;
769
+ };
770
+ readonly gt: {
771
+ readonly description: "Greater than";
772
+ readonly type: "number";
773
+ };
774
+ readonly gte: {
775
+ readonly description: "Greater than or equal to";
776
+ readonly type: "number";
777
+ };
778
+ readonly lt: {
779
+ readonly description: "Less than";
780
+ readonly type: "number";
781
+ };
782
+ readonly lte: {
783
+ readonly description: "Less than or equal to";
784
+ readonly type: "number";
785
+ };
786
+ };
787
+ }];
788
+ };
789
+ };
790
+ };
791
+ readonly args: {
792
+ readonly description: "The arguments to the operation";
793
+ readonly anyOf: readonly [{
794
+ readonly type: "string";
795
+ readonly maxLength: 4096;
796
+ }, {
797
+ readonly type: "array";
798
+ readonly minItems: 1;
799
+ readonly items: {
800
+ readonly type: "string";
801
+ readonly maxLength: 4096;
802
+ };
803
+ }];
804
+ };
805
+ };
806
+ readonly allOf: readonly [{
807
+ readonly if: {
808
+ readonly properties: {
809
+ readonly op: {
810
+ readonly enum: readonly ["append", "set"];
811
+ };
812
+ };
813
+ };
814
+ readonly then: {
815
+ readonly required: readonly ["args"];
816
+ };
817
+ }, {
818
+ readonly if: {
819
+ readonly allOf: readonly [{
820
+ readonly properties: {
821
+ readonly type: {
822
+ readonly enum: readonly ["request.headers", "response.headers"];
823
+ };
824
+ };
825
+ }, {
826
+ readonly properties: {
827
+ readonly op: {
828
+ readonly enum: readonly ["set", "append"];
829
+ };
830
+ };
831
+ }];
832
+ };
833
+ readonly then: {
834
+ readonly properties: {
835
+ readonly target: {
836
+ readonly properties: {
837
+ readonly key: {
838
+ readonly if: {
839
+ readonly type: "string";
840
+ };
841
+ readonly then: {
842
+ readonly pattern: "^[a-zA-Z0-9_-]+$";
843
+ };
844
+ };
845
+ };
846
+ };
847
+ readonly args: {
848
+ readonly anyOf: readonly [{
849
+ readonly type: "string";
850
+ readonly pattern: "^[a-zA-Z0-9_ :;.,\"'?!(){}\\[\\]@<>=+*#$&`|~\\^%/-]+$";
851
+ }, {
852
+ readonly type: "array";
853
+ readonly items: {
854
+ readonly type: "string";
855
+ readonly pattern: "^[a-zA-Z0-9_ :;.,\"'?!(){}\\[\\]@<>=+*#$&`|~\\^%/-]+$";
856
+ };
857
+ }];
858
+ };
859
+ };
860
+ };
861
+ }];
862
+ };
863
+ };
724
864
  };
725
865
  }, {
726
866
  readonly type: "object";
@@ -771,85 +911,80 @@ export declare const rewritesSchema: {
771
911
  readonly enum: readonly ["host"];
772
912
  };
773
913
  readonly value: {
774
- description: string;
775
- anyOf: ({
776
- description: string;
777
- type: string;
778
- maxLength: number;
779
- additionalProperties?: undefined;
780
- minProperties?: undefined;
781
- properties?: undefined;
782
- } | {
783
- description: string;
784
- type: string;
785
- additionalProperties: boolean;
786
- minProperties: number;
787
- properties: {
788
- eq: {
789
- description: string;
790
- anyOf: ({
791
- type: string;
792
- maxLength: number;
793
- } | {
794
- type: string;
795
- maxLength?: undefined;
796
- })[];
797
- };
798
- neq: {
799
- description: string;
800
- type: string;
801
- maxLength: number;
802
- };
803
- inc: {
804
- description: string;
805
- type: string;
806
- items: {
807
- type: string;
808
- maxLength: number;
809
- };
810
- };
811
- ninc: {
812
- description: string;
813
- type: string;
814
- items: {
815
- type: string;
816
- maxLength: number;
817
- };
818
- };
819
- pre: {
820
- description: string;
821
- type: string;
822
- maxLength: number;
823
- };
824
- suf: {
825
- description: string;
826
- type: string;
827
- maxLength: number;
828
- };
829
- re: {
830
- description: string;
831
- type: string;
832
- maxLength: number;
833
- };
834
- gt: {
835
- description: string;
836
- type: string;
837
- };
838
- gte: {
839
- description: string;
840
- type: string;
841
- };
842
- lt: {
843
- description: string;
844
- type: string;
845
- };
846
- lte: {
847
- description: string;
848
- type: string;
914
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
915
+ readonly anyOf: readonly [{
916
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
917
+ readonly type: "string";
918
+ readonly maxLength: 4096;
919
+ }, {
920
+ readonly description: "A condition operation object";
921
+ readonly type: "object";
922
+ readonly additionalProperties: false;
923
+ readonly minProperties: 1;
924
+ readonly properties: {
925
+ readonly eq: {
926
+ readonly description: "Equal to";
927
+ readonly anyOf: readonly [{
928
+ readonly type: "string";
929
+ readonly maxLength: 4096;
930
+ }, {
931
+ readonly type: "number";
932
+ }];
933
+ };
934
+ readonly neq: {
935
+ readonly description: "Not equal";
936
+ readonly type: "string";
937
+ readonly maxLength: 4096;
938
+ };
939
+ readonly inc: {
940
+ readonly description: "In array";
941
+ readonly type: "array";
942
+ readonly items: {
943
+ readonly type: "string";
944
+ readonly maxLength: 4096;
945
+ };
946
+ };
947
+ readonly ninc: {
948
+ readonly description: "Not in array";
949
+ readonly type: "array";
950
+ readonly items: {
951
+ readonly type: "string";
952
+ readonly maxLength: 4096;
953
+ };
954
+ };
955
+ readonly pre: {
956
+ readonly description: "Starts with";
957
+ readonly type: "string";
958
+ readonly maxLength: 4096;
959
+ };
960
+ readonly suf: {
961
+ readonly description: "Ends with";
962
+ readonly type: "string";
963
+ readonly maxLength: 4096;
964
+ };
965
+ readonly re: {
966
+ readonly description: "Regex";
967
+ readonly type: "string";
968
+ readonly maxLength: 4096;
969
+ };
970
+ readonly gt: {
971
+ readonly description: "Greater than";
972
+ readonly type: "number";
973
+ };
974
+ readonly gte: {
975
+ readonly description: "Greater than or equal to";
976
+ readonly type: "number";
977
+ };
978
+ readonly lt: {
979
+ readonly description: "Less than";
980
+ readonly type: "number";
981
+ };
982
+ readonly lte: {
983
+ readonly description: "Less than or equal to";
984
+ readonly type: "number";
849
985
  };
850
986
  };
851
- maxLength?: undefined;
852
- })[];
987
+ }];
853
988
  };
854
989
  };
855
990
  }, {
@@ -868,85 +1003,80 @@ export declare const rewritesSchema: {
868
1003
  readonly maxLength: 4096;
869
1004
  };
870
1005
  readonly value: {
871
- description: string;
872
- anyOf: ({
873
- description: string;
874
- type: string;
875
- maxLength: number;
876
- additionalProperties?: undefined;
877
- minProperties?: undefined;
878
- properties?: undefined;
879
- } | {
880
- description: string;
881
- type: string;
882
- additionalProperties: boolean;
883
- minProperties: number;
884
- properties: {
885
- eq: {
886
- description: string;
887
- anyOf: ({
888
- type: string;
889
- maxLength: number;
890
- } | {
891
- type: string;
892
- maxLength?: undefined;
893
- })[];
894
- };
895
- neq: {
896
- description: string;
897
- type: string;
898
- maxLength: number;
899
- };
900
- inc: {
901
- description: string;
902
- type: string;
903
- items: {
904
- type: string;
905
- maxLength: number;
906
- };
907
- };
908
- ninc: {
909
- description: string;
910
- type: string;
911
- items: {
912
- type: string;
913
- maxLength: number;
914
- };
915
- };
916
- pre: {
917
- description: string;
918
- type: string;
919
- maxLength: number;
920
- };
921
- suf: {
922
- description: string;
923
- type: string;
924
- maxLength: number;
925
- };
926
- re: {
927
- description: string;
928
- type: string;
929
- maxLength: number;
930
- };
931
- gt: {
932
- description: string;
933
- type: string;
934
- };
935
- gte: {
936
- description: string;
937
- type: string;
938
- };
939
- lt: {
940
- description: string;
941
- type: string;
942
- };
943
- lte: {
944
- description: string;
945
- type: string;
1006
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
1007
+ readonly anyOf: readonly [{
1008
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
1009
+ readonly type: "string";
1010
+ readonly maxLength: 4096;
1011
+ }, {
1012
+ readonly description: "A condition operation object";
1013
+ readonly type: "object";
1014
+ readonly additionalProperties: false;
1015
+ readonly minProperties: 1;
1016
+ readonly properties: {
1017
+ readonly eq: {
1018
+ readonly description: "Equal to";
1019
+ readonly anyOf: readonly [{
1020
+ readonly type: "string";
1021
+ readonly maxLength: 4096;
1022
+ }, {
1023
+ readonly type: "number";
1024
+ }];
1025
+ };
1026
+ readonly neq: {
1027
+ readonly description: "Not equal";
1028
+ readonly type: "string";
1029
+ readonly maxLength: 4096;
1030
+ };
1031
+ readonly inc: {
1032
+ readonly description: "In array";
1033
+ readonly type: "array";
1034
+ readonly items: {
1035
+ readonly type: "string";
1036
+ readonly maxLength: 4096;
1037
+ };
1038
+ };
1039
+ readonly ninc: {
1040
+ readonly description: "Not in array";
1041
+ readonly type: "array";
1042
+ readonly items: {
1043
+ readonly type: "string";
1044
+ readonly maxLength: 4096;
1045
+ };
1046
+ };
1047
+ readonly pre: {
1048
+ readonly description: "Starts with";
1049
+ readonly type: "string";
1050
+ readonly maxLength: 4096;
1051
+ };
1052
+ readonly suf: {
1053
+ readonly description: "Ends with";
1054
+ readonly type: "string";
1055
+ readonly maxLength: 4096;
1056
+ };
1057
+ readonly re: {
1058
+ readonly description: "Regex";
1059
+ readonly type: "string";
1060
+ readonly maxLength: 4096;
1061
+ };
1062
+ readonly gt: {
1063
+ readonly description: "Greater than";
1064
+ readonly type: "number";
1065
+ };
1066
+ readonly gte: {
1067
+ readonly description: "Greater than or equal to";
1068
+ readonly type: "number";
1069
+ };
1070
+ readonly lt: {
1071
+ readonly description: "Less than";
1072
+ readonly type: "number";
1073
+ };
1074
+ readonly lte: {
1075
+ readonly description: "Less than or equal to";
1076
+ readonly type: "number";
946
1077
  };
947
1078
  };
948
- maxLength?: undefined;
949
- })[];
1079
+ }];
950
1080
  };
951
1081
  };
952
1082
  }];
@@ -968,85 +1098,80 @@ export declare const rewritesSchema: {
968
1098
  readonly enum: readonly ["host"];
969
1099
  };
970
1100
  readonly value: {
971
- description: string;
972
- anyOf: ({
973
- description: string;
974
- type: string;
975
- maxLength: number;
976
- additionalProperties?: undefined;
977
- minProperties?: undefined;
978
- properties?: undefined;
979
- } | {
980
- description: string;
981
- type: string;
982
- additionalProperties: boolean;
983
- minProperties: number;
984
- properties: {
985
- eq: {
986
- description: string;
987
- anyOf: ({
988
- type: string;
989
- maxLength: number;
990
- } | {
991
- type: string;
992
- maxLength?: undefined;
993
- })[];
994
- };
995
- neq: {
996
- description: string;
997
- type: string;
998
- maxLength: number;
999
- };
1000
- inc: {
1001
- description: string;
1002
- type: string;
1003
- items: {
1004
- type: string;
1005
- maxLength: number;
1006
- };
1007
- };
1008
- ninc: {
1009
- description: string;
1010
- type: string;
1011
- items: {
1012
- type: string;
1013
- maxLength: number;
1014
- };
1015
- };
1016
- pre: {
1017
- description: string;
1018
- type: string;
1019
- maxLength: number;
1020
- };
1021
- suf: {
1022
- description: string;
1023
- type: string;
1024
- maxLength: number;
1025
- };
1026
- re: {
1027
- description: string;
1028
- type: string;
1029
- maxLength: number;
1030
- };
1031
- gt: {
1032
- description: string;
1033
- type: string;
1034
- };
1035
- gte: {
1036
- description: string;
1037
- type: string;
1038
- };
1039
- lt: {
1040
- description: string;
1041
- type: string;
1042
- };
1043
- lte: {
1044
- description: string;
1045
- type: string;
1101
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
1102
+ readonly anyOf: readonly [{
1103
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
1104
+ readonly type: "string";
1105
+ readonly maxLength: 4096;
1106
+ }, {
1107
+ readonly description: "A condition operation object";
1108
+ readonly type: "object";
1109
+ readonly additionalProperties: false;
1110
+ readonly minProperties: 1;
1111
+ readonly properties: {
1112
+ readonly eq: {
1113
+ readonly description: "Equal to";
1114
+ readonly anyOf: readonly [{
1115
+ readonly type: "string";
1116
+ readonly maxLength: 4096;
1117
+ }, {
1118
+ readonly type: "number";
1119
+ }];
1120
+ };
1121
+ readonly neq: {
1122
+ readonly description: "Not equal";
1123
+ readonly type: "string";
1124
+ readonly maxLength: 4096;
1125
+ };
1126
+ readonly inc: {
1127
+ readonly description: "In array";
1128
+ readonly type: "array";
1129
+ readonly items: {
1130
+ readonly type: "string";
1131
+ readonly maxLength: 4096;
1132
+ };
1133
+ };
1134
+ readonly ninc: {
1135
+ readonly description: "Not in array";
1136
+ readonly type: "array";
1137
+ readonly items: {
1138
+ readonly type: "string";
1139
+ readonly maxLength: 4096;
1140
+ };
1141
+ };
1142
+ readonly pre: {
1143
+ readonly description: "Starts with";
1144
+ readonly type: "string";
1145
+ readonly maxLength: 4096;
1146
+ };
1147
+ readonly suf: {
1148
+ readonly description: "Ends with";
1149
+ readonly type: "string";
1150
+ readonly maxLength: 4096;
1151
+ };
1152
+ readonly re: {
1153
+ readonly description: "Regex";
1154
+ readonly type: "string";
1155
+ readonly maxLength: 4096;
1156
+ };
1157
+ readonly gt: {
1158
+ readonly description: "Greater than";
1159
+ readonly type: "number";
1160
+ };
1161
+ readonly gte: {
1162
+ readonly description: "Greater than or equal to";
1163
+ readonly type: "number";
1164
+ };
1165
+ readonly lt: {
1166
+ readonly description: "Less than";
1167
+ readonly type: "number";
1168
+ };
1169
+ readonly lte: {
1170
+ readonly description: "Less than or equal to";
1171
+ readonly type: "number";
1046
1172
  };
1047
1173
  };
1048
- maxLength?: undefined;
1049
- })[];
1174
+ }];
1050
1175
  };
1051
1176
  };
1052
1177
  }, {
@@ -1065,85 +1190,80 @@ export declare const rewritesSchema: {
1065
1190
  readonly maxLength: 4096;
1066
1191
  };
1067
1192
  readonly value: {
1068
- description: string;
1069
- anyOf: ({
1070
- description: string;
1071
- type: string;
1072
- maxLength: number;
1073
- additionalProperties?: undefined;
1074
- minProperties?: undefined;
1075
- properties?: undefined;
1076
- } | {
1077
- description: string;
1078
- type: string;
1079
- additionalProperties: boolean;
1080
- minProperties: number;
1081
- properties: {
1082
- eq: {
1083
- description: string;
1084
- anyOf: ({
1085
- type: string;
1086
- maxLength: number;
1087
- } | {
1088
- type: string;
1089
- maxLength?: undefined;
1090
- })[];
1091
- };
1092
- neq: {
1093
- description: string;
1094
- type: string;
1095
- maxLength: number;
1096
- };
1097
- inc: {
1098
- description: string;
1099
- type: string;
1100
- items: {
1101
- type: string;
1102
- maxLength: number;
1103
- };
1104
- };
1105
- ninc: {
1106
- description: string;
1107
- type: string;
1108
- items: {
1109
- type: string;
1110
- maxLength: number;
1111
- };
1112
- };
1113
- pre: {
1114
- description: string;
1115
- type: string;
1116
- maxLength: number;
1117
- };
1118
- suf: {
1119
- description: string;
1120
- type: string;
1121
- maxLength: number;
1122
- };
1123
- re: {
1124
- description: string;
1125
- type: string;
1126
- maxLength: number;
1127
- };
1128
- gt: {
1129
- description: string;
1130
- type: string;
1131
- };
1132
- gte: {
1133
- description: string;
1134
- type: string;
1135
- };
1136
- lt: {
1137
- description: string;
1138
- type: string;
1139
- };
1140
- lte: {
1141
- description: string;
1142
- type: string;
1193
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
1194
+ readonly anyOf: readonly [{
1195
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
1196
+ readonly type: "string";
1197
+ readonly maxLength: 4096;
1198
+ }, {
1199
+ readonly description: "A condition operation object";
1200
+ readonly type: "object";
1201
+ readonly additionalProperties: false;
1202
+ readonly minProperties: 1;
1203
+ readonly properties: {
1204
+ readonly eq: {
1205
+ readonly description: "Equal to";
1206
+ readonly anyOf: readonly [{
1207
+ readonly type: "string";
1208
+ readonly maxLength: 4096;
1209
+ }, {
1210
+ readonly type: "number";
1211
+ }];
1212
+ };
1213
+ readonly neq: {
1214
+ readonly description: "Not equal";
1215
+ readonly type: "string";
1216
+ readonly maxLength: 4096;
1217
+ };
1218
+ readonly inc: {
1219
+ readonly description: "In array";
1220
+ readonly type: "array";
1221
+ readonly items: {
1222
+ readonly type: "string";
1223
+ readonly maxLength: 4096;
1224
+ };
1225
+ };
1226
+ readonly ninc: {
1227
+ readonly description: "Not in array";
1228
+ readonly type: "array";
1229
+ readonly items: {
1230
+ readonly type: "string";
1231
+ readonly maxLength: 4096;
1232
+ };
1233
+ };
1234
+ readonly pre: {
1235
+ readonly description: "Starts with";
1236
+ readonly type: "string";
1237
+ readonly maxLength: 4096;
1238
+ };
1239
+ readonly suf: {
1240
+ readonly description: "Ends with";
1241
+ readonly type: "string";
1242
+ readonly maxLength: 4096;
1243
+ };
1244
+ readonly re: {
1245
+ readonly description: "Regex";
1246
+ readonly type: "string";
1247
+ readonly maxLength: 4096;
1248
+ };
1249
+ readonly gt: {
1250
+ readonly description: "Greater than";
1251
+ readonly type: "number";
1252
+ };
1253
+ readonly gte: {
1254
+ readonly description: "Greater than or equal to";
1255
+ readonly type: "number";
1256
+ };
1257
+ readonly lt: {
1258
+ readonly description: "Less than";
1259
+ readonly type: "number";
1260
+ };
1261
+ readonly lte: {
1262
+ readonly description: "Less than or equal to";
1263
+ readonly type: "number";
1143
1264
  };
1144
1265
  };
1145
- maxLength?: undefined;
1146
- })[];
1266
+ }];
1147
1267
  };
1148
1268
  };
1149
1269
  }];
@@ -1205,85 +1325,80 @@ export declare const redirectsSchema: {
1205
1325
  readonly enum: readonly ["host"];
1206
1326
  };
1207
1327
  readonly value: {
1208
- description: string;
1209
- anyOf: ({
1210
- description: string;
1211
- type: string;
1212
- maxLength: number;
1213
- additionalProperties?: undefined;
1214
- minProperties?: undefined;
1215
- properties?: undefined;
1216
- } | {
1217
- description: string;
1218
- type: string;
1219
- additionalProperties: boolean;
1220
- minProperties: number;
1221
- properties: {
1222
- eq: {
1223
- description: string;
1224
- anyOf: ({
1225
- type: string;
1226
- maxLength: number;
1227
- } | {
1228
- type: string;
1229
- maxLength?: undefined;
1230
- })[];
1231
- };
1232
- neq: {
1233
- description: string;
1234
- type: string;
1235
- maxLength: number;
1236
- };
1237
- inc: {
1238
- description: string;
1239
- type: string;
1240
- items: {
1241
- type: string;
1242
- maxLength: number;
1243
- };
1244
- };
1245
- ninc: {
1246
- description: string;
1247
- type: string;
1248
- items: {
1249
- type: string;
1250
- maxLength: number;
1251
- };
1252
- };
1253
- pre: {
1254
- description: string;
1255
- type: string;
1256
- maxLength: number;
1257
- };
1258
- suf: {
1259
- description: string;
1260
- type: string;
1261
- maxLength: number;
1262
- };
1263
- re: {
1264
- description: string;
1265
- type: string;
1266
- maxLength: number;
1267
- };
1268
- gt: {
1269
- description: string;
1270
- type: string;
1271
- };
1272
- gte: {
1273
- description: string;
1274
- type: string;
1275
- };
1276
- lt: {
1277
- description: string;
1278
- type: string;
1279
- };
1280
- lte: {
1281
- description: string;
1282
- type: string;
1328
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
1329
+ readonly anyOf: readonly [{
1330
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
1331
+ readonly type: "string";
1332
+ readonly maxLength: 4096;
1333
+ }, {
1334
+ readonly description: "A condition operation object";
1335
+ readonly type: "object";
1336
+ readonly additionalProperties: false;
1337
+ readonly minProperties: 1;
1338
+ readonly properties: {
1339
+ readonly eq: {
1340
+ readonly description: "Equal to";
1341
+ readonly anyOf: readonly [{
1342
+ readonly type: "string";
1343
+ readonly maxLength: 4096;
1344
+ }, {
1345
+ readonly type: "number";
1346
+ }];
1347
+ };
1348
+ readonly neq: {
1349
+ readonly description: "Not equal";
1350
+ readonly type: "string";
1351
+ readonly maxLength: 4096;
1352
+ };
1353
+ readonly inc: {
1354
+ readonly description: "In array";
1355
+ readonly type: "array";
1356
+ readonly items: {
1357
+ readonly type: "string";
1358
+ readonly maxLength: 4096;
1359
+ };
1360
+ };
1361
+ readonly ninc: {
1362
+ readonly description: "Not in array";
1363
+ readonly type: "array";
1364
+ readonly items: {
1365
+ readonly type: "string";
1366
+ readonly maxLength: 4096;
1367
+ };
1368
+ };
1369
+ readonly pre: {
1370
+ readonly description: "Starts with";
1371
+ readonly type: "string";
1372
+ readonly maxLength: 4096;
1373
+ };
1374
+ readonly suf: {
1375
+ readonly description: "Ends with";
1376
+ readonly type: "string";
1377
+ readonly maxLength: 4096;
1378
+ };
1379
+ readonly re: {
1380
+ readonly description: "Regex";
1381
+ readonly type: "string";
1382
+ readonly maxLength: 4096;
1383
+ };
1384
+ readonly gt: {
1385
+ readonly description: "Greater than";
1386
+ readonly type: "number";
1387
+ };
1388
+ readonly gte: {
1389
+ readonly description: "Greater than or equal to";
1390
+ readonly type: "number";
1391
+ };
1392
+ readonly lt: {
1393
+ readonly description: "Less than";
1394
+ readonly type: "number";
1395
+ };
1396
+ readonly lte: {
1397
+ readonly description: "Less than or equal to";
1398
+ readonly type: "number";
1283
1399
  };
1284
1400
  };
1285
- maxLength?: undefined;
1286
- })[];
1401
+ }];
1287
1402
  };
1288
1403
  };
1289
1404
  }, {
@@ -1302,85 +1417,80 @@ export declare const redirectsSchema: {
1302
1417
  readonly maxLength: 4096;
1303
1418
  };
1304
1419
  readonly value: {
1305
- description: string;
1306
- anyOf: ({
1307
- description: string;
1308
- type: string;
1309
- maxLength: number;
1310
- additionalProperties?: undefined;
1311
- minProperties?: undefined;
1312
- properties?: undefined;
1313
- } | {
1314
- description: string;
1315
- type: string;
1316
- additionalProperties: boolean;
1317
- minProperties: number;
1318
- properties: {
1319
- eq: {
1320
- description: string;
1321
- anyOf: ({
1322
- type: string;
1323
- maxLength: number;
1324
- } | {
1325
- type: string;
1326
- maxLength?: undefined;
1327
- })[];
1328
- };
1329
- neq: {
1330
- description: string;
1331
- type: string;
1332
- maxLength: number;
1333
- };
1334
- inc: {
1335
- description: string;
1336
- type: string;
1337
- items: {
1338
- type: string;
1339
- maxLength: number;
1340
- };
1341
- };
1342
- ninc: {
1343
- description: string;
1344
- type: string;
1345
- items: {
1346
- type: string;
1347
- maxLength: number;
1348
- };
1349
- };
1350
- pre: {
1351
- description: string;
1352
- type: string;
1353
- maxLength: number;
1354
- };
1355
- suf: {
1356
- description: string;
1357
- type: string;
1358
- maxLength: number;
1359
- };
1360
- re: {
1361
- description: string;
1362
- type: string;
1363
- maxLength: number;
1364
- };
1365
- gt: {
1366
- description: string;
1367
- type: string;
1368
- };
1369
- gte: {
1370
- description: string;
1371
- type: string;
1372
- };
1373
- lt: {
1374
- description: string;
1375
- type: string;
1376
- };
1377
- lte: {
1378
- description: string;
1379
- type: string;
1420
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
1421
+ readonly anyOf: readonly [{
1422
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
1423
+ readonly type: "string";
1424
+ readonly maxLength: 4096;
1425
+ }, {
1426
+ readonly description: "A condition operation object";
1427
+ readonly type: "object";
1428
+ readonly additionalProperties: false;
1429
+ readonly minProperties: 1;
1430
+ readonly properties: {
1431
+ readonly eq: {
1432
+ readonly description: "Equal to";
1433
+ readonly anyOf: readonly [{
1434
+ readonly type: "string";
1435
+ readonly maxLength: 4096;
1436
+ }, {
1437
+ readonly type: "number";
1438
+ }];
1439
+ };
1440
+ readonly neq: {
1441
+ readonly description: "Not equal";
1442
+ readonly type: "string";
1443
+ readonly maxLength: 4096;
1444
+ };
1445
+ readonly inc: {
1446
+ readonly description: "In array";
1447
+ readonly type: "array";
1448
+ readonly items: {
1449
+ readonly type: "string";
1450
+ readonly maxLength: 4096;
1451
+ };
1452
+ };
1453
+ readonly ninc: {
1454
+ readonly description: "Not in array";
1455
+ readonly type: "array";
1456
+ readonly items: {
1457
+ readonly type: "string";
1458
+ readonly maxLength: 4096;
1459
+ };
1460
+ };
1461
+ readonly pre: {
1462
+ readonly description: "Starts with";
1463
+ readonly type: "string";
1464
+ readonly maxLength: 4096;
1465
+ };
1466
+ readonly suf: {
1467
+ readonly description: "Ends with";
1468
+ readonly type: "string";
1469
+ readonly maxLength: 4096;
1470
+ };
1471
+ readonly re: {
1472
+ readonly description: "Regex";
1473
+ readonly type: "string";
1474
+ readonly maxLength: 4096;
1475
+ };
1476
+ readonly gt: {
1477
+ readonly description: "Greater than";
1478
+ readonly type: "number";
1479
+ };
1480
+ readonly gte: {
1481
+ readonly description: "Greater than or equal to";
1482
+ readonly type: "number";
1483
+ };
1484
+ readonly lt: {
1485
+ readonly description: "Less than";
1486
+ readonly type: "number";
1487
+ };
1488
+ readonly lte: {
1489
+ readonly description: "Less than or equal to";
1490
+ readonly type: "number";
1380
1491
  };
1381
1492
  };
1382
- maxLength?: undefined;
1383
- })[];
1493
+ }];
1384
1494
  };
1385
1495
  };
1386
1496
  }];
@@ -1402,85 +1512,80 @@ export declare const redirectsSchema: {
1402
1512
  readonly enum: readonly ["host"];
1403
1513
  };
1404
1514
  readonly value: {
1405
- description: string;
1406
- anyOf: ({
1407
- description: string;
1408
- type: string;
1409
- maxLength: number;
1410
- additionalProperties?: undefined;
1411
- minProperties?: undefined;
1412
- properties?: undefined;
1413
- } | {
1414
- description: string;
1415
- type: string;
1416
- additionalProperties: boolean;
1417
- minProperties: number;
1418
- properties: {
1419
- eq: {
1420
- description: string;
1421
- anyOf: ({
1422
- type: string;
1423
- maxLength: number;
1424
- } | {
1425
- type: string;
1426
- maxLength?: undefined;
1427
- })[];
1428
- };
1429
- neq: {
1430
- description: string;
1431
- type: string;
1432
- maxLength: number;
1433
- };
1434
- inc: {
1435
- description: string;
1436
- type: string;
1437
- items: {
1438
- type: string;
1439
- maxLength: number;
1440
- };
1441
- };
1442
- ninc: {
1443
- description: string;
1444
- type: string;
1445
- items: {
1446
- type: string;
1447
- maxLength: number;
1448
- };
1449
- };
1450
- pre: {
1451
- description: string;
1452
- type: string;
1453
- maxLength: number;
1454
- };
1455
- suf: {
1456
- description: string;
1457
- type: string;
1458
- maxLength: number;
1459
- };
1460
- re: {
1461
- description: string;
1462
- type: string;
1463
- maxLength: number;
1464
- };
1465
- gt: {
1466
- description: string;
1467
- type: string;
1468
- };
1469
- gte: {
1470
- description: string;
1471
- type: string;
1472
- };
1473
- lt: {
1474
- description: string;
1475
- type: string;
1476
- };
1477
- lte: {
1478
- description: string;
1479
- type: string;
1515
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
1516
+ readonly anyOf: readonly [{
1517
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
1518
+ readonly type: "string";
1519
+ readonly maxLength: 4096;
1520
+ }, {
1521
+ readonly description: "A condition operation object";
1522
+ readonly type: "object";
1523
+ readonly additionalProperties: false;
1524
+ readonly minProperties: 1;
1525
+ readonly properties: {
1526
+ readonly eq: {
1527
+ readonly description: "Equal to";
1528
+ readonly anyOf: readonly [{
1529
+ readonly type: "string";
1530
+ readonly maxLength: 4096;
1531
+ }, {
1532
+ readonly type: "number";
1533
+ }];
1534
+ };
1535
+ readonly neq: {
1536
+ readonly description: "Not equal";
1537
+ readonly type: "string";
1538
+ readonly maxLength: 4096;
1539
+ };
1540
+ readonly inc: {
1541
+ readonly description: "In array";
1542
+ readonly type: "array";
1543
+ readonly items: {
1544
+ readonly type: "string";
1545
+ readonly maxLength: 4096;
1546
+ };
1547
+ };
1548
+ readonly ninc: {
1549
+ readonly description: "Not in array";
1550
+ readonly type: "array";
1551
+ readonly items: {
1552
+ readonly type: "string";
1553
+ readonly maxLength: 4096;
1554
+ };
1555
+ };
1556
+ readonly pre: {
1557
+ readonly description: "Starts with";
1558
+ readonly type: "string";
1559
+ readonly maxLength: 4096;
1560
+ };
1561
+ readonly suf: {
1562
+ readonly description: "Ends with";
1563
+ readonly type: "string";
1564
+ readonly maxLength: 4096;
1565
+ };
1566
+ readonly re: {
1567
+ readonly description: "Regex";
1568
+ readonly type: "string";
1569
+ readonly maxLength: 4096;
1570
+ };
1571
+ readonly gt: {
1572
+ readonly description: "Greater than";
1573
+ readonly type: "number";
1574
+ };
1575
+ readonly gte: {
1576
+ readonly description: "Greater than or equal to";
1577
+ readonly type: "number";
1578
+ };
1579
+ readonly lt: {
1580
+ readonly description: "Less than";
1581
+ readonly type: "number";
1582
+ };
1583
+ readonly lte: {
1584
+ readonly description: "Less than or equal to";
1585
+ readonly type: "number";
1480
1586
  };
1481
1587
  };
1482
- maxLength?: undefined;
1483
- })[];
1588
+ }];
1484
1589
  };
1485
1590
  };
1486
1591
  }, {
@@ -1499,85 +1604,80 @@ export declare const redirectsSchema: {
1499
1604
  readonly maxLength: 4096;
1500
1605
  };
1501
1606
  readonly value: {
1502
- description: string;
1503
- anyOf: ({
1504
- description: string;
1505
- type: string;
1506
- maxLength: number;
1507
- additionalProperties?: undefined;
1508
- minProperties?: undefined;
1509
- properties?: undefined;
1510
- } | {
1511
- description: string;
1512
- type: string;
1513
- additionalProperties: boolean;
1514
- minProperties: number;
1515
- properties: {
1516
- eq: {
1517
- description: string;
1518
- anyOf: ({
1519
- type: string;
1520
- maxLength: number;
1521
- } | {
1522
- type: string;
1523
- maxLength?: undefined;
1524
- })[];
1525
- };
1526
- neq: {
1527
- description: string;
1528
- type: string;
1529
- maxLength: number;
1530
- };
1531
- inc: {
1532
- description: string;
1533
- type: string;
1534
- items: {
1535
- type: string;
1536
- maxLength: number;
1537
- };
1538
- };
1539
- ninc: {
1540
- description: string;
1541
- type: string;
1542
- items: {
1543
- type: string;
1544
- maxLength: number;
1545
- };
1546
- };
1547
- pre: {
1548
- description: string;
1549
- type: string;
1550
- maxLength: number;
1551
- };
1552
- suf: {
1553
- description: string;
1554
- type: string;
1555
- maxLength: number;
1556
- };
1557
- re: {
1558
- description: string;
1559
- type: string;
1560
- maxLength: number;
1561
- };
1562
- gt: {
1563
- description: string;
1564
- type: string;
1565
- };
1566
- gte: {
1567
- description: string;
1568
- type: string;
1569
- };
1570
- lt: {
1571
- description: string;
1572
- type: string;
1573
- };
1574
- lte: {
1575
- description: string;
1576
- type: string;
1607
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
1608
+ readonly anyOf: readonly [{
1609
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
1610
+ readonly type: "string";
1611
+ readonly maxLength: 4096;
1612
+ }, {
1613
+ readonly description: "A condition operation object";
1614
+ readonly type: "object";
1615
+ readonly additionalProperties: false;
1616
+ readonly minProperties: 1;
1617
+ readonly properties: {
1618
+ readonly eq: {
1619
+ readonly description: "Equal to";
1620
+ readonly anyOf: readonly [{
1621
+ readonly type: "string";
1622
+ readonly maxLength: 4096;
1623
+ }, {
1624
+ readonly type: "number";
1625
+ }];
1626
+ };
1627
+ readonly neq: {
1628
+ readonly description: "Not equal";
1629
+ readonly type: "string";
1630
+ readonly maxLength: 4096;
1631
+ };
1632
+ readonly inc: {
1633
+ readonly description: "In array";
1634
+ readonly type: "array";
1635
+ readonly items: {
1636
+ readonly type: "string";
1637
+ readonly maxLength: 4096;
1638
+ };
1639
+ };
1640
+ readonly ninc: {
1641
+ readonly description: "Not in array";
1642
+ readonly type: "array";
1643
+ readonly items: {
1644
+ readonly type: "string";
1645
+ readonly maxLength: 4096;
1646
+ };
1647
+ };
1648
+ readonly pre: {
1649
+ readonly description: "Starts with";
1650
+ readonly type: "string";
1651
+ readonly maxLength: 4096;
1652
+ };
1653
+ readonly suf: {
1654
+ readonly description: "Ends with";
1655
+ readonly type: "string";
1656
+ readonly maxLength: 4096;
1657
+ };
1658
+ readonly re: {
1659
+ readonly description: "Regex";
1660
+ readonly type: "string";
1661
+ readonly maxLength: 4096;
1662
+ };
1663
+ readonly gt: {
1664
+ readonly description: "Greater than";
1665
+ readonly type: "number";
1666
+ };
1667
+ readonly gte: {
1668
+ readonly description: "Greater than or equal to";
1669
+ readonly type: "number";
1670
+ };
1671
+ readonly lt: {
1672
+ readonly description: "Less than";
1673
+ readonly type: "number";
1674
+ };
1675
+ readonly lte: {
1676
+ readonly description: "Less than or equal to";
1677
+ readonly type: "number";
1577
1678
  };
1578
1679
  };
1579
- maxLength?: undefined;
1580
- })[];
1680
+ }];
1581
1681
  };
1582
1682
  };
1583
1683
  }];
@@ -1636,85 +1736,80 @@ export declare const headersSchema: {
1636
1736
  readonly enum: readonly ["host"];
1637
1737
  };
1638
1738
  readonly value: {
1639
- description: string;
1640
- anyOf: ({
1641
- description: string;
1642
- type: string;
1643
- maxLength: number;
1644
- additionalProperties?: undefined;
1645
- minProperties?: undefined;
1646
- properties?: undefined;
1647
- } | {
1648
- description: string;
1649
- type: string;
1650
- additionalProperties: boolean;
1651
- minProperties: number;
1652
- properties: {
1653
- eq: {
1654
- description: string;
1655
- anyOf: ({
1656
- type: string;
1657
- maxLength: number;
1658
- } | {
1659
- type: string;
1660
- maxLength?: undefined;
1661
- })[];
1662
- };
1663
- neq: {
1664
- description: string;
1665
- type: string;
1666
- maxLength: number;
1667
- };
1668
- inc: {
1669
- description: string;
1670
- type: string;
1671
- items: {
1672
- type: string;
1673
- maxLength: number;
1674
- };
1675
- };
1676
- ninc: {
1677
- description: string;
1678
- type: string;
1679
- items: {
1680
- type: string;
1681
- maxLength: number;
1682
- };
1683
- };
1684
- pre: {
1685
- description: string;
1686
- type: string;
1687
- maxLength: number;
1688
- };
1689
- suf: {
1690
- description: string;
1691
- type: string;
1692
- maxLength: number;
1693
- };
1694
- re: {
1695
- description: string;
1696
- type: string;
1697
- maxLength: number;
1698
- };
1699
- gt: {
1700
- description: string;
1701
- type: string;
1702
- };
1703
- gte: {
1704
- description: string;
1705
- type: string;
1706
- };
1707
- lt: {
1708
- description: string;
1709
- type: string;
1710
- };
1711
- lte: {
1712
- description: string;
1713
- type: string;
1739
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
1740
+ readonly anyOf: readonly [{
1741
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
1742
+ readonly type: "string";
1743
+ readonly maxLength: 4096;
1744
+ }, {
1745
+ readonly description: "A condition operation object";
1746
+ readonly type: "object";
1747
+ readonly additionalProperties: false;
1748
+ readonly minProperties: 1;
1749
+ readonly properties: {
1750
+ readonly eq: {
1751
+ readonly description: "Equal to";
1752
+ readonly anyOf: readonly [{
1753
+ readonly type: "string";
1754
+ readonly maxLength: 4096;
1755
+ }, {
1756
+ readonly type: "number";
1757
+ }];
1758
+ };
1759
+ readonly neq: {
1760
+ readonly description: "Not equal";
1761
+ readonly type: "string";
1762
+ readonly maxLength: 4096;
1763
+ };
1764
+ readonly inc: {
1765
+ readonly description: "In array";
1766
+ readonly type: "array";
1767
+ readonly items: {
1768
+ readonly type: "string";
1769
+ readonly maxLength: 4096;
1770
+ };
1771
+ };
1772
+ readonly ninc: {
1773
+ readonly description: "Not in array";
1774
+ readonly type: "array";
1775
+ readonly items: {
1776
+ readonly type: "string";
1777
+ readonly maxLength: 4096;
1778
+ };
1779
+ };
1780
+ readonly pre: {
1781
+ readonly description: "Starts with";
1782
+ readonly type: "string";
1783
+ readonly maxLength: 4096;
1784
+ };
1785
+ readonly suf: {
1786
+ readonly description: "Ends with";
1787
+ readonly type: "string";
1788
+ readonly maxLength: 4096;
1789
+ };
1790
+ readonly re: {
1791
+ readonly description: "Regex";
1792
+ readonly type: "string";
1793
+ readonly maxLength: 4096;
1794
+ };
1795
+ readonly gt: {
1796
+ readonly description: "Greater than";
1797
+ readonly type: "number";
1798
+ };
1799
+ readonly gte: {
1800
+ readonly description: "Greater than or equal to";
1801
+ readonly type: "number";
1802
+ };
1803
+ readonly lt: {
1804
+ readonly description: "Less than";
1805
+ readonly type: "number";
1806
+ };
1807
+ readonly lte: {
1808
+ readonly description: "Less than or equal to";
1809
+ readonly type: "number";
1714
1810
  };
1715
1811
  };
1716
- maxLength?: undefined;
1717
- })[];
1812
+ }];
1718
1813
  };
1719
1814
  };
1720
1815
  }, {
@@ -1733,85 +1828,80 @@ export declare const headersSchema: {
1733
1828
  readonly maxLength: 4096;
1734
1829
  };
1735
1830
  readonly value: {
1736
- description: string;
1737
- anyOf: ({
1738
- description: string;
1739
- type: string;
1740
- maxLength: number;
1741
- additionalProperties?: undefined;
1742
- minProperties?: undefined;
1743
- properties?: undefined;
1744
- } | {
1745
- description: string;
1746
- type: string;
1747
- additionalProperties: boolean;
1748
- minProperties: number;
1749
- properties: {
1750
- eq: {
1751
- description: string;
1752
- anyOf: ({
1753
- type: string;
1754
- maxLength: number;
1755
- } | {
1756
- type: string;
1757
- maxLength?: undefined;
1758
- })[];
1759
- };
1760
- neq: {
1761
- description: string;
1762
- type: string;
1763
- maxLength: number;
1764
- };
1765
- inc: {
1766
- description: string;
1767
- type: string;
1768
- items: {
1769
- type: string;
1770
- maxLength: number;
1771
- };
1772
- };
1773
- ninc: {
1774
- description: string;
1775
- type: string;
1776
- items: {
1777
- type: string;
1778
- maxLength: number;
1779
- };
1780
- };
1781
- pre: {
1782
- description: string;
1783
- type: string;
1784
- maxLength: number;
1785
- };
1786
- suf: {
1787
- description: string;
1788
- type: string;
1789
- maxLength: number;
1790
- };
1791
- re: {
1792
- description: string;
1793
- type: string;
1794
- maxLength: number;
1795
- };
1796
- gt: {
1797
- description: string;
1798
- type: string;
1799
- };
1800
- gte: {
1801
- description: string;
1802
- type: string;
1803
- };
1804
- lt: {
1805
- description: string;
1806
- type: string;
1807
- };
1808
- lte: {
1809
- description: string;
1810
- type: string;
1831
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
1832
+ readonly anyOf: readonly [{
1833
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
1834
+ readonly type: "string";
1835
+ readonly maxLength: 4096;
1836
+ }, {
1837
+ readonly description: "A condition operation object";
1838
+ readonly type: "object";
1839
+ readonly additionalProperties: false;
1840
+ readonly minProperties: 1;
1841
+ readonly properties: {
1842
+ readonly eq: {
1843
+ readonly description: "Equal to";
1844
+ readonly anyOf: readonly [{
1845
+ readonly type: "string";
1846
+ readonly maxLength: 4096;
1847
+ }, {
1848
+ readonly type: "number";
1849
+ }];
1850
+ };
1851
+ readonly neq: {
1852
+ readonly description: "Not equal";
1853
+ readonly type: "string";
1854
+ readonly maxLength: 4096;
1855
+ };
1856
+ readonly inc: {
1857
+ readonly description: "In array";
1858
+ readonly type: "array";
1859
+ readonly items: {
1860
+ readonly type: "string";
1861
+ readonly maxLength: 4096;
1862
+ };
1863
+ };
1864
+ readonly ninc: {
1865
+ readonly description: "Not in array";
1866
+ readonly type: "array";
1867
+ readonly items: {
1868
+ readonly type: "string";
1869
+ readonly maxLength: 4096;
1870
+ };
1871
+ };
1872
+ readonly pre: {
1873
+ readonly description: "Starts with";
1874
+ readonly type: "string";
1875
+ readonly maxLength: 4096;
1876
+ };
1877
+ readonly suf: {
1878
+ readonly description: "Ends with";
1879
+ readonly type: "string";
1880
+ readonly maxLength: 4096;
1881
+ };
1882
+ readonly re: {
1883
+ readonly description: "Regex";
1884
+ readonly type: "string";
1885
+ readonly maxLength: 4096;
1886
+ };
1887
+ readonly gt: {
1888
+ readonly description: "Greater than";
1889
+ readonly type: "number";
1890
+ };
1891
+ readonly gte: {
1892
+ readonly description: "Greater than or equal to";
1893
+ readonly type: "number";
1894
+ };
1895
+ readonly lt: {
1896
+ readonly description: "Less than";
1897
+ readonly type: "number";
1898
+ };
1899
+ readonly lte: {
1900
+ readonly description: "Less than or equal to";
1901
+ readonly type: "number";
1811
1902
  };
1812
1903
  };
1813
- maxLength?: undefined;
1814
- })[];
1904
+ }];
1815
1905
  };
1816
1906
  };
1817
1907
  }];
@@ -1833,85 +1923,80 @@ export declare const headersSchema: {
1833
1923
  readonly enum: readonly ["host"];
1834
1924
  };
1835
1925
  readonly value: {
1836
- description: string;
1837
- anyOf: ({
1838
- description: string;
1839
- type: string;
1840
- maxLength: number;
1841
- additionalProperties?: undefined;
1842
- minProperties?: undefined;
1843
- properties?: undefined;
1844
- } | {
1845
- description: string;
1846
- type: string;
1847
- additionalProperties: boolean;
1848
- minProperties: number;
1849
- properties: {
1850
- eq: {
1851
- description: string;
1852
- anyOf: ({
1853
- type: string;
1854
- maxLength: number;
1855
- } | {
1856
- type: string;
1857
- maxLength?: undefined;
1858
- })[];
1859
- };
1860
- neq: {
1861
- description: string;
1862
- type: string;
1863
- maxLength: number;
1864
- };
1865
- inc: {
1866
- description: string;
1867
- type: string;
1868
- items: {
1869
- type: string;
1870
- maxLength: number;
1871
- };
1872
- };
1873
- ninc: {
1874
- description: string;
1875
- type: string;
1876
- items: {
1877
- type: string;
1878
- maxLength: number;
1879
- };
1880
- };
1881
- pre: {
1882
- description: string;
1883
- type: string;
1884
- maxLength: number;
1885
- };
1886
- suf: {
1887
- description: string;
1888
- type: string;
1889
- maxLength: number;
1890
- };
1891
- re: {
1892
- description: string;
1893
- type: string;
1894
- maxLength: number;
1895
- };
1896
- gt: {
1897
- description: string;
1898
- type: string;
1899
- };
1900
- gte: {
1901
- description: string;
1902
- type: string;
1903
- };
1904
- lt: {
1905
- description: string;
1906
- type: string;
1907
- };
1908
- lte: {
1909
- description: string;
1910
- type: string;
1926
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
1927
+ readonly anyOf: readonly [{
1928
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
1929
+ readonly type: "string";
1930
+ readonly maxLength: 4096;
1931
+ }, {
1932
+ readonly description: "A condition operation object";
1933
+ readonly type: "object";
1934
+ readonly additionalProperties: false;
1935
+ readonly minProperties: 1;
1936
+ readonly properties: {
1937
+ readonly eq: {
1938
+ readonly description: "Equal to";
1939
+ readonly anyOf: readonly [{
1940
+ readonly type: "string";
1941
+ readonly maxLength: 4096;
1942
+ }, {
1943
+ readonly type: "number";
1944
+ }];
1945
+ };
1946
+ readonly neq: {
1947
+ readonly description: "Not equal";
1948
+ readonly type: "string";
1949
+ readonly maxLength: 4096;
1950
+ };
1951
+ readonly inc: {
1952
+ readonly description: "In array";
1953
+ readonly type: "array";
1954
+ readonly items: {
1955
+ readonly type: "string";
1956
+ readonly maxLength: 4096;
1957
+ };
1958
+ };
1959
+ readonly ninc: {
1960
+ readonly description: "Not in array";
1961
+ readonly type: "array";
1962
+ readonly items: {
1963
+ readonly type: "string";
1964
+ readonly maxLength: 4096;
1965
+ };
1966
+ };
1967
+ readonly pre: {
1968
+ readonly description: "Starts with";
1969
+ readonly type: "string";
1970
+ readonly maxLength: 4096;
1971
+ };
1972
+ readonly suf: {
1973
+ readonly description: "Ends with";
1974
+ readonly type: "string";
1975
+ readonly maxLength: 4096;
1976
+ };
1977
+ readonly re: {
1978
+ readonly description: "Regex";
1979
+ readonly type: "string";
1980
+ readonly maxLength: 4096;
1981
+ };
1982
+ readonly gt: {
1983
+ readonly description: "Greater than";
1984
+ readonly type: "number";
1985
+ };
1986
+ readonly gte: {
1987
+ readonly description: "Greater than or equal to";
1988
+ readonly type: "number";
1989
+ };
1990
+ readonly lt: {
1991
+ readonly description: "Less than";
1992
+ readonly type: "number";
1993
+ };
1994
+ readonly lte: {
1995
+ readonly description: "Less than or equal to";
1996
+ readonly type: "number";
1911
1997
  };
1912
1998
  };
1913
- maxLength?: undefined;
1914
- })[];
1999
+ }];
1915
2000
  };
1916
2001
  };
1917
2002
  }, {
@@ -1930,85 +2015,80 @@ export declare const headersSchema: {
1930
2015
  readonly maxLength: 4096;
1931
2016
  };
1932
2017
  readonly value: {
1933
- description: string;
1934
- anyOf: ({
1935
- description: string;
1936
- type: string;
1937
- maxLength: number;
1938
- additionalProperties?: undefined;
1939
- minProperties?: undefined;
1940
- properties?: undefined;
1941
- } | {
1942
- description: string;
1943
- type: string;
1944
- additionalProperties: boolean;
1945
- minProperties: number;
1946
- properties: {
1947
- eq: {
1948
- description: string;
1949
- anyOf: ({
1950
- type: string;
1951
- maxLength: number;
1952
- } | {
1953
- type: string;
1954
- maxLength?: undefined;
1955
- })[];
1956
- };
1957
- neq: {
1958
- description: string;
1959
- type: string;
1960
- maxLength: number;
1961
- };
1962
- inc: {
1963
- description: string;
1964
- type: string;
1965
- items: {
1966
- type: string;
1967
- maxLength: number;
1968
- };
1969
- };
1970
- ninc: {
1971
- description: string;
1972
- type: string;
1973
- items: {
1974
- type: string;
1975
- maxLength: number;
1976
- };
1977
- };
1978
- pre: {
1979
- description: string;
1980
- type: string;
1981
- maxLength: number;
1982
- };
1983
- suf: {
1984
- description: string;
1985
- type: string;
1986
- maxLength: number;
1987
- };
1988
- re: {
1989
- description: string;
1990
- type: string;
1991
- maxLength: number;
1992
- };
1993
- gt: {
1994
- description: string;
1995
- type: string;
1996
- };
1997
- gte: {
1998
- description: string;
1999
- type: string;
2000
- };
2001
- lt: {
2002
- description: string;
2003
- type: string;
2004
- };
2005
- lte: {
2006
- description: string;
2007
- type: string;
2018
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
2019
+ readonly anyOf: readonly [{
2020
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
2021
+ readonly type: "string";
2022
+ readonly maxLength: 4096;
2023
+ }, {
2024
+ readonly description: "A condition operation object";
2025
+ readonly type: "object";
2026
+ readonly additionalProperties: false;
2027
+ readonly minProperties: 1;
2028
+ readonly properties: {
2029
+ readonly eq: {
2030
+ readonly description: "Equal to";
2031
+ readonly anyOf: readonly [{
2032
+ readonly type: "string";
2033
+ readonly maxLength: 4096;
2034
+ }, {
2035
+ readonly type: "number";
2036
+ }];
2037
+ };
2038
+ readonly neq: {
2039
+ readonly description: "Not equal";
2040
+ readonly type: "string";
2041
+ readonly maxLength: 4096;
2042
+ };
2043
+ readonly inc: {
2044
+ readonly description: "In array";
2045
+ readonly type: "array";
2046
+ readonly items: {
2047
+ readonly type: "string";
2048
+ readonly maxLength: 4096;
2049
+ };
2050
+ };
2051
+ readonly ninc: {
2052
+ readonly description: "Not in array";
2053
+ readonly type: "array";
2054
+ readonly items: {
2055
+ readonly type: "string";
2056
+ readonly maxLength: 4096;
2057
+ };
2058
+ };
2059
+ readonly pre: {
2060
+ readonly description: "Starts with";
2061
+ readonly type: "string";
2062
+ readonly maxLength: 4096;
2063
+ };
2064
+ readonly suf: {
2065
+ readonly description: "Ends with";
2066
+ readonly type: "string";
2067
+ readonly maxLength: 4096;
2068
+ };
2069
+ readonly re: {
2070
+ readonly description: "Regex";
2071
+ readonly type: "string";
2072
+ readonly maxLength: 4096;
2073
+ };
2074
+ readonly gt: {
2075
+ readonly description: "Greater than";
2076
+ readonly type: "number";
2077
+ };
2078
+ readonly gte: {
2079
+ readonly description: "Greater than or equal to";
2080
+ readonly type: "number";
2081
+ };
2082
+ readonly lt: {
2083
+ readonly description: "Less than";
2084
+ readonly type: "number";
2085
+ };
2086
+ readonly lte: {
2087
+ readonly description: "Less than or equal to";
2088
+ readonly type: "number";
2008
2089
  };
2009
2090
  };
2010
- maxLength?: undefined;
2011
- })[];
2091
+ }];
2012
2092
  };
2013
2093
  };
2014
2094
  }];