@remnawave/backend-contract 2.6.0 → 2.6.2
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.
- package/build/backend/commands/subscription-settings/get-subscription-settings.command.d.ts +47 -0
- package/build/backend/commands/subscription-settings/get-subscription-settings.command.d.ts.map +1 -1
- package/build/backend/commands/subscription-settings/update-subscription-settings.command.d.ts +84 -0
- package/build/backend/commands/subscription-settings/update-subscription-settings.command.d.ts.map +1 -1
- package/build/backend/commands/system/testers/test-srr-matcher.command.d.ts +55 -0
- package/build/backend/commands/system/testers/test-srr-matcher.command.d.ts.map +1 -1
- package/build/backend/models/response-rules/response-rule-modifications.schema.d.ts +6 -0
- package/build/backend/models/response-rules/response-rule-modifications.schema.d.ts.map +1 -1
- package/build/backend/models/response-rules/response-rule-modifications.schema.js +13 -0
- package/build/backend/models/response-rules/response-rule-settings.schema.d.ts +9 -0
- package/build/backend/models/response-rules/response-rule-settings.schema.d.ts.map +1 -0
- package/build/backend/models/response-rules/response-rule-settings.schema.js +20 -0
- package/build/backend/models/response-rules/response-rule.schema.d.ts +20 -0
- package/build/backend/models/response-rules/response-rule.schema.d.ts.map +1 -1
- package/build/backend/models/response-rules/response-rules-config.schema.d.ts +27 -0
- package/build/backend/models/response-rules/response-rules-config.schema.d.ts.map +1 -1
- package/build/backend/models/response-rules/response-rules-config.schema.js +2 -0
- package/build/backend/models/subscription-settings.schema.d.ts +37 -0
- package/build/backend/models/subscription-settings.schema.d.ts.map +1 -1
- package/build/frontend/models/response-rules/response-rule-modifications.schema.js +13 -0
- package/build/frontend/models/response-rules/response-rule-settings.schema.js +20 -0
- package/build/frontend/models/response-rules/response-rules-config.schema.js +2 -0
- package/package.json +1 -1
|
@@ -42,6 +42,13 @@ export declare namespace GetSubscriptionSettingsCommand {
|
|
|
42
42
|
version: z.ZodNativeEnum<{
|
|
43
43
|
readonly 1: "1";
|
|
44
44
|
}>;
|
|
45
|
+
settings: z.ZodOptional<z.ZodObject<{
|
|
46
|
+
disableSubscriptionAccessByPath: z.ZodOptional<z.ZodBoolean>;
|
|
47
|
+
}, "strip", z.ZodTypeAny, {
|
|
48
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
49
|
+
}, {
|
|
50
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
51
|
+
}>>;
|
|
45
52
|
rules: z.ZodArray<z.ZodObject<{
|
|
46
53
|
name: z.ZodString;
|
|
47
54
|
description: z.ZodOptional<z.ZodString>;
|
|
@@ -101,19 +108,25 @@ export declare namespace GetSubscriptionSettingsCommand {
|
|
|
101
108
|
value: string;
|
|
102
109
|
key: string;
|
|
103
110
|
}>, "many">>;
|
|
111
|
+
applyHeadersToEnd: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
|
|
104
112
|
subscriptionTemplate: z.ZodOptional<z.ZodString>;
|
|
113
|
+
ignoreHostXrayJsonTemplate: z.ZodOptional<z.ZodBoolean>;
|
|
105
114
|
}, "strip", z.ZodTypeAny, {
|
|
106
115
|
headers?: {
|
|
107
116
|
value: string;
|
|
108
117
|
key: string;
|
|
109
118
|
}[] | undefined;
|
|
119
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
110
120
|
subscriptionTemplate?: string | undefined;
|
|
121
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
111
122
|
}, {
|
|
112
123
|
headers?: {
|
|
113
124
|
value: string;
|
|
114
125
|
key: string;
|
|
115
126
|
}[] | undefined;
|
|
127
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
116
128
|
subscriptionTemplate?: string | undefined;
|
|
129
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
117
130
|
}>>;
|
|
118
131
|
}, "strip", z.ZodTypeAny, {
|
|
119
132
|
enabled: boolean;
|
|
@@ -132,7 +145,9 @@ export declare namespace GetSubscriptionSettingsCommand {
|
|
|
132
145
|
value: string;
|
|
133
146
|
key: string;
|
|
134
147
|
}[] | undefined;
|
|
148
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
135
149
|
subscriptionTemplate?: string | undefined;
|
|
150
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
136
151
|
} | undefined;
|
|
137
152
|
}, {
|
|
138
153
|
enabled: boolean;
|
|
@@ -151,7 +166,9 @@ export declare namespace GetSubscriptionSettingsCommand {
|
|
|
151
166
|
value: string;
|
|
152
167
|
key: string;
|
|
153
168
|
}[] | undefined;
|
|
169
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
154
170
|
subscriptionTemplate?: string | undefined;
|
|
171
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
155
172
|
} | undefined;
|
|
156
173
|
}>, "many">;
|
|
157
174
|
}, "strip", z.ZodTypeAny, {
|
|
@@ -173,9 +190,14 @@ export declare namespace GetSubscriptionSettingsCommand {
|
|
|
173
190
|
value: string;
|
|
174
191
|
key: string;
|
|
175
192
|
}[] | undefined;
|
|
193
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
176
194
|
subscriptionTemplate?: string | undefined;
|
|
195
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
177
196
|
} | undefined;
|
|
178
197
|
}[];
|
|
198
|
+
settings?: {
|
|
199
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
200
|
+
} | undefined;
|
|
179
201
|
}, {
|
|
180
202
|
version: "1";
|
|
181
203
|
rules: {
|
|
@@ -195,9 +217,14 @@ export declare namespace GetSubscriptionSettingsCommand {
|
|
|
195
217
|
value: string;
|
|
196
218
|
key: string;
|
|
197
219
|
}[] | undefined;
|
|
220
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
198
221
|
subscriptionTemplate?: string | undefined;
|
|
222
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
199
223
|
} | undefined;
|
|
200
224
|
}[];
|
|
225
|
+
settings?: {
|
|
226
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
227
|
+
} | undefined;
|
|
201
228
|
}>>;
|
|
202
229
|
hwidSettings: z.ZodNullable<z.ZodObject<{
|
|
203
230
|
enabled: z.ZodBoolean;
|
|
@@ -255,9 +282,14 @@ export declare namespace GetSubscriptionSettingsCommand {
|
|
|
255
282
|
value: string;
|
|
256
283
|
key: string;
|
|
257
284
|
}[] | undefined;
|
|
285
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
258
286
|
subscriptionTemplate?: string | undefined;
|
|
287
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
259
288
|
} | undefined;
|
|
260
289
|
}[];
|
|
290
|
+
settings?: {
|
|
291
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
292
|
+
} | undefined;
|
|
261
293
|
} | null;
|
|
262
294
|
hwidSettings: {
|
|
263
295
|
enabled: boolean;
|
|
@@ -305,9 +337,14 @@ export declare namespace GetSubscriptionSettingsCommand {
|
|
|
305
337
|
value: string;
|
|
306
338
|
key: string;
|
|
307
339
|
}[] | undefined;
|
|
340
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
308
341
|
subscriptionTemplate?: string | undefined;
|
|
342
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
309
343
|
} | undefined;
|
|
310
344
|
}[];
|
|
345
|
+
settings?: {
|
|
346
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
347
|
+
} | undefined;
|
|
311
348
|
} | null;
|
|
312
349
|
hwidSettings: {
|
|
313
350
|
enabled: boolean;
|
|
@@ -357,9 +394,14 @@ export declare namespace GetSubscriptionSettingsCommand {
|
|
|
357
394
|
value: string;
|
|
358
395
|
key: string;
|
|
359
396
|
}[] | undefined;
|
|
397
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
360
398
|
subscriptionTemplate?: string | undefined;
|
|
399
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
361
400
|
} | undefined;
|
|
362
401
|
}[];
|
|
402
|
+
settings?: {
|
|
403
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
404
|
+
} | undefined;
|
|
363
405
|
} | null;
|
|
364
406
|
hwidSettings: {
|
|
365
407
|
enabled: boolean;
|
|
@@ -409,9 +451,14 @@ export declare namespace GetSubscriptionSettingsCommand {
|
|
|
409
451
|
value: string;
|
|
410
452
|
key: string;
|
|
411
453
|
}[] | undefined;
|
|
454
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
412
455
|
subscriptionTemplate?: string | undefined;
|
|
456
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
413
457
|
} | undefined;
|
|
414
458
|
}[];
|
|
459
|
+
settings?: {
|
|
460
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
461
|
+
} | undefined;
|
|
415
462
|
} | null;
|
|
416
463
|
hwidSettings: {
|
|
417
464
|
enabled: boolean;
|
package/build/backend/commands/subscription-settings/get-subscription-settings.command.d.ts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"get-subscription-settings.command.d.ts","sourceRoot":"","sources":["../../../../commands/subscription-settings/get-subscription-settings.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,8BAA8B,CAAC;IACrC,MAAM,GAAG,+BAAqC,CAAC;IAC/C,MAAM,OAAO,+BAAM,CAAC;IAEpB,MAAM,eAAe,2CAI3B,CAAC;IAEK,MAAM,cAAc
|
|
1
|
+
{"version":3,"file":"get-subscription-settings.command.d.ts","sourceRoot":"","sources":["../../../../commands/subscription-settings/get-subscription-settings.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,8BAA8B,CAAC;IACrC,MAAM,GAAG,+BAAqC,CAAC;IAC/C,MAAM,OAAO,+BAAM,CAAC;IAEpB,MAAM,eAAe,2CAI3B,CAAC;IAEK,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}
|
package/build/backend/commands/subscription-settings/update-subscription-settings.command.d.ts
CHANGED
|
@@ -41,6 +41,13 @@ export declare namespace UpdateSubscriptionSettingsCommand {
|
|
|
41
41
|
version: z.ZodNativeEnum<{
|
|
42
42
|
readonly 1: "1";
|
|
43
43
|
}>;
|
|
44
|
+
settings: z.ZodOptional<z.ZodObject<{
|
|
45
|
+
disableSubscriptionAccessByPath: z.ZodOptional<z.ZodBoolean>;
|
|
46
|
+
}, "strip", z.ZodTypeAny, {
|
|
47
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
48
|
+
}, {
|
|
49
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
50
|
+
}>>;
|
|
44
51
|
rules: z.ZodArray<z.ZodObject<{
|
|
45
52
|
name: z.ZodString;
|
|
46
53
|
description: z.ZodOptional<z.ZodString>;
|
|
@@ -100,19 +107,25 @@ export declare namespace UpdateSubscriptionSettingsCommand {
|
|
|
100
107
|
value: string;
|
|
101
108
|
key: string;
|
|
102
109
|
}>, "many">>;
|
|
110
|
+
applyHeadersToEnd: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
|
|
103
111
|
subscriptionTemplate: z.ZodOptional<z.ZodString>;
|
|
112
|
+
ignoreHostXrayJsonTemplate: z.ZodOptional<z.ZodBoolean>;
|
|
104
113
|
}, "strip", z.ZodTypeAny, {
|
|
105
114
|
headers?: {
|
|
106
115
|
value: string;
|
|
107
116
|
key: string;
|
|
108
117
|
}[] | undefined;
|
|
118
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
109
119
|
subscriptionTemplate?: string | undefined;
|
|
120
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
110
121
|
}, {
|
|
111
122
|
headers?: {
|
|
112
123
|
value: string;
|
|
113
124
|
key: string;
|
|
114
125
|
}[] | undefined;
|
|
126
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
115
127
|
subscriptionTemplate?: string | undefined;
|
|
128
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
116
129
|
}>>;
|
|
117
130
|
}, "strip", z.ZodTypeAny, {
|
|
118
131
|
enabled: boolean;
|
|
@@ -131,7 +144,9 @@ export declare namespace UpdateSubscriptionSettingsCommand {
|
|
|
131
144
|
value: string;
|
|
132
145
|
key: string;
|
|
133
146
|
}[] | undefined;
|
|
147
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
134
148
|
subscriptionTemplate?: string | undefined;
|
|
149
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
135
150
|
} | undefined;
|
|
136
151
|
}, {
|
|
137
152
|
enabled: boolean;
|
|
@@ -150,7 +165,9 @@ export declare namespace UpdateSubscriptionSettingsCommand {
|
|
|
150
165
|
value: string;
|
|
151
166
|
key: string;
|
|
152
167
|
}[] | undefined;
|
|
168
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
153
169
|
subscriptionTemplate?: string | undefined;
|
|
170
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
154
171
|
} | undefined;
|
|
155
172
|
}>, "many">;
|
|
156
173
|
}, "strip", z.ZodTypeAny, {
|
|
@@ -172,9 +189,14 @@ export declare namespace UpdateSubscriptionSettingsCommand {
|
|
|
172
189
|
value: string;
|
|
173
190
|
key: string;
|
|
174
191
|
}[] | undefined;
|
|
192
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
175
193
|
subscriptionTemplate?: string | undefined;
|
|
194
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
176
195
|
} | undefined;
|
|
177
196
|
}[];
|
|
197
|
+
settings?: {
|
|
198
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
199
|
+
} | undefined;
|
|
178
200
|
}, {
|
|
179
201
|
version: "1";
|
|
180
202
|
rules: {
|
|
@@ -194,9 +216,14 @@ export declare namespace UpdateSubscriptionSettingsCommand {
|
|
|
194
216
|
value: string;
|
|
195
217
|
key: string;
|
|
196
218
|
}[] | undefined;
|
|
219
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
197
220
|
subscriptionTemplate?: string | undefined;
|
|
221
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
198
222
|
} | undefined;
|
|
199
223
|
}[];
|
|
224
|
+
settings?: {
|
|
225
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
226
|
+
} | undefined;
|
|
200
227
|
}>>;
|
|
201
228
|
hwidSettings: z.ZodOptional<z.ZodObject<{
|
|
202
229
|
enabled: z.ZodBoolean;
|
|
@@ -250,9 +277,14 @@ export declare namespace UpdateSubscriptionSettingsCommand {
|
|
|
250
277
|
value: string;
|
|
251
278
|
key: string;
|
|
252
279
|
}[] | undefined;
|
|
280
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
253
281
|
subscriptionTemplate?: string | undefined;
|
|
282
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
254
283
|
} | undefined;
|
|
255
284
|
}[];
|
|
285
|
+
settings?: {
|
|
286
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
287
|
+
} | undefined;
|
|
256
288
|
} | undefined;
|
|
257
289
|
hwidSettings?: {
|
|
258
290
|
enabled: boolean;
|
|
@@ -298,9 +330,14 @@ export declare namespace UpdateSubscriptionSettingsCommand {
|
|
|
298
330
|
value: string;
|
|
299
331
|
key: string;
|
|
300
332
|
}[] | undefined;
|
|
333
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
301
334
|
subscriptionTemplate?: string | undefined;
|
|
335
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
302
336
|
} | undefined;
|
|
303
337
|
}[];
|
|
338
|
+
settings?: {
|
|
339
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
340
|
+
} | undefined;
|
|
304
341
|
} | undefined;
|
|
305
342
|
hwidSettings?: {
|
|
306
343
|
enabled: boolean;
|
|
@@ -348,6 +385,13 @@ export declare namespace UpdateSubscriptionSettingsCommand {
|
|
|
348
385
|
version: z.ZodNativeEnum<{
|
|
349
386
|
readonly 1: "1";
|
|
350
387
|
}>;
|
|
388
|
+
settings: z.ZodOptional<z.ZodObject<{
|
|
389
|
+
disableSubscriptionAccessByPath: z.ZodOptional<z.ZodBoolean>;
|
|
390
|
+
}, "strip", z.ZodTypeAny, {
|
|
391
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
392
|
+
}, {
|
|
393
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
394
|
+
}>>;
|
|
351
395
|
rules: z.ZodArray<z.ZodObject<{
|
|
352
396
|
name: z.ZodString;
|
|
353
397
|
description: z.ZodOptional<z.ZodString>;
|
|
@@ -407,19 +451,25 @@ export declare namespace UpdateSubscriptionSettingsCommand {
|
|
|
407
451
|
value: string;
|
|
408
452
|
key: string;
|
|
409
453
|
}>, "many">>;
|
|
454
|
+
applyHeadersToEnd: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
|
|
410
455
|
subscriptionTemplate: z.ZodOptional<z.ZodString>;
|
|
456
|
+
ignoreHostXrayJsonTemplate: z.ZodOptional<z.ZodBoolean>;
|
|
411
457
|
}, "strip", z.ZodTypeAny, {
|
|
412
458
|
headers?: {
|
|
413
459
|
value: string;
|
|
414
460
|
key: string;
|
|
415
461
|
}[] | undefined;
|
|
462
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
416
463
|
subscriptionTemplate?: string | undefined;
|
|
464
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
417
465
|
}, {
|
|
418
466
|
headers?: {
|
|
419
467
|
value: string;
|
|
420
468
|
key: string;
|
|
421
469
|
}[] | undefined;
|
|
470
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
422
471
|
subscriptionTemplate?: string | undefined;
|
|
472
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
423
473
|
}>>;
|
|
424
474
|
}, "strip", z.ZodTypeAny, {
|
|
425
475
|
enabled: boolean;
|
|
@@ -438,7 +488,9 @@ export declare namespace UpdateSubscriptionSettingsCommand {
|
|
|
438
488
|
value: string;
|
|
439
489
|
key: string;
|
|
440
490
|
}[] | undefined;
|
|
491
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
441
492
|
subscriptionTemplate?: string | undefined;
|
|
493
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
442
494
|
} | undefined;
|
|
443
495
|
}, {
|
|
444
496
|
enabled: boolean;
|
|
@@ -457,7 +509,9 @@ export declare namespace UpdateSubscriptionSettingsCommand {
|
|
|
457
509
|
value: string;
|
|
458
510
|
key: string;
|
|
459
511
|
}[] | undefined;
|
|
512
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
460
513
|
subscriptionTemplate?: string | undefined;
|
|
514
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
461
515
|
} | undefined;
|
|
462
516
|
}>, "many">;
|
|
463
517
|
}, "strip", z.ZodTypeAny, {
|
|
@@ -479,9 +533,14 @@ export declare namespace UpdateSubscriptionSettingsCommand {
|
|
|
479
533
|
value: string;
|
|
480
534
|
key: string;
|
|
481
535
|
}[] | undefined;
|
|
536
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
482
537
|
subscriptionTemplate?: string | undefined;
|
|
538
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
483
539
|
} | undefined;
|
|
484
540
|
}[];
|
|
541
|
+
settings?: {
|
|
542
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
543
|
+
} | undefined;
|
|
485
544
|
}, {
|
|
486
545
|
version: "1";
|
|
487
546
|
rules: {
|
|
@@ -501,9 +560,14 @@ export declare namespace UpdateSubscriptionSettingsCommand {
|
|
|
501
560
|
value: string;
|
|
502
561
|
key: string;
|
|
503
562
|
}[] | undefined;
|
|
563
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
504
564
|
subscriptionTemplate?: string | undefined;
|
|
565
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
505
566
|
} | undefined;
|
|
506
567
|
}[];
|
|
568
|
+
settings?: {
|
|
569
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
570
|
+
} | undefined;
|
|
507
571
|
}>>;
|
|
508
572
|
hwidSettings: z.ZodNullable<z.ZodObject<{
|
|
509
573
|
enabled: z.ZodBoolean;
|
|
@@ -561,9 +625,14 @@ export declare namespace UpdateSubscriptionSettingsCommand {
|
|
|
561
625
|
value: string;
|
|
562
626
|
key: string;
|
|
563
627
|
}[] | undefined;
|
|
628
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
564
629
|
subscriptionTemplate?: string | undefined;
|
|
630
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
565
631
|
} | undefined;
|
|
566
632
|
}[];
|
|
633
|
+
settings?: {
|
|
634
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
635
|
+
} | undefined;
|
|
567
636
|
} | null;
|
|
568
637
|
hwidSettings: {
|
|
569
638
|
enabled: boolean;
|
|
@@ -611,9 +680,14 @@ export declare namespace UpdateSubscriptionSettingsCommand {
|
|
|
611
680
|
value: string;
|
|
612
681
|
key: string;
|
|
613
682
|
}[] | undefined;
|
|
683
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
614
684
|
subscriptionTemplate?: string | undefined;
|
|
685
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
615
686
|
} | undefined;
|
|
616
687
|
}[];
|
|
688
|
+
settings?: {
|
|
689
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
690
|
+
} | undefined;
|
|
617
691
|
} | null;
|
|
618
692
|
hwidSettings: {
|
|
619
693
|
enabled: boolean;
|
|
@@ -663,9 +737,14 @@ export declare namespace UpdateSubscriptionSettingsCommand {
|
|
|
663
737
|
value: string;
|
|
664
738
|
key: string;
|
|
665
739
|
}[] | undefined;
|
|
740
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
666
741
|
subscriptionTemplate?: string | undefined;
|
|
742
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
667
743
|
} | undefined;
|
|
668
744
|
}[];
|
|
745
|
+
settings?: {
|
|
746
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
747
|
+
} | undefined;
|
|
669
748
|
} | null;
|
|
670
749
|
hwidSettings: {
|
|
671
750
|
enabled: boolean;
|
|
@@ -715,9 +794,14 @@ export declare namespace UpdateSubscriptionSettingsCommand {
|
|
|
715
794
|
value: string;
|
|
716
795
|
key: string;
|
|
717
796
|
}[] | undefined;
|
|
797
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
718
798
|
subscriptionTemplate?: string | undefined;
|
|
799
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
719
800
|
} | undefined;
|
|
720
801
|
}[];
|
|
802
|
+
settings?: {
|
|
803
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
804
|
+
} | undefined;
|
|
721
805
|
} | null;
|
|
722
806
|
hwidSettings: {
|
|
723
807
|
enabled: boolean;
|
package/build/backend/commands/subscription-settings/update-subscription-settings.command.d.ts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"update-subscription-settings.command.d.ts","sourceRoot":"","sources":["../../../../commands/subscription-settings/update-subscription-settings.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,yBAAiB,iCAAiC,CAAC;IACxC,MAAM,GAAG,+BAAwC,CAAC;IAClD,MAAM,OAAO,+BAAM,CAAC;IAEpB,MAAM,eAAe,2CAI3B,CAAC;IAEK,MAAM,aAAa
|
|
1
|
+
{"version":3,"file":"update-subscription-settings.command.d.ts","sourceRoot":"","sources":["../../../../commands/subscription-settings/update-subscription-settings.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB,yBAAiB,iCAAiC,CAAC;IACxC,MAAM,GAAG,+BAAwC,CAAC;IAClD,MAAM,OAAO,+BAAM,CAAC;IAEpB,MAAM,eAAe,2CAI3B,CAAC;IAEK,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAoCxB,CAAC;IAEH,KAAY,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IAE7C,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}
|
|
@@ -8,6 +8,13 @@ export declare namespace TestSrrMatcherCommand {
|
|
|
8
8
|
version: z.ZodNativeEnum<{
|
|
9
9
|
readonly 1: "1";
|
|
10
10
|
}>;
|
|
11
|
+
settings: z.ZodOptional<z.ZodObject<{
|
|
12
|
+
disableSubscriptionAccessByPath: z.ZodOptional<z.ZodBoolean>;
|
|
13
|
+
}, "strip", z.ZodTypeAny, {
|
|
14
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
15
|
+
}, {
|
|
16
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
17
|
+
}>>;
|
|
11
18
|
rules: z.ZodArray<z.ZodObject<{
|
|
12
19
|
name: z.ZodString;
|
|
13
20
|
description: z.ZodOptional<z.ZodString>;
|
|
@@ -67,19 +74,25 @@ export declare namespace TestSrrMatcherCommand {
|
|
|
67
74
|
value: string;
|
|
68
75
|
key: string;
|
|
69
76
|
}>, "many">>;
|
|
77
|
+
applyHeadersToEnd: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
|
|
70
78
|
subscriptionTemplate: z.ZodOptional<z.ZodString>;
|
|
79
|
+
ignoreHostXrayJsonTemplate: z.ZodOptional<z.ZodBoolean>;
|
|
71
80
|
}, "strip", z.ZodTypeAny, {
|
|
72
81
|
headers?: {
|
|
73
82
|
value: string;
|
|
74
83
|
key: string;
|
|
75
84
|
}[] | undefined;
|
|
85
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
76
86
|
subscriptionTemplate?: string | undefined;
|
|
87
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
77
88
|
}, {
|
|
78
89
|
headers?: {
|
|
79
90
|
value: string;
|
|
80
91
|
key: string;
|
|
81
92
|
}[] | undefined;
|
|
93
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
82
94
|
subscriptionTemplate?: string | undefined;
|
|
95
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
83
96
|
}>>;
|
|
84
97
|
}, "strip", z.ZodTypeAny, {
|
|
85
98
|
enabled: boolean;
|
|
@@ -98,7 +111,9 @@ export declare namespace TestSrrMatcherCommand {
|
|
|
98
111
|
value: string;
|
|
99
112
|
key: string;
|
|
100
113
|
}[] | undefined;
|
|
114
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
101
115
|
subscriptionTemplate?: string | undefined;
|
|
116
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
102
117
|
} | undefined;
|
|
103
118
|
}, {
|
|
104
119
|
enabled: boolean;
|
|
@@ -117,7 +132,9 @@ export declare namespace TestSrrMatcherCommand {
|
|
|
117
132
|
value: string;
|
|
118
133
|
key: string;
|
|
119
134
|
}[] | undefined;
|
|
135
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
120
136
|
subscriptionTemplate?: string | undefined;
|
|
137
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
121
138
|
} | undefined;
|
|
122
139
|
}>, "many">;
|
|
123
140
|
}, "strip", z.ZodTypeAny, {
|
|
@@ -139,9 +156,14 @@ export declare namespace TestSrrMatcherCommand {
|
|
|
139
156
|
value: string;
|
|
140
157
|
key: string;
|
|
141
158
|
}[] | undefined;
|
|
159
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
142
160
|
subscriptionTemplate?: string | undefined;
|
|
161
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
143
162
|
} | undefined;
|
|
144
163
|
}[];
|
|
164
|
+
settings?: {
|
|
165
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
166
|
+
} | undefined;
|
|
145
167
|
}, {
|
|
146
168
|
version: "1";
|
|
147
169
|
rules: {
|
|
@@ -161,9 +183,14 @@ export declare namespace TestSrrMatcherCommand {
|
|
|
161
183
|
value: string;
|
|
162
184
|
key: string;
|
|
163
185
|
}[] | undefined;
|
|
186
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
164
187
|
subscriptionTemplate?: string | undefined;
|
|
188
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
165
189
|
} | undefined;
|
|
166
190
|
}[];
|
|
191
|
+
settings?: {
|
|
192
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
193
|
+
} | undefined;
|
|
167
194
|
}>;
|
|
168
195
|
}, "strip", z.ZodTypeAny, {
|
|
169
196
|
responseRules: {
|
|
@@ -185,9 +212,14 @@ export declare namespace TestSrrMatcherCommand {
|
|
|
185
212
|
value: string;
|
|
186
213
|
key: string;
|
|
187
214
|
}[] | undefined;
|
|
215
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
188
216
|
subscriptionTemplate?: string | undefined;
|
|
217
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
189
218
|
} | undefined;
|
|
190
219
|
}[];
|
|
220
|
+
settings?: {
|
|
221
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
222
|
+
} | undefined;
|
|
191
223
|
};
|
|
192
224
|
}, {
|
|
193
225
|
responseRules: {
|
|
@@ -209,9 +241,14 @@ export declare namespace TestSrrMatcherCommand {
|
|
|
209
241
|
value: string;
|
|
210
242
|
key: string;
|
|
211
243
|
}[] | undefined;
|
|
244
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
212
245
|
subscriptionTemplate?: string | undefined;
|
|
246
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
213
247
|
} | undefined;
|
|
214
248
|
}[];
|
|
249
|
+
settings?: {
|
|
250
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
251
|
+
} | undefined;
|
|
215
252
|
};
|
|
216
253
|
}>;
|
|
217
254
|
type Request = z.infer<typeof RequestSchema>;
|
|
@@ -290,19 +327,25 @@ export declare namespace TestSrrMatcherCommand {
|
|
|
290
327
|
value: string;
|
|
291
328
|
key: string;
|
|
292
329
|
}>, "many">>;
|
|
330
|
+
applyHeadersToEnd: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
|
|
293
331
|
subscriptionTemplate: z.ZodOptional<z.ZodString>;
|
|
332
|
+
ignoreHostXrayJsonTemplate: z.ZodOptional<z.ZodBoolean>;
|
|
294
333
|
}, "strip", z.ZodTypeAny, {
|
|
295
334
|
headers?: {
|
|
296
335
|
value: string;
|
|
297
336
|
key: string;
|
|
298
337
|
}[] | undefined;
|
|
338
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
299
339
|
subscriptionTemplate?: string | undefined;
|
|
340
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
300
341
|
}, {
|
|
301
342
|
headers?: {
|
|
302
343
|
value: string;
|
|
303
344
|
key: string;
|
|
304
345
|
}[] | undefined;
|
|
346
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
305
347
|
subscriptionTemplate?: string | undefined;
|
|
348
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
306
349
|
}>>;
|
|
307
350
|
}, "strip", z.ZodTypeAny, {
|
|
308
351
|
enabled: boolean;
|
|
@@ -321,7 +364,9 @@ export declare namespace TestSrrMatcherCommand {
|
|
|
321
364
|
value: string;
|
|
322
365
|
key: string;
|
|
323
366
|
}[] | undefined;
|
|
367
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
324
368
|
subscriptionTemplate?: string | undefined;
|
|
369
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
325
370
|
} | undefined;
|
|
326
371
|
}, {
|
|
327
372
|
enabled: boolean;
|
|
@@ -340,7 +385,9 @@ export declare namespace TestSrrMatcherCommand {
|
|
|
340
385
|
value: string;
|
|
341
386
|
key: string;
|
|
342
387
|
}[] | undefined;
|
|
388
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
343
389
|
subscriptionTemplate?: string | undefined;
|
|
390
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
344
391
|
} | undefined;
|
|
345
392
|
}>>;
|
|
346
393
|
inputHeaders: z.ZodRecord<z.ZodString, z.ZodString>;
|
|
@@ -365,7 +412,9 @@ export declare namespace TestSrrMatcherCommand {
|
|
|
365
412
|
value: string;
|
|
366
413
|
key: string;
|
|
367
414
|
}[] | undefined;
|
|
415
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
368
416
|
subscriptionTemplate?: string | undefined;
|
|
417
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
369
418
|
} | undefined;
|
|
370
419
|
} | null;
|
|
371
420
|
inputHeaders: Record<string, string>;
|
|
@@ -390,7 +439,9 @@ export declare namespace TestSrrMatcherCommand {
|
|
|
390
439
|
value: string;
|
|
391
440
|
key: string;
|
|
392
441
|
}[] | undefined;
|
|
442
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
393
443
|
subscriptionTemplate?: string | undefined;
|
|
444
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
394
445
|
} | undefined;
|
|
395
446
|
} | null;
|
|
396
447
|
inputHeaders: Record<string, string>;
|
|
@@ -417,7 +468,9 @@ export declare namespace TestSrrMatcherCommand {
|
|
|
417
468
|
value: string;
|
|
418
469
|
key: string;
|
|
419
470
|
}[] | undefined;
|
|
471
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
420
472
|
subscriptionTemplate?: string | undefined;
|
|
473
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
421
474
|
} | undefined;
|
|
422
475
|
} | null;
|
|
423
476
|
inputHeaders: Record<string, string>;
|
|
@@ -444,7 +497,9 @@ export declare namespace TestSrrMatcherCommand {
|
|
|
444
497
|
value: string;
|
|
445
498
|
key: string;
|
|
446
499
|
}[] | undefined;
|
|
500
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
447
501
|
subscriptionTemplate?: string | undefined;
|
|
502
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
448
503
|
} | undefined;
|
|
449
504
|
} | null;
|
|
450
505
|
inputHeaders: Record<string, string>;
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"test-srr-matcher.command.d.ts","sourceRoot":"","sources":["../../../../../commands/system/testers/test-srr-matcher.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,qBAAqB,CAAC;IAC5B,MAAM,GAAG,mCAAsC,CAAC;IAChD,MAAM,OAAO,mCAAM,CAAC;IAEpB,MAAM,eAAe,8CAI3B,CAAC;IACK,MAAM,aAAa
|
|
1
|
+
{"version":3,"file":"test-srr-matcher.command.d.ts","sourceRoot":"","sources":["../../../../../commands/system/testers/test-srr-matcher.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,qBAAqB,CAAC;IAC5B,MAAM,GAAG,mCAAsC,CAAC;IAChD,MAAM,OAAO,mCAAM,CAAC;IAEpB,MAAM,eAAe,8CAI3B,CAAC;IACK,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAExB,CAAC;IAEH,KAAY,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IAE7C,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAQzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}
|
|
@@ -10,18 +10,24 @@ export declare const ResponseRuleModificationsSchema: z.ZodOptional<z.ZodObject<
|
|
|
10
10
|
value: string;
|
|
11
11
|
key: string;
|
|
12
12
|
}>, "many">>;
|
|
13
|
+
applyHeadersToEnd: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
|
|
13
14
|
subscriptionTemplate: z.ZodOptional<z.ZodString>;
|
|
15
|
+
ignoreHostXrayJsonTemplate: z.ZodOptional<z.ZodBoolean>;
|
|
14
16
|
}, "strip", z.ZodTypeAny, {
|
|
15
17
|
headers?: {
|
|
16
18
|
value: string;
|
|
17
19
|
key: string;
|
|
18
20
|
}[] | undefined;
|
|
21
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
19
22
|
subscriptionTemplate?: string | undefined;
|
|
23
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
20
24
|
}, {
|
|
21
25
|
headers?: {
|
|
22
26
|
value: string;
|
|
23
27
|
key: string;
|
|
24
28
|
}[] | undefined;
|
|
29
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
25
30
|
subscriptionTemplate?: string | undefined;
|
|
31
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
26
32
|
}>>;
|
|
27
33
|
//# sourceMappingURL=response-rule-modifications.schema.d.ts.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"response-rule-modifications.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rule-modifications.schema.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,eAAO,MAAM,+BAA+B
|
|
1
|
+
{"version":3,"file":"response-rule-modifications.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rule-modifications.schema.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkGvC,CAAC"}
|
|
@@ -42,6 +42,13 @@ exports.ResponseRuleModificationsSchema = zod_1.default
|
|
|
42
42
|
markdownDescription: 'Array of headers to be added when the rule is matched.',
|
|
43
43
|
}))
|
|
44
44
|
.optional(),
|
|
45
|
+
applyHeadersToEnd: zod_1.default
|
|
46
|
+
.boolean()
|
|
47
|
+
.optional()
|
|
48
|
+
.describe(JSON.stringify({
|
|
49
|
+
markdownDescription: 'By default, headers are added when forming the response. In some cases, headers set in SRR may be overridden by headers from other parts of the system. If you set this flag to **true**, headers from SRR will be added at the very end, just before the response is sent. In this case, SRR headers may override headers from other sections.',
|
|
50
|
+
}))
|
|
51
|
+
.optional(),
|
|
45
52
|
subscriptionTemplate: zod_1.default
|
|
46
53
|
.string()
|
|
47
54
|
.min(1, 'Subscription template name is required')
|
|
@@ -49,6 +56,12 @@ exports.ResponseRuleModificationsSchema = zod_1.default
|
|
|
49
56
|
.describe(JSON.stringify({
|
|
50
57
|
markdownDescription: 'Override the subscription template with the given name. If not provided, the default subscription template will be used. If the template name is not found, the default subscription template for this type will be used. **This modification have higher priority than settings from External Squads.**',
|
|
51
58
|
})),
|
|
59
|
+
ignoreHostXrayJsonTemplate: zod_1.default
|
|
60
|
+
.boolean()
|
|
61
|
+
.optional()
|
|
62
|
+
.describe(JSON.stringify({
|
|
63
|
+
markdownDescription: "Each Host may have its own Xray Json Template. If you set this flag to **true**, the Xray Json Template defined by the SRR will be used. **The Host's Xray Json Template will be ignored.**",
|
|
64
|
+
})),
|
|
52
65
|
})
|
|
53
66
|
.optional()
|
|
54
67
|
.describe(JSON.stringify({
|
|
@@ -0,0 +1,9 @@
|
|
|
1
|
+
import z from 'zod';
|
|
2
|
+
export declare const ResponseRuleSettingsSchema: z.ZodOptional<z.ZodObject<{
|
|
3
|
+
disableSubscriptionAccessByPath: z.ZodOptional<z.ZodBoolean>;
|
|
4
|
+
}, "strip", z.ZodTypeAny, {
|
|
5
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
6
|
+
}, {
|
|
7
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
8
|
+
}>>;
|
|
9
|
+
//# sourceMappingURL=response-rule-settings.schema.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"response-rule-settings.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rule-settings.schema.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,eAAO,MAAM,0BAA0B;;;;;;GAiBlC,CAAC"}
|
|
@@ -0,0 +1,20 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
var __importDefault = (this && this.__importDefault) || function (mod) {
|
|
3
|
+
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
4
|
+
};
|
|
5
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
6
|
+
exports.ResponseRuleSettingsSchema = void 0;
|
|
7
|
+
const zod_1 = __importDefault(require("zod"));
|
|
8
|
+
exports.ResponseRuleSettingsSchema = zod_1.default
|
|
9
|
+
.object({
|
|
10
|
+
disableSubscriptionAccessByPath: zod_1.default
|
|
11
|
+
.boolean()
|
|
12
|
+
.optional()
|
|
13
|
+
.describe(JSON.stringify({
|
|
14
|
+
markdownDescription: "Usually, a user's subscription may also be available via additional paths such as **/json**, **/stash**, or **/mihomo**. If this flag is set to **true**, access via these additional paths will be disabled.",
|
|
15
|
+
})),
|
|
16
|
+
})
|
|
17
|
+
.optional()
|
|
18
|
+
.describe(JSON.stringify({
|
|
19
|
+
markdownDescription: 'Settings for the **response rules** config. Optional.',
|
|
20
|
+
}));
|
|
@@ -58,19 +58,25 @@ export declare const ResponseRuleSchemaBase: z.ZodObject<{
|
|
|
58
58
|
value: string;
|
|
59
59
|
key: string;
|
|
60
60
|
}>, "many">>;
|
|
61
|
+
applyHeadersToEnd: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
|
|
61
62
|
subscriptionTemplate: z.ZodOptional<z.ZodString>;
|
|
63
|
+
ignoreHostXrayJsonTemplate: z.ZodOptional<z.ZodBoolean>;
|
|
62
64
|
}, "strip", z.ZodTypeAny, {
|
|
63
65
|
headers?: {
|
|
64
66
|
value: string;
|
|
65
67
|
key: string;
|
|
66
68
|
}[] | undefined;
|
|
69
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
67
70
|
subscriptionTemplate?: string | undefined;
|
|
71
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
68
72
|
}, {
|
|
69
73
|
headers?: {
|
|
70
74
|
value: string;
|
|
71
75
|
key: string;
|
|
72
76
|
}[] | undefined;
|
|
77
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
73
78
|
subscriptionTemplate?: string | undefined;
|
|
79
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
74
80
|
}>>;
|
|
75
81
|
}, "strip", z.ZodTypeAny, {
|
|
76
82
|
enabled: boolean;
|
|
@@ -89,7 +95,9 @@ export declare const ResponseRuleSchemaBase: z.ZodObject<{
|
|
|
89
95
|
value: string;
|
|
90
96
|
key: string;
|
|
91
97
|
}[] | undefined;
|
|
98
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
92
99
|
subscriptionTemplate?: string | undefined;
|
|
100
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
93
101
|
} | undefined;
|
|
94
102
|
}, {
|
|
95
103
|
enabled: boolean;
|
|
@@ -108,7 +116,9 @@ export declare const ResponseRuleSchemaBase: z.ZodObject<{
|
|
|
108
116
|
value: string;
|
|
109
117
|
key: string;
|
|
110
118
|
}[] | undefined;
|
|
119
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
111
120
|
subscriptionTemplate?: string | undefined;
|
|
121
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
112
122
|
} | undefined;
|
|
113
123
|
}>;
|
|
114
124
|
export declare const ResponseRuleSchema: z.ZodObject<{
|
|
@@ -170,19 +180,25 @@ export declare const ResponseRuleSchema: z.ZodObject<{
|
|
|
170
180
|
value: string;
|
|
171
181
|
key: string;
|
|
172
182
|
}>, "many">>;
|
|
183
|
+
applyHeadersToEnd: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
|
|
173
184
|
subscriptionTemplate: z.ZodOptional<z.ZodString>;
|
|
185
|
+
ignoreHostXrayJsonTemplate: z.ZodOptional<z.ZodBoolean>;
|
|
174
186
|
}, "strip", z.ZodTypeAny, {
|
|
175
187
|
headers?: {
|
|
176
188
|
value: string;
|
|
177
189
|
key: string;
|
|
178
190
|
}[] | undefined;
|
|
191
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
179
192
|
subscriptionTemplate?: string | undefined;
|
|
193
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
180
194
|
}, {
|
|
181
195
|
headers?: {
|
|
182
196
|
value: string;
|
|
183
197
|
key: string;
|
|
184
198
|
}[] | undefined;
|
|
199
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
185
200
|
subscriptionTemplate?: string | undefined;
|
|
201
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
186
202
|
}>>;
|
|
187
203
|
}, "strip", z.ZodTypeAny, {
|
|
188
204
|
enabled: boolean;
|
|
@@ -201,7 +217,9 @@ export declare const ResponseRuleSchema: z.ZodObject<{
|
|
|
201
217
|
value: string;
|
|
202
218
|
key: string;
|
|
203
219
|
}[] | undefined;
|
|
220
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
204
221
|
subscriptionTemplate?: string | undefined;
|
|
222
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
205
223
|
} | undefined;
|
|
206
224
|
}, {
|
|
207
225
|
enabled: boolean;
|
|
@@ -220,7 +238,9 @@ export declare const ResponseRuleSchema: z.ZodObject<{
|
|
|
220
238
|
value: string;
|
|
221
239
|
key: string;
|
|
222
240
|
}[] | undefined;
|
|
241
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
223
242
|
subscriptionTemplate?: string | undefined;
|
|
243
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
224
244
|
} | undefined;
|
|
225
245
|
}>;
|
|
226
246
|
//# sourceMappingURL=response-rule.schema.d.ts.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"response-rule.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rule.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAexB,eAAO,MAAM,sBAAsB
|
|
1
|
+
{"version":3,"file":"response-rule.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rule.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAexB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgDjC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqB9B,CAAC"}
|
|
@@ -3,6 +3,13 @@ export declare const ResponseRulesConfigSchema: z.ZodObject<{
|
|
|
3
3
|
version: z.ZodNativeEnum<{
|
|
4
4
|
readonly 1: "1";
|
|
5
5
|
}>;
|
|
6
|
+
settings: z.ZodOptional<z.ZodObject<{
|
|
7
|
+
disableSubscriptionAccessByPath: z.ZodOptional<z.ZodBoolean>;
|
|
8
|
+
}, "strip", z.ZodTypeAny, {
|
|
9
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
10
|
+
}, {
|
|
11
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
12
|
+
}>>;
|
|
6
13
|
rules: z.ZodArray<z.ZodObject<{
|
|
7
14
|
name: z.ZodString;
|
|
8
15
|
description: z.ZodOptional<z.ZodString>;
|
|
@@ -62,19 +69,25 @@ export declare const ResponseRulesConfigSchema: z.ZodObject<{
|
|
|
62
69
|
value: string;
|
|
63
70
|
key: string;
|
|
64
71
|
}>, "many">>;
|
|
72
|
+
applyHeadersToEnd: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
|
|
65
73
|
subscriptionTemplate: z.ZodOptional<z.ZodString>;
|
|
74
|
+
ignoreHostXrayJsonTemplate: z.ZodOptional<z.ZodBoolean>;
|
|
66
75
|
}, "strip", z.ZodTypeAny, {
|
|
67
76
|
headers?: {
|
|
68
77
|
value: string;
|
|
69
78
|
key: string;
|
|
70
79
|
}[] | undefined;
|
|
80
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
71
81
|
subscriptionTemplate?: string | undefined;
|
|
82
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
72
83
|
}, {
|
|
73
84
|
headers?: {
|
|
74
85
|
value: string;
|
|
75
86
|
key: string;
|
|
76
87
|
}[] | undefined;
|
|
88
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
77
89
|
subscriptionTemplate?: string | undefined;
|
|
90
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
78
91
|
}>>;
|
|
79
92
|
}, "strip", z.ZodTypeAny, {
|
|
80
93
|
enabled: boolean;
|
|
@@ -93,7 +106,9 @@ export declare const ResponseRulesConfigSchema: z.ZodObject<{
|
|
|
93
106
|
value: string;
|
|
94
107
|
key: string;
|
|
95
108
|
}[] | undefined;
|
|
109
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
96
110
|
subscriptionTemplate?: string | undefined;
|
|
111
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
97
112
|
} | undefined;
|
|
98
113
|
}, {
|
|
99
114
|
enabled: boolean;
|
|
@@ -112,7 +127,9 @@ export declare const ResponseRulesConfigSchema: z.ZodObject<{
|
|
|
112
127
|
value: string;
|
|
113
128
|
key: string;
|
|
114
129
|
}[] | undefined;
|
|
130
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
115
131
|
subscriptionTemplate?: string | undefined;
|
|
132
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
116
133
|
} | undefined;
|
|
117
134
|
}>, "many">;
|
|
118
135
|
}, "strip", z.ZodTypeAny, {
|
|
@@ -134,9 +151,14 @@ export declare const ResponseRulesConfigSchema: z.ZodObject<{
|
|
|
134
151
|
value: string;
|
|
135
152
|
key: string;
|
|
136
153
|
}[] | undefined;
|
|
154
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
137
155
|
subscriptionTemplate?: string | undefined;
|
|
156
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
138
157
|
} | undefined;
|
|
139
158
|
}[];
|
|
159
|
+
settings?: {
|
|
160
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
161
|
+
} | undefined;
|
|
140
162
|
}, {
|
|
141
163
|
version: "1";
|
|
142
164
|
rules: {
|
|
@@ -156,8 +178,13 @@ export declare const ResponseRulesConfigSchema: z.ZodObject<{
|
|
|
156
178
|
value: string;
|
|
157
179
|
key: string;
|
|
158
180
|
}[] | undefined;
|
|
181
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
159
182
|
subscriptionTemplate?: string | undefined;
|
|
183
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
160
184
|
} | undefined;
|
|
161
185
|
}[];
|
|
186
|
+
settings?: {
|
|
187
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
188
|
+
} | undefined;
|
|
162
189
|
}>;
|
|
163
190
|
//# sourceMappingURL=response-rules-config.schema.d.ts.map
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"response-rules-config.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rules-config.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;
|
|
1
|
+
{"version":3,"file":"response-rules-config.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rules-config.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBpC,CAAC"}
|
|
@@ -2,6 +2,7 @@
|
|
|
2
2
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
3
|
exports.ResponseRulesConfigSchema = void 0;
|
|
4
4
|
const zod_1 = require("zod");
|
|
5
|
+
const response_rule_settings_schema_1 = require("./response-rule-settings.schema");
|
|
5
6
|
const response_rules_examples_1 = require("./response-rules-examples");
|
|
6
7
|
const constants_1 = require("../../constants");
|
|
7
8
|
const response_rule_schema_1 = require("./response-rule.schema");
|
|
@@ -10,6 +11,7 @@ exports.ResponseRulesConfigSchema = zod_1.z.object({
|
|
|
10
11
|
title: 'Response Rules Config Version',
|
|
11
12
|
markdownDescription: 'Version of the **response rules** config. Currently supported version is **1**.',
|
|
12
13
|
})),
|
|
14
|
+
settings: response_rule_settings_schema_1.ResponseRuleSettingsSchema,
|
|
13
15
|
rules: zod_1.z.array(response_rule_schema_1.ResponseRuleSchema).describe(JSON.stringify({
|
|
14
16
|
title: 'Response Rules',
|
|
15
17
|
markdownDescription: `Array of **response rules**. Rules are evaluated in order and the first rule that matches is applied. If no rule matches, request will be blocked by default.\n\n**Example:**\n\`\`\`json\n${JSON.stringify([response_rules_examples_1.EXAMPLES_SRR_BLANK_RULE], null, 2)}\n\`\`\``,
|
|
@@ -37,6 +37,13 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
|
|
|
37
37
|
version: z.ZodNativeEnum<{
|
|
38
38
|
readonly 1: "1";
|
|
39
39
|
}>;
|
|
40
|
+
settings: z.ZodOptional<z.ZodObject<{
|
|
41
|
+
disableSubscriptionAccessByPath: z.ZodOptional<z.ZodBoolean>;
|
|
42
|
+
}, "strip", z.ZodTypeAny, {
|
|
43
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
44
|
+
}, {
|
|
45
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
46
|
+
}>>;
|
|
40
47
|
rules: z.ZodArray<z.ZodObject<{
|
|
41
48
|
name: z.ZodString;
|
|
42
49
|
description: z.ZodOptional<z.ZodString>;
|
|
@@ -96,19 +103,25 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
|
|
|
96
103
|
value: string;
|
|
97
104
|
key: string;
|
|
98
105
|
}>, "many">>;
|
|
106
|
+
applyHeadersToEnd: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
|
|
99
107
|
subscriptionTemplate: z.ZodOptional<z.ZodString>;
|
|
108
|
+
ignoreHostXrayJsonTemplate: z.ZodOptional<z.ZodBoolean>;
|
|
100
109
|
}, "strip", z.ZodTypeAny, {
|
|
101
110
|
headers?: {
|
|
102
111
|
value: string;
|
|
103
112
|
key: string;
|
|
104
113
|
}[] | undefined;
|
|
114
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
105
115
|
subscriptionTemplate?: string | undefined;
|
|
116
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
106
117
|
}, {
|
|
107
118
|
headers?: {
|
|
108
119
|
value: string;
|
|
109
120
|
key: string;
|
|
110
121
|
}[] | undefined;
|
|
122
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
111
123
|
subscriptionTemplate?: string | undefined;
|
|
124
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
112
125
|
}>>;
|
|
113
126
|
}, "strip", z.ZodTypeAny, {
|
|
114
127
|
enabled: boolean;
|
|
@@ -127,7 +140,9 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
|
|
|
127
140
|
value: string;
|
|
128
141
|
key: string;
|
|
129
142
|
}[] | undefined;
|
|
143
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
130
144
|
subscriptionTemplate?: string | undefined;
|
|
145
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
131
146
|
} | undefined;
|
|
132
147
|
}, {
|
|
133
148
|
enabled: boolean;
|
|
@@ -146,7 +161,9 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
|
|
|
146
161
|
value: string;
|
|
147
162
|
key: string;
|
|
148
163
|
}[] | undefined;
|
|
164
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
149
165
|
subscriptionTemplate?: string | undefined;
|
|
166
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
150
167
|
} | undefined;
|
|
151
168
|
}>, "many">;
|
|
152
169
|
}, "strip", z.ZodTypeAny, {
|
|
@@ -168,9 +185,14 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
|
|
|
168
185
|
value: string;
|
|
169
186
|
key: string;
|
|
170
187
|
}[] | undefined;
|
|
188
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
171
189
|
subscriptionTemplate?: string | undefined;
|
|
190
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
172
191
|
} | undefined;
|
|
173
192
|
}[];
|
|
193
|
+
settings?: {
|
|
194
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
195
|
+
} | undefined;
|
|
174
196
|
}, {
|
|
175
197
|
version: "1";
|
|
176
198
|
rules: {
|
|
@@ -190,9 +212,14 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
|
|
|
190
212
|
value: string;
|
|
191
213
|
key: string;
|
|
192
214
|
}[] | undefined;
|
|
215
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
193
216
|
subscriptionTemplate?: string | undefined;
|
|
217
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
194
218
|
} | undefined;
|
|
195
219
|
}[];
|
|
220
|
+
settings?: {
|
|
221
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
222
|
+
} | undefined;
|
|
196
223
|
}>>;
|
|
197
224
|
hwidSettings: z.ZodNullable<z.ZodObject<{
|
|
198
225
|
enabled: z.ZodBoolean;
|
|
@@ -250,9 +277,14 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
|
|
|
250
277
|
value: string;
|
|
251
278
|
key: string;
|
|
252
279
|
}[] | undefined;
|
|
280
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
253
281
|
subscriptionTemplate?: string | undefined;
|
|
282
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
254
283
|
} | undefined;
|
|
255
284
|
}[];
|
|
285
|
+
settings?: {
|
|
286
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
287
|
+
} | undefined;
|
|
256
288
|
} | null;
|
|
257
289
|
hwidSettings: {
|
|
258
290
|
enabled: boolean;
|
|
@@ -300,9 +332,14 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
|
|
|
300
332
|
value: string;
|
|
301
333
|
key: string;
|
|
302
334
|
}[] | undefined;
|
|
335
|
+
applyHeadersToEnd?: boolean | undefined;
|
|
303
336
|
subscriptionTemplate?: string | undefined;
|
|
337
|
+
ignoreHostXrayJsonTemplate?: boolean | undefined;
|
|
304
338
|
} | undefined;
|
|
305
339
|
}[];
|
|
340
|
+
settings?: {
|
|
341
|
+
disableSubscriptionAccessByPath?: boolean | undefined;
|
|
342
|
+
} | undefined;
|
|
306
343
|
} | null;
|
|
307
344
|
hwidSettings: {
|
|
308
345
|
enabled: boolean;
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"subscription-settings.schema.d.ts","sourceRoot":"","sources":["../../../models/subscription-settings.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,0BAA0B
|
|
1
|
+
{"version":3,"file":"subscription-settings.schema.d.ts","sourceRoot":"","sources":["../../../models/subscription-settings.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCrC,CAAC"}
|
|
@@ -42,6 +42,13 @@ exports.ResponseRuleModificationsSchema = zod_1.default
|
|
|
42
42
|
markdownDescription: 'Array of headers to be added when the rule is matched.',
|
|
43
43
|
}))
|
|
44
44
|
.optional(),
|
|
45
|
+
applyHeadersToEnd: zod_1.default
|
|
46
|
+
.boolean()
|
|
47
|
+
.optional()
|
|
48
|
+
.describe(JSON.stringify({
|
|
49
|
+
markdownDescription: 'By default, headers are added when forming the response. In some cases, headers set in SRR may be overridden by headers from other parts of the system. If you set this flag to **true**, headers from SRR will be added at the very end, just before the response is sent. In this case, SRR headers may override headers from other sections.',
|
|
50
|
+
}))
|
|
51
|
+
.optional(),
|
|
45
52
|
subscriptionTemplate: zod_1.default
|
|
46
53
|
.string()
|
|
47
54
|
.min(1, 'Subscription template name is required')
|
|
@@ -49,6 +56,12 @@ exports.ResponseRuleModificationsSchema = zod_1.default
|
|
|
49
56
|
.describe(JSON.stringify({
|
|
50
57
|
markdownDescription: 'Override the subscription template with the given name. If not provided, the default subscription template will be used. If the template name is not found, the default subscription template for this type will be used. **This modification have higher priority than settings from External Squads.**',
|
|
51
58
|
})),
|
|
59
|
+
ignoreHostXrayJsonTemplate: zod_1.default
|
|
60
|
+
.boolean()
|
|
61
|
+
.optional()
|
|
62
|
+
.describe(JSON.stringify({
|
|
63
|
+
markdownDescription: "Each Host may have its own Xray Json Template. If you set this flag to **true**, the Xray Json Template defined by the SRR will be used. **The Host's Xray Json Template will be ignored.**",
|
|
64
|
+
})),
|
|
52
65
|
})
|
|
53
66
|
.optional()
|
|
54
67
|
.describe(JSON.stringify({
|
|
@@ -0,0 +1,20 @@
|
|
|
1
|
+
"use strict";
|
|
2
|
+
var __importDefault = (this && this.__importDefault) || function (mod) {
|
|
3
|
+
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
4
|
+
};
|
|
5
|
+
Object.defineProperty(exports, "__esModule", { value: true });
|
|
6
|
+
exports.ResponseRuleSettingsSchema = void 0;
|
|
7
|
+
const zod_1 = __importDefault(require("zod"));
|
|
8
|
+
exports.ResponseRuleSettingsSchema = zod_1.default
|
|
9
|
+
.object({
|
|
10
|
+
disableSubscriptionAccessByPath: zod_1.default
|
|
11
|
+
.boolean()
|
|
12
|
+
.optional()
|
|
13
|
+
.describe(JSON.stringify({
|
|
14
|
+
markdownDescription: "Usually, a user's subscription may also be available via additional paths such as **/json**, **/stash**, or **/mihomo**. If this flag is set to **true**, access via these additional paths will be disabled.",
|
|
15
|
+
})),
|
|
16
|
+
})
|
|
17
|
+
.optional()
|
|
18
|
+
.describe(JSON.stringify({
|
|
19
|
+
markdownDescription: 'Settings for the **response rules** config. Optional.',
|
|
20
|
+
}));
|
|
@@ -2,6 +2,7 @@
|
|
|
2
2
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
3
3
|
exports.ResponseRulesConfigSchema = void 0;
|
|
4
4
|
const zod_1 = require("zod");
|
|
5
|
+
const response_rule_settings_schema_1 = require("./response-rule-settings.schema");
|
|
5
6
|
const response_rules_examples_1 = require("./response-rules-examples");
|
|
6
7
|
const constants_1 = require("../../constants");
|
|
7
8
|
const response_rule_schema_1 = require("./response-rule.schema");
|
|
@@ -10,6 +11,7 @@ exports.ResponseRulesConfigSchema = zod_1.z.object({
|
|
|
10
11
|
title: 'Response Rules Config Version',
|
|
11
12
|
markdownDescription: 'Version of the **response rules** config. Currently supported version is **1**.',
|
|
12
13
|
})),
|
|
14
|
+
settings: response_rule_settings_schema_1.ResponseRuleSettingsSchema,
|
|
13
15
|
rules: zod_1.z.array(response_rule_schema_1.ResponseRuleSchema).describe(JSON.stringify({
|
|
14
16
|
title: 'Response Rules',
|
|
15
17
|
markdownDescription: `Array of **response rules**. Rules are evaluated in order and the first rule that matches is applied. If no rule matches, request will be blocked by default.\n\n**Example:**\n\`\`\`json\n${JSON.stringify([response_rules_examples_1.EXAMPLES_SRR_BLANK_RULE], null, 2)}\n\`\`\``,
|