@vercel/routing-utils 5.0.6 → 5.0.7

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 (2) hide show
  1. package/dist/schemas.d.ts +1232 -1322
  2. 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
- })[];
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
+ }];
40
36
  };
41
- neq: {
42
- description: string;
43
- type: string;
44
- maxLength: number;
37
+ readonly neq: {
38
+ readonly description: "Not equal";
39
+ readonly type: "string";
40
+ readonly maxLength: 4096;
45
41
  };
46
- inc: {
47
- description: string;
48
- type: string;
49
- items: {
50
- type: string;
51
- maxLength: number;
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
- })[];
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
+ }];
137
128
  };
138
- neq: {
139
- description: string;
140
- type: string;
141
- maxLength: number;
129
+ readonly neq: {
130
+ readonly description: "Not equal";
131
+ readonly type: "string";
132
+ readonly maxLength: 4096;
142
133
  };
143
- inc: {
144
- description: string;
145
- type: string;
146
- items: {
147
- type: string;
148
- maxLength: number;
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
  }];
@@ -771,85 +741,80 @@ export declare const rewritesSchema: {
771
741
  readonly enum: readonly ["host"];
772
742
  };
773
743
  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;
744
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
745
+ readonly anyOf: readonly [{
746
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
747
+ readonly type: "string";
748
+ readonly maxLength: 4096;
749
+ }, {
750
+ readonly description: "A condition operation object";
751
+ readonly type: "object";
752
+ readonly additionalProperties: false;
753
+ readonly minProperties: 1;
754
+ readonly properties: {
755
+ readonly eq: {
756
+ readonly description: "Equal to";
757
+ readonly anyOf: readonly [{
758
+ readonly type: "string";
759
+ readonly maxLength: 4096;
760
+ }, {
761
+ readonly type: "number";
762
+ }];
763
+ };
764
+ readonly neq: {
765
+ readonly description: "Not equal";
766
+ readonly type: "string";
767
+ readonly maxLength: 4096;
768
+ };
769
+ readonly inc: {
770
+ readonly description: "In array";
771
+ readonly type: "array";
772
+ readonly items: {
773
+ readonly type: "string";
774
+ readonly maxLength: 4096;
775
+ };
776
+ };
777
+ readonly ninc: {
778
+ readonly description: "Not in array";
779
+ readonly type: "array";
780
+ readonly items: {
781
+ readonly type: "string";
782
+ readonly maxLength: 4096;
783
+ };
784
+ };
785
+ readonly pre: {
786
+ readonly description: "Starts with";
787
+ readonly type: "string";
788
+ readonly maxLength: 4096;
789
+ };
790
+ readonly suf: {
791
+ readonly description: "Ends with";
792
+ readonly type: "string";
793
+ readonly maxLength: 4096;
794
+ };
795
+ readonly re: {
796
+ readonly description: "Regex";
797
+ readonly type: "string";
798
+ readonly maxLength: 4096;
799
+ };
800
+ readonly gt: {
801
+ readonly description: "Greater than";
802
+ readonly type: "number";
803
+ };
804
+ readonly gte: {
805
+ readonly description: "Greater than or equal to";
806
+ readonly type: "number";
807
+ };
808
+ readonly lt: {
809
+ readonly description: "Less than";
810
+ readonly type: "number";
811
+ };
812
+ readonly lte: {
813
+ readonly description: "Less than or equal to";
814
+ readonly type: "number";
849
815
  };
850
816
  };
851
- maxLength?: undefined;
852
- })[];
817
+ }];
853
818
  };
854
819
  };
855
820
  }, {
@@ -868,85 +833,80 @@ export declare const rewritesSchema: {
868
833
  readonly maxLength: 4096;
869
834
  };
870
835
  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;
836
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
837
+ readonly anyOf: readonly [{
838
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
839
+ readonly type: "string";
840
+ readonly maxLength: 4096;
841
+ }, {
842
+ readonly description: "A condition operation object";
843
+ readonly type: "object";
844
+ readonly additionalProperties: false;
845
+ readonly minProperties: 1;
846
+ readonly properties: {
847
+ readonly eq: {
848
+ readonly description: "Equal to";
849
+ readonly anyOf: readonly [{
850
+ readonly type: "string";
851
+ readonly maxLength: 4096;
852
+ }, {
853
+ readonly type: "number";
854
+ }];
855
+ };
856
+ readonly neq: {
857
+ readonly description: "Not equal";
858
+ readonly type: "string";
859
+ readonly maxLength: 4096;
860
+ };
861
+ readonly inc: {
862
+ readonly description: "In array";
863
+ readonly type: "array";
864
+ readonly items: {
865
+ readonly type: "string";
866
+ readonly maxLength: 4096;
867
+ };
868
+ };
869
+ readonly ninc: {
870
+ readonly description: "Not in array";
871
+ readonly type: "array";
872
+ readonly items: {
873
+ readonly type: "string";
874
+ readonly maxLength: 4096;
875
+ };
876
+ };
877
+ readonly pre: {
878
+ readonly description: "Starts with";
879
+ readonly type: "string";
880
+ readonly maxLength: 4096;
881
+ };
882
+ readonly suf: {
883
+ readonly description: "Ends with";
884
+ readonly type: "string";
885
+ readonly maxLength: 4096;
886
+ };
887
+ readonly re: {
888
+ readonly description: "Regex";
889
+ readonly type: "string";
890
+ readonly maxLength: 4096;
891
+ };
892
+ readonly gt: {
893
+ readonly description: "Greater than";
894
+ readonly type: "number";
895
+ };
896
+ readonly gte: {
897
+ readonly description: "Greater than or equal to";
898
+ readonly type: "number";
899
+ };
900
+ readonly lt: {
901
+ readonly description: "Less than";
902
+ readonly type: "number";
903
+ };
904
+ readonly lte: {
905
+ readonly description: "Less than or equal to";
906
+ readonly type: "number";
946
907
  };
947
908
  };
948
- maxLength?: undefined;
949
- })[];
909
+ }];
950
910
  };
951
911
  };
952
912
  }];
@@ -968,85 +928,80 @@ export declare const rewritesSchema: {
968
928
  readonly enum: readonly ["host"];
969
929
  };
970
930
  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;
931
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
932
+ readonly anyOf: readonly [{
933
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
934
+ readonly type: "string";
935
+ readonly maxLength: 4096;
936
+ }, {
937
+ readonly description: "A condition operation object";
938
+ readonly type: "object";
939
+ readonly additionalProperties: false;
940
+ readonly minProperties: 1;
941
+ readonly properties: {
942
+ readonly eq: {
943
+ readonly description: "Equal to";
944
+ readonly anyOf: readonly [{
945
+ readonly type: "string";
946
+ readonly maxLength: 4096;
947
+ }, {
948
+ readonly type: "number";
949
+ }];
950
+ };
951
+ readonly neq: {
952
+ readonly description: "Not equal";
953
+ readonly type: "string";
954
+ readonly maxLength: 4096;
955
+ };
956
+ readonly inc: {
957
+ readonly description: "In array";
958
+ readonly type: "array";
959
+ readonly items: {
960
+ readonly type: "string";
961
+ readonly maxLength: 4096;
962
+ };
963
+ };
964
+ readonly ninc: {
965
+ readonly description: "Not in array";
966
+ readonly type: "array";
967
+ readonly items: {
968
+ readonly type: "string";
969
+ readonly maxLength: 4096;
970
+ };
971
+ };
972
+ readonly pre: {
973
+ readonly description: "Starts with";
974
+ readonly type: "string";
975
+ readonly maxLength: 4096;
976
+ };
977
+ readonly suf: {
978
+ readonly description: "Ends with";
979
+ readonly type: "string";
980
+ readonly maxLength: 4096;
981
+ };
982
+ readonly re: {
983
+ readonly description: "Regex";
984
+ readonly type: "string";
985
+ readonly maxLength: 4096;
986
+ };
987
+ readonly gt: {
988
+ readonly description: "Greater than";
989
+ readonly type: "number";
990
+ };
991
+ readonly gte: {
992
+ readonly description: "Greater than or equal to";
993
+ readonly type: "number";
994
+ };
995
+ readonly lt: {
996
+ readonly description: "Less than";
997
+ readonly type: "number";
998
+ };
999
+ readonly lte: {
1000
+ readonly description: "Less than or equal to";
1001
+ readonly type: "number";
1046
1002
  };
1047
1003
  };
1048
- maxLength?: undefined;
1049
- })[];
1004
+ }];
1050
1005
  };
1051
1006
  };
1052
1007
  }, {
@@ -1065,85 +1020,80 @@ export declare const rewritesSchema: {
1065
1020
  readonly maxLength: 4096;
1066
1021
  };
1067
1022
  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;
1023
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
1024
+ readonly anyOf: readonly [{
1025
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
1026
+ readonly type: "string";
1027
+ readonly maxLength: 4096;
1028
+ }, {
1029
+ readonly description: "A condition operation object";
1030
+ readonly type: "object";
1031
+ readonly additionalProperties: false;
1032
+ readonly minProperties: 1;
1033
+ readonly properties: {
1034
+ readonly eq: {
1035
+ readonly description: "Equal to";
1036
+ readonly anyOf: readonly [{
1037
+ readonly type: "string";
1038
+ readonly maxLength: 4096;
1039
+ }, {
1040
+ readonly type: "number";
1041
+ }];
1042
+ };
1043
+ readonly neq: {
1044
+ readonly description: "Not equal";
1045
+ readonly type: "string";
1046
+ readonly maxLength: 4096;
1047
+ };
1048
+ readonly inc: {
1049
+ readonly description: "In array";
1050
+ readonly type: "array";
1051
+ readonly items: {
1052
+ readonly type: "string";
1053
+ readonly maxLength: 4096;
1054
+ };
1055
+ };
1056
+ readonly ninc: {
1057
+ readonly description: "Not in array";
1058
+ readonly type: "array";
1059
+ readonly items: {
1060
+ readonly type: "string";
1061
+ readonly maxLength: 4096;
1062
+ };
1063
+ };
1064
+ readonly pre: {
1065
+ readonly description: "Starts with";
1066
+ readonly type: "string";
1067
+ readonly maxLength: 4096;
1068
+ };
1069
+ readonly suf: {
1070
+ readonly description: "Ends with";
1071
+ readonly type: "string";
1072
+ readonly maxLength: 4096;
1073
+ };
1074
+ readonly re: {
1075
+ readonly description: "Regex";
1076
+ readonly type: "string";
1077
+ readonly maxLength: 4096;
1078
+ };
1079
+ readonly gt: {
1080
+ readonly description: "Greater than";
1081
+ readonly type: "number";
1082
+ };
1083
+ readonly gte: {
1084
+ readonly description: "Greater than or equal to";
1085
+ readonly type: "number";
1086
+ };
1087
+ readonly lt: {
1088
+ readonly description: "Less than";
1089
+ readonly type: "number";
1090
+ };
1091
+ readonly lte: {
1092
+ readonly description: "Less than or equal to";
1093
+ readonly type: "number";
1143
1094
  };
1144
1095
  };
1145
- maxLength?: undefined;
1146
- })[];
1096
+ }];
1147
1097
  };
1148
1098
  };
1149
1099
  }];
@@ -1205,85 +1155,80 @@ export declare const redirectsSchema: {
1205
1155
  readonly enum: readonly ["host"];
1206
1156
  };
1207
1157
  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;
1158
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
1159
+ readonly anyOf: readonly [{
1160
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
1161
+ readonly type: "string";
1162
+ readonly maxLength: 4096;
1163
+ }, {
1164
+ readonly description: "A condition operation object";
1165
+ readonly type: "object";
1166
+ readonly additionalProperties: false;
1167
+ readonly minProperties: 1;
1168
+ readonly properties: {
1169
+ readonly eq: {
1170
+ readonly description: "Equal to";
1171
+ readonly anyOf: readonly [{
1172
+ readonly type: "string";
1173
+ readonly maxLength: 4096;
1174
+ }, {
1175
+ readonly type: "number";
1176
+ }];
1177
+ };
1178
+ readonly neq: {
1179
+ readonly description: "Not equal";
1180
+ readonly type: "string";
1181
+ readonly maxLength: 4096;
1182
+ };
1183
+ readonly inc: {
1184
+ readonly description: "In array";
1185
+ readonly type: "array";
1186
+ readonly items: {
1187
+ readonly type: "string";
1188
+ readonly maxLength: 4096;
1189
+ };
1190
+ };
1191
+ readonly ninc: {
1192
+ readonly description: "Not in array";
1193
+ readonly type: "array";
1194
+ readonly items: {
1195
+ readonly type: "string";
1196
+ readonly maxLength: 4096;
1197
+ };
1198
+ };
1199
+ readonly pre: {
1200
+ readonly description: "Starts with";
1201
+ readonly type: "string";
1202
+ readonly maxLength: 4096;
1203
+ };
1204
+ readonly suf: {
1205
+ readonly description: "Ends with";
1206
+ readonly type: "string";
1207
+ readonly maxLength: 4096;
1208
+ };
1209
+ readonly re: {
1210
+ readonly description: "Regex";
1211
+ readonly type: "string";
1212
+ readonly maxLength: 4096;
1213
+ };
1214
+ readonly gt: {
1215
+ readonly description: "Greater than";
1216
+ readonly type: "number";
1217
+ };
1218
+ readonly gte: {
1219
+ readonly description: "Greater than or equal to";
1220
+ readonly type: "number";
1221
+ };
1222
+ readonly lt: {
1223
+ readonly description: "Less than";
1224
+ readonly type: "number";
1225
+ };
1226
+ readonly lte: {
1227
+ readonly description: "Less than or equal to";
1228
+ readonly type: "number";
1283
1229
  };
1284
1230
  };
1285
- maxLength?: undefined;
1286
- })[];
1231
+ }];
1287
1232
  };
1288
1233
  };
1289
1234
  }, {
@@ -1302,85 +1247,80 @@ export declare const redirectsSchema: {
1302
1247
  readonly maxLength: 4096;
1303
1248
  };
1304
1249
  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;
1250
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
1251
+ readonly anyOf: readonly [{
1252
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
1253
+ readonly type: "string";
1254
+ readonly maxLength: 4096;
1255
+ }, {
1256
+ readonly description: "A condition operation object";
1257
+ readonly type: "object";
1258
+ readonly additionalProperties: false;
1259
+ readonly minProperties: 1;
1260
+ readonly properties: {
1261
+ readonly eq: {
1262
+ readonly description: "Equal to";
1263
+ readonly anyOf: readonly [{
1264
+ readonly type: "string";
1265
+ readonly maxLength: 4096;
1266
+ }, {
1267
+ readonly type: "number";
1268
+ }];
1269
+ };
1270
+ readonly neq: {
1271
+ readonly description: "Not equal";
1272
+ readonly type: "string";
1273
+ readonly maxLength: 4096;
1274
+ };
1275
+ readonly inc: {
1276
+ readonly description: "In array";
1277
+ readonly type: "array";
1278
+ readonly items: {
1279
+ readonly type: "string";
1280
+ readonly maxLength: 4096;
1281
+ };
1282
+ };
1283
+ readonly ninc: {
1284
+ readonly description: "Not in array";
1285
+ readonly type: "array";
1286
+ readonly items: {
1287
+ readonly type: "string";
1288
+ readonly maxLength: 4096;
1289
+ };
1290
+ };
1291
+ readonly pre: {
1292
+ readonly description: "Starts with";
1293
+ readonly type: "string";
1294
+ readonly maxLength: 4096;
1295
+ };
1296
+ readonly suf: {
1297
+ readonly description: "Ends with";
1298
+ readonly type: "string";
1299
+ readonly maxLength: 4096;
1300
+ };
1301
+ readonly re: {
1302
+ readonly description: "Regex";
1303
+ readonly type: "string";
1304
+ readonly maxLength: 4096;
1305
+ };
1306
+ readonly gt: {
1307
+ readonly description: "Greater than";
1308
+ readonly type: "number";
1309
+ };
1310
+ readonly gte: {
1311
+ readonly description: "Greater than or equal to";
1312
+ readonly type: "number";
1313
+ };
1314
+ readonly lt: {
1315
+ readonly description: "Less than";
1316
+ readonly type: "number";
1317
+ };
1318
+ readonly lte: {
1319
+ readonly description: "Less than or equal to";
1320
+ readonly type: "number";
1380
1321
  };
1381
1322
  };
1382
- maxLength?: undefined;
1383
- })[];
1323
+ }];
1384
1324
  };
1385
1325
  };
1386
1326
  }];
@@ -1402,85 +1342,80 @@ export declare const redirectsSchema: {
1402
1342
  readonly enum: readonly ["host"];
1403
1343
  };
1404
1344
  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;
1345
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
1346
+ readonly anyOf: readonly [{
1347
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
1348
+ readonly type: "string";
1349
+ readonly maxLength: 4096;
1350
+ }, {
1351
+ readonly description: "A condition operation object";
1352
+ readonly type: "object";
1353
+ readonly additionalProperties: false;
1354
+ readonly minProperties: 1;
1355
+ readonly properties: {
1356
+ readonly eq: {
1357
+ readonly description: "Equal to";
1358
+ readonly anyOf: readonly [{
1359
+ readonly type: "string";
1360
+ readonly maxLength: 4096;
1361
+ }, {
1362
+ readonly type: "number";
1363
+ }];
1364
+ };
1365
+ readonly neq: {
1366
+ readonly description: "Not equal";
1367
+ readonly type: "string";
1368
+ readonly maxLength: 4096;
1369
+ };
1370
+ readonly inc: {
1371
+ readonly description: "In array";
1372
+ readonly type: "array";
1373
+ readonly items: {
1374
+ readonly type: "string";
1375
+ readonly maxLength: 4096;
1376
+ };
1377
+ };
1378
+ readonly ninc: {
1379
+ readonly description: "Not in array";
1380
+ readonly type: "array";
1381
+ readonly items: {
1382
+ readonly type: "string";
1383
+ readonly maxLength: 4096;
1384
+ };
1385
+ };
1386
+ readonly pre: {
1387
+ readonly description: "Starts with";
1388
+ readonly type: "string";
1389
+ readonly maxLength: 4096;
1390
+ };
1391
+ readonly suf: {
1392
+ readonly description: "Ends with";
1393
+ readonly type: "string";
1394
+ readonly maxLength: 4096;
1395
+ };
1396
+ readonly re: {
1397
+ readonly description: "Regex";
1398
+ readonly type: "string";
1399
+ readonly maxLength: 4096;
1400
+ };
1401
+ readonly gt: {
1402
+ readonly description: "Greater than";
1403
+ readonly type: "number";
1404
+ };
1405
+ readonly gte: {
1406
+ readonly description: "Greater than or equal to";
1407
+ readonly type: "number";
1408
+ };
1409
+ readonly lt: {
1410
+ readonly description: "Less than";
1411
+ readonly type: "number";
1412
+ };
1413
+ readonly lte: {
1414
+ readonly description: "Less than or equal to";
1415
+ readonly type: "number";
1480
1416
  };
1481
1417
  };
1482
- maxLength?: undefined;
1483
- })[];
1418
+ }];
1484
1419
  };
1485
1420
  };
1486
1421
  }, {
@@ -1499,85 +1434,80 @@ export declare const redirectsSchema: {
1499
1434
  readonly maxLength: 4096;
1500
1435
  };
1501
1436
  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;
1437
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
1438
+ readonly anyOf: readonly [{
1439
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
1440
+ readonly type: "string";
1441
+ readonly maxLength: 4096;
1442
+ }, {
1443
+ readonly description: "A condition operation object";
1444
+ readonly type: "object";
1445
+ readonly additionalProperties: false;
1446
+ readonly minProperties: 1;
1447
+ readonly properties: {
1448
+ readonly eq: {
1449
+ readonly description: "Equal to";
1450
+ readonly anyOf: readonly [{
1451
+ readonly type: "string";
1452
+ readonly maxLength: 4096;
1453
+ }, {
1454
+ readonly type: "number";
1455
+ }];
1456
+ };
1457
+ readonly neq: {
1458
+ readonly description: "Not equal";
1459
+ readonly type: "string";
1460
+ readonly maxLength: 4096;
1461
+ };
1462
+ readonly inc: {
1463
+ readonly description: "In array";
1464
+ readonly type: "array";
1465
+ readonly items: {
1466
+ readonly type: "string";
1467
+ readonly maxLength: 4096;
1468
+ };
1469
+ };
1470
+ readonly ninc: {
1471
+ readonly description: "Not in array";
1472
+ readonly type: "array";
1473
+ readonly items: {
1474
+ readonly type: "string";
1475
+ readonly maxLength: 4096;
1476
+ };
1477
+ };
1478
+ readonly pre: {
1479
+ readonly description: "Starts with";
1480
+ readonly type: "string";
1481
+ readonly maxLength: 4096;
1482
+ };
1483
+ readonly suf: {
1484
+ readonly description: "Ends with";
1485
+ readonly type: "string";
1486
+ readonly maxLength: 4096;
1487
+ };
1488
+ readonly re: {
1489
+ readonly description: "Regex";
1490
+ readonly type: "string";
1491
+ readonly maxLength: 4096;
1492
+ };
1493
+ readonly gt: {
1494
+ readonly description: "Greater than";
1495
+ readonly type: "number";
1496
+ };
1497
+ readonly gte: {
1498
+ readonly description: "Greater than or equal to";
1499
+ readonly type: "number";
1500
+ };
1501
+ readonly lt: {
1502
+ readonly description: "Less than";
1503
+ readonly type: "number";
1504
+ };
1505
+ readonly lte: {
1506
+ readonly description: "Less than or equal to";
1507
+ readonly type: "number";
1577
1508
  };
1578
1509
  };
1579
- maxLength?: undefined;
1580
- })[];
1510
+ }];
1581
1511
  };
1582
1512
  };
1583
1513
  }];
@@ -1636,85 +1566,80 @@ export declare const headersSchema: {
1636
1566
  readonly enum: readonly ["host"];
1637
1567
  };
1638
1568
  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;
1569
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
1570
+ readonly anyOf: readonly [{
1571
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
1572
+ readonly type: "string";
1573
+ readonly maxLength: 4096;
1574
+ }, {
1575
+ readonly description: "A condition operation object";
1576
+ readonly type: "object";
1577
+ readonly additionalProperties: false;
1578
+ readonly minProperties: 1;
1579
+ readonly properties: {
1580
+ readonly eq: {
1581
+ readonly description: "Equal to";
1582
+ readonly anyOf: readonly [{
1583
+ readonly type: "string";
1584
+ readonly maxLength: 4096;
1585
+ }, {
1586
+ readonly type: "number";
1587
+ }];
1588
+ };
1589
+ readonly neq: {
1590
+ readonly description: "Not equal";
1591
+ readonly type: "string";
1592
+ readonly maxLength: 4096;
1593
+ };
1594
+ readonly inc: {
1595
+ readonly description: "In array";
1596
+ readonly type: "array";
1597
+ readonly items: {
1598
+ readonly type: "string";
1599
+ readonly maxLength: 4096;
1600
+ };
1601
+ };
1602
+ readonly ninc: {
1603
+ readonly description: "Not in array";
1604
+ readonly type: "array";
1605
+ readonly items: {
1606
+ readonly type: "string";
1607
+ readonly maxLength: 4096;
1608
+ };
1609
+ };
1610
+ readonly pre: {
1611
+ readonly description: "Starts with";
1612
+ readonly type: "string";
1613
+ readonly maxLength: 4096;
1614
+ };
1615
+ readonly suf: {
1616
+ readonly description: "Ends with";
1617
+ readonly type: "string";
1618
+ readonly maxLength: 4096;
1619
+ };
1620
+ readonly re: {
1621
+ readonly description: "Regex";
1622
+ readonly type: "string";
1623
+ readonly maxLength: 4096;
1624
+ };
1625
+ readonly gt: {
1626
+ readonly description: "Greater than";
1627
+ readonly type: "number";
1628
+ };
1629
+ readonly gte: {
1630
+ readonly description: "Greater than or equal to";
1631
+ readonly type: "number";
1632
+ };
1633
+ readonly lt: {
1634
+ readonly description: "Less than";
1635
+ readonly type: "number";
1636
+ };
1637
+ readonly lte: {
1638
+ readonly description: "Less than or equal to";
1639
+ readonly type: "number";
1714
1640
  };
1715
1641
  };
1716
- maxLength?: undefined;
1717
- })[];
1642
+ }];
1718
1643
  };
1719
1644
  };
1720
1645
  }, {
@@ -1733,85 +1658,80 @@ export declare const headersSchema: {
1733
1658
  readonly maxLength: 4096;
1734
1659
  };
1735
1660
  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;
1661
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
1662
+ readonly anyOf: readonly [{
1663
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
1664
+ readonly type: "string";
1665
+ readonly maxLength: 4096;
1666
+ }, {
1667
+ readonly description: "A condition operation object";
1668
+ readonly type: "object";
1669
+ readonly additionalProperties: false;
1670
+ readonly minProperties: 1;
1671
+ readonly properties: {
1672
+ readonly eq: {
1673
+ readonly description: "Equal to";
1674
+ readonly anyOf: readonly [{
1675
+ readonly type: "string";
1676
+ readonly maxLength: 4096;
1677
+ }, {
1678
+ readonly type: "number";
1679
+ }];
1680
+ };
1681
+ readonly neq: {
1682
+ readonly description: "Not equal";
1683
+ readonly type: "string";
1684
+ readonly maxLength: 4096;
1685
+ };
1686
+ readonly inc: {
1687
+ readonly description: "In array";
1688
+ readonly type: "array";
1689
+ readonly items: {
1690
+ readonly type: "string";
1691
+ readonly maxLength: 4096;
1692
+ };
1693
+ };
1694
+ readonly ninc: {
1695
+ readonly description: "Not in array";
1696
+ readonly type: "array";
1697
+ readonly items: {
1698
+ readonly type: "string";
1699
+ readonly maxLength: 4096;
1700
+ };
1701
+ };
1702
+ readonly pre: {
1703
+ readonly description: "Starts with";
1704
+ readonly type: "string";
1705
+ readonly maxLength: 4096;
1706
+ };
1707
+ readonly suf: {
1708
+ readonly description: "Ends with";
1709
+ readonly type: "string";
1710
+ readonly maxLength: 4096;
1711
+ };
1712
+ readonly re: {
1713
+ readonly description: "Regex";
1714
+ readonly type: "string";
1715
+ readonly maxLength: 4096;
1716
+ };
1717
+ readonly gt: {
1718
+ readonly description: "Greater than";
1719
+ readonly type: "number";
1720
+ };
1721
+ readonly gte: {
1722
+ readonly description: "Greater than or equal to";
1723
+ readonly type: "number";
1724
+ };
1725
+ readonly lt: {
1726
+ readonly description: "Less than";
1727
+ readonly type: "number";
1728
+ };
1729
+ readonly lte: {
1730
+ readonly description: "Less than or equal to";
1731
+ readonly type: "number";
1811
1732
  };
1812
1733
  };
1813
- maxLength?: undefined;
1814
- })[];
1734
+ }];
1815
1735
  };
1816
1736
  };
1817
1737
  }];
@@ -1833,85 +1753,80 @@ export declare const headersSchema: {
1833
1753
  readonly enum: readonly ["host"];
1834
1754
  };
1835
1755
  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;
1756
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
1757
+ readonly anyOf: readonly [{
1758
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
1759
+ readonly type: "string";
1760
+ readonly maxLength: 4096;
1761
+ }, {
1762
+ readonly description: "A condition operation object";
1763
+ readonly type: "object";
1764
+ readonly additionalProperties: false;
1765
+ readonly minProperties: 1;
1766
+ readonly properties: {
1767
+ readonly eq: {
1768
+ readonly description: "Equal to";
1769
+ readonly anyOf: readonly [{
1770
+ readonly type: "string";
1771
+ readonly maxLength: 4096;
1772
+ }, {
1773
+ readonly type: "number";
1774
+ }];
1775
+ };
1776
+ readonly neq: {
1777
+ readonly description: "Not equal";
1778
+ readonly type: "string";
1779
+ readonly maxLength: 4096;
1780
+ };
1781
+ readonly inc: {
1782
+ readonly description: "In array";
1783
+ readonly type: "array";
1784
+ readonly items: {
1785
+ readonly type: "string";
1786
+ readonly maxLength: 4096;
1787
+ };
1788
+ };
1789
+ readonly ninc: {
1790
+ readonly description: "Not in array";
1791
+ readonly type: "array";
1792
+ readonly items: {
1793
+ readonly type: "string";
1794
+ readonly maxLength: 4096;
1795
+ };
1796
+ };
1797
+ readonly pre: {
1798
+ readonly description: "Starts with";
1799
+ readonly type: "string";
1800
+ readonly maxLength: 4096;
1801
+ };
1802
+ readonly suf: {
1803
+ readonly description: "Ends with";
1804
+ readonly type: "string";
1805
+ readonly maxLength: 4096;
1806
+ };
1807
+ readonly re: {
1808
+ readonly description: "Regex";
1809
+ readonly type: "string";
1810
+ readonly maxLength: 4096;
1811
+ };
1812
+ readonly gt: {
1813
+ readonly description: "Greater than";
1814
+ readonly type: "number";
1815
+ };
1816
+ readonly gte: {
1817
+ readonly description: "Greater than or equal to";
1818
+ readonly type: "number";
1819
+ };
1820
+ readonly lt: {
1821
+ readonly description: "Less than";
1822
+ readonly type: "number";
1823
+ };
1824
+ readonly lte: {
1825
+ readonly description: "Less than or equal to";
1826
+ readonly type: "number";
1911
1827
  };
1912
1828
  };
1913
- maxLength?: undefined;
1914
- })[];
1829
+ }];
1915
1830
  };
1916
1831
  };
1917
1832
  }, {
@@ -1930,85 +1845,80 @@ export declare const headersSchema: {
1930
1845
  readonly maxLength: 4096;
1931
1846
  };
1932
1847
  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;
1848
+ readonly description: "A value to match against. Can be a string (regex) or a condition operation object";
1849
+ readonly anyOf: readonly [{
1850
+ readonly description: "A regular expression used to match thev value. Named groups can be used in the destination.";
1851
+ readonly type: "string";
1852
+ readonly maxLength: 4096;
1853
+ }, {
1854
+ readonly description: "A condition operation object";
1855
+ readonly type: "object";
1856
+ readonly additionalProperties: false;
1857
+ readonly minProperties: 1;
1858
+ readonly properties: {
1859
+ readonly eq: {
1860
+ readonly description: "Equal to";
1861
+ readonly anyOf: readonly [{
1862
+ readonly type: "string";
1863
+ readonly maxLength: 4096;
1864
+ }, {
1865
+ readonly type: "number";
1866
+ }];
1867
+ };
1868
+ readonly neq: {
1869
+ readonly description: "Not equal";
1870
+ readonly type: "string";
1871
+ readonly maxLength: 4096;
1872
+ };
1873
+ readonly inc: {
1874
+ readonly description: "In array";
1875
+ readonly type: "array";
1876
+ readonly items: {
1877
+ readonly type: "string";
1878
+ readonly maxLength: 4096;
1879
+ };
1880
+ };
1881
+ readonly ninc: {
1882
+ readonly description: "Not in array";
1883
+ readonly type: "array";
1884
+ readonly items: {
1885
+ readonly type: "string";
1886
+ readonly maxLength: 4096;
1887
+ };
1888
+ };
1889
+ readonly pre: {
1890
+ readonly description: "Starts with";
1891
+ readonly type: "string";
1892
+ readonly maxLength: 4096;
1893
+ };
1894
+ readonly suf: {
1895
+ readonly description: "Ends with";
1896
+ readonly type: "string";
1897
+ readonly maxLength: 4096;
1898
+ };
1899
+ readonly re: {
1900
+ readonly description: "Regex";
1901
+ readonly type: "string";
1902
+ readonly maxLength: 4096;
1903
+ };
1904
+ readonly gt: {
1905
+ readonly description: "Greater than";
1906
+ readonly type: "number";
1907
+ };
1908
+ readonly gte: {
1909
+ readonly description: "Greater than or equal to";
1910
+ readonly type: "number";
1911
+ };
1912
+ readonly lt: {
1913
+ readonly description: "Less than";
1914
+ readonly type: "number";
1915
+ };
1916
+ readonly lte: {
1917
+ readonly description: "Less than or equal to";
1918
+ readonly type: "number";
2008
1919
  };
2009
1920
  };
2010
- maxLength?: undefined;
2011
- })[];
1921
+ }];
2012
1922
  };
2013
1923
  };
2014
1924
  }];