@remnawave/backend-contract 2.1.76 → 2.1.77

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 (44) hide show
  1. package/build/backend/commands/subscription/get-subscription-by-short-uuid-by-client-type.command.d.ts +2 -3
  2. package/build/backend/commands/subscription/get-subscription-by-short-uuid-by-client-type.command.d.ts.map +1 -1
  3. package/build/backend/commands/subscription-settings/get-subscription-settings.command.d.ts +242 -0
  4. package/build/backend/commands/subscription-settings/get-subscription-settings.command.d.ts.map +1 -1
  5. package/build/backend/commands/subscription-settings/update-subscription-settings.command.d.ts +440 -0
  6. package/build/backend/commands/subscription-settings/update-subscription-settings.command.d.ts.map +1 -1
  7. package/build/backend/commands/subscription-settings/update-subscription-settings.command.js +2 -1
  8. package/build/backend/commands/subscription-template/get-template.command.d.ts +14 -14
  9. package/build/backend/commands/subscription-template/update-template.command.d.ts +14 -14
  10. package/build/backend/commands/subscriptions/get-by/get-raw-subscription-by-short-uuid.command.d.ts +4 -4
  11. package/build/backend/constants/response-rules/response-rules.contants.d.ts +26 -19
  12. package/build/backend/constants/response-rules/response-rules.contants.d.ts.map +1 -1
  13. package/build/backend/constants/response-rules/response-rules.contants.js +17 -16
  14. package/build/backend/constants/subscription-template/template-type/request-template-type.constant.d.ts +1 -2
  15. package/build/backend/constants/subscription-template/template-type/request-template-type.constant.d.ts.map +1 -1
  16. package/build/backend/constants/subscription-template/template-type/request-template-type.constant.js +0 -1
  17. package/build/backend/constants/subscription-template/template-type/template-type.constant.d.ts +5 -5
  18. package/build/backend/constants/subscription-template/template-type/template-type.constant.d.ts.map +1 -1
  19. package/build/backend/constants/subscription-template/template-type/template-type.constant.js +4 -4
  20. package/build/backend/models/response-rules/index.d.ts +1 -0
  21. package/build/backend/models/response-rules/index.d.ts.map +1 -1
  22. package/build/backend/models/response-rules/index.js +1 -0
  23. package/build/backend/models/response-rules/response-rule-condition.schema.d.ts +29 -0
  24. package/build/backend/models/response-rules/response-rule-condition.schema.d.ts.map +1 -0
  25. package/build/backend/models/response-rules/response-rule-condition.schema.js +29 -0
  26. package/build/backend/models/response-rules/response-rule.schema.d.ts +52 -14
  27. package/build/backend/models/response-rules/response-rule.schema.d.ts.map +1 -1
  28. package/build/backend/models/response-rules/response-rule.schema.js +28 -21
  29. package/build/backend/models/response-rules/response-rules-config.schema.d.ts +72 -20
  30. package/build/backend/models/response-rules/response-rules-config.schema.d.ts.map +1 -1
  31. package/build/backend/models/response-rules/response-rules-config.schema.js +3 -0
  32. package/build/backend/models/subscription-settings.schema.d.ts +198 -0
  33. package/build/backend/models/subscription-settings.schema.d.ts.map +1 -1
  34. package/build/backend/models/subscription-settings.schema.js +2 -0
  35. package/build/frontend/commands/subscription-settings/update-subscription-settings.command.js +2 -1
  36. package/build/frontend/constants/response-rules/response-rules.contants.js +17 -15
  37. package/build/frontend/constants/subscription-template/template-type/request-template-type.constant.js +0 -1
  38. package/build/frontend/constants/subscription-template/template-type/template-type.constant.js +4 -4
  39. package/build/frontend/models/response-rules/index.js +1 -0
  40. package/build/frontend/models/response-rules/response-rule-condition.schema.js +29 -0
  41. package/build/frontend/models/response-rules/response-rule.schema.js +28 -21
  42. package/build/frontend/models/response-rules/response-rules-config.schema.js +3 -0
  43. package/build/frontend/models/subscription-settings.schema.js +2 -0
  44. package/package.json +1 -1
package/build/backend/models/response-rules/response-rules-config.schema.d.ts CHANGED
@@ -26,78 +26,130 @@ export declare const ResponseRulesConfigSchema: z.ZodObject<{
26
26
  readonly NOT_REGEX: "NOT_REGEX";
27
27
  }>;
28
28
  value: z.ZodString;
29
+ caseSensitive: z.ZodBoolean;
29
30
  }, "strip", z.ZodTypeAny, {
30
31
  value: string;
31
- operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
32
32
  headerName: string;
33
+ operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
34
+ caseSensitive: boolean;
33
35
  }, {
34
36
  value: string;
35
- operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
36
37
  headerName: string;
38
+ operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
39
+ caseSensitive: boolean;
37
40
  }>, "many">;
38
41
  responseType: z.ZodNativeEnum<{
42
+ readonly BROWSER: "BROWSER";
39
43
  readonly BLOCK: "BLOCK";
40
- readonly XRAY_BASE64: "XRAY_BASE64";
41
44
  readonly STATUS_CODE_404: "STATUS_CODE_404";
42
- readonly STATUS_CODE_403: "STATUS_CODE_403";
43
45
  readonly STATUS_CODE_451: "STATUS_CODE_451";
44
46
  readonly SOCKET_DROP: "SOCKET_DROP";
45
- readonly STASH: "STASH";
46
- readonly SINGBOX: "SINGBOX";
47
- readonly SINGBOX_LEGACY: "SINGBOX_LEGACY";
48
- readonly MIHOMO: "MIHOMO";
49
47
  readonly XRAY_JSON: "XRAY_JSON";
48
+ readonly XRAY_BASE64: "XRAY_BASE64";
49
+ readonly MIHOMO: "MIHOMO";
50
+ readonly STASH: "STASH";
50
51
  readonly CLASH: "CLASH";
52
+ readonly SINGBOX: "SINGBOX";
53
+ }>;
54
+ responseModifications: z.ZodObject<{
55
+ headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
56
+ key: z.ZodString;
57
+ value: z.ZodString;
58
+ }, "strip", z.ZodTypeAny, {
59
+ value: string;
60
+ key: string;
61
+ }, {
62
+ value: string;
63
+ key: string;
64
+ }>, "many">>;
65
+ }, "strip", z.ZodTypeAny, {
66
+ headers?: {
67
+ value: string;
68
+ key: string;
69
+ }[] | undefined;
70
+ }, {
71
+ headers?: {
72
+ value: string;
73
+ key: string;
74
+ }[] | undefined;
51
75
  }>;
52
76
  }, "strip", z.ZodTypeAny, {
53
77
  name: string;
54
- enabled: boolean;
55
78
  operator: "AND" | "OR";
79
+ enabled: boolean;
56
80
  conditions: {
57
81
  value: string;
58
- operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
59
82
  headerName: string;
83
+ operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
84
+ caseSensitive: boolean;
60
85
  }[];
61
- responseType: "STASH" | "SINGBOX" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "BLOCK" | "XRAY_BASE64" | "STATUS_CODE_404" | "STATUS_CODE_403" | "STATUS_CODE_451" | "SOCKET_DROP";
86
+ responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
87
+ responseModifications: {
88
+ headers?: {
89
+ value: string;
90
+ key: string;
91
+ }[] | undefined;
92
+ };
62
93
  description?: string | undefined;
63
94
  }, {
64
95
  name: string;
65
- enabled: boolean;
66
96
  operator: "AND" | "OR";
97
+ enabled: boolean;
67
98
  conditions: {
68
99
  value: string;
69
- operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
70
100
  headerName: string;
101
+ operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
102
+ caseSensitive: boolean;
71
103
  }[];
72
- responseType: "STASH" | "SINGBOX" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "BLOCK" | "XRAY_BASE64" | "STATUS_CODE_404" | "STATUS_CODE_403" | "STATUS_CODE_451" | "SOCKET_DROP";
104
+ responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
105
+ responseModifications: {
106
+ headers?: {
107
+ value: string;
108
+ key: string;
109
+ }[] | undefined;
110
+ };
73
111
  description?: string | undefined;
74
112
  }>, "many">;
75
113
  }, "strip", z.ZodTypeAny, {
76
114
  version: "1";
77
115
  rules: {
78
116
  name: string;
79
- enabled: boolean;
80
117
  operator: "AND" | "OR";
118
+ enabled: boolean;
81
119
  conditions: {
82
120
  value: string;
83
- operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
84
121
  headerName: string;
122
+ operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
123
+ caseSensitive: boolean;
85
124
  }[];
86
- responseType: "STASH" | "SINGBOX" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "BLOCK" | "XRAY_BASE64" | "STATUS_CODE_404" | "STATUS_CODE_403" | "STATUS_CODE_451" | "SOCKET_DROP";
125
+ responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
126
+ responseModifications: {
127
+ headers?: {
128
+ value: string;
129
+ key: string;
130
+ }[] | undefined;
131
+ };
87
132
  description?: string | undefined;
88
133
  }[];
89
134
  }, {
90
135
  version: "1";
91
136
  rules: {
92
137
  name: string;
93
- enabled: boolean;
94
138
  operator: "AND" | "OR";
139
+ enabled: boolean;
95
140
  conditions: {
96
141
  value: string;
97
- operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
98
142
  headerName: string;
143
+ operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
144
+ caseSensitive: boolean;
99
145
  }[];
100
- responseType: "STASH" | "SINGBOX" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "BLOCK" | "XRAY_BASE64" | "STATUS_CODE_404" | "STATUS_CODE_403" | "STATUS_CODE_451" | "SOCKET_DROP";
146
+ responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
147
+ responseModifications: {
148
+ headers?: {
149
+ value: string;
150
+ key: string;
151
+ }[] | undefined;
152
+ };
101
153
  description?: string | undefined;
102
154
  }[];
103
155
  }>;
package/build/backend/models/response-rules/response-rules-config.schema.d.ts.map CHANGED
@@ -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;AAkCxB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgCpC,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;AAoCxB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCpC,CAAC"}
package/build/backend/models/response-rules/response-rules-config.schema.js CHANGED
@@ -14,11 +14,13 @@ const RuleExampleJson = JSON.stringify({
14
14
  headerName: 'user-agent',
15
15
  operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
16
16
  value: 'Hiddify',
17
+ caseSensitive: true,
17
18
  },
18
19
  {
19
20
  headerName: 'user-agent',
20
21
  operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
21
22
  value: 'FoxRay',
23
+ caseSensitive: true,
22
24
  },
23
25
  ],
24
26
  responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
@@ -41,6 +43,7 @@ exports.ResponseRulesConfigSchema = zod_1.z.object({
41
43
  headerName: 'user-agent',
42
44
  operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
43
45
  value: 'Example Rule Value, replace with your own value',
46
+ caseSensitive: true,
44
47
  },
45
48
  ],
46
49
  responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
package/build/backend/models/subscription-settings.schema.d.ts CHANGED
@@ -15,6 +15,160 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
15
15
  disabledUsersRemarks: z.ZodArray<z.ZodString, "many">;
16
16
  customResponseHeaders: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
17
17
  randomizeHosts: z.ZodBoolean;
18
+ responseRules: z.ZodNullable<z.ZodObject<{
19
+ version: z.ZodNativeEnum<{
20
+ readonly 1: "1";
21
+ }>;
22
+ rules: z.ZodArray<z.ZodObject<{
23
+ name: z.ZodString;
24
+ description: z.ZodOptional<z.ZodString>;
25
+ enabled: z.ZodBoolean;
26
+ operator: z.ZodNativeEnum<{
27
+ readonly AND: "AND";
28
+ readonly OR: "OR";
29
+ }>;
30
+ conditions: z.ZodArray<z.ZodObject<{
31
+ headerName: z.ZodString;
32
+ operator: z.ZodNativeEnum<{
33
+ readonly EQUALS: "EQUALS";
34
+ readonly NOT_EQUALS: "NOT_EQUALS";
35
+ readonly CONTAINS: "CONTAINS";
36
+ readonly NOT_CONTAINS: "NOT_CONTAINS";
37
+ readonly STARTS_WITH: "STARTS_WITH";
38
+ readonly NOT_STARTS_WITH: "NOT_STARTS_WITH";
39
+ readonly ENDS_WITH: "ENDS_WITH";
40
+ readonly NOT_ENDS_WITH: "NOT_ENDS_WITH";
41
+ readonly REGEX: "REGEX";
42
+ readonly NOT_REGEX: "NOT_REGEX";
43
+ }>;
44
+ value: z.ZodString;
45
+ caseSensitive: z.ZodBoolean;
46
+ }, "strip", z.ZodTypeAny, {
47
+ value: string;
48
+ headerName: string;
49
+ operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
50
+ caseSensitive: boolean;
51
+ }, {
52
+ value: string;
53
+ headerName: string;
54
+ operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
55
+ caseSensitive: boolean;
56
+ }>, "many">;
57
+ responseType: z.ZodNativeEnum<{
58
+ readonly BROWSER: "BROWSER";
59
+ readonly BLOCK: "BLOCK";
60
+ readonly STATUS_CODE_404: "STATUS_CODE_404";
61
+ readonly STATUS_CODE_451: "STATUS_CODE_451";
62
+ readonly SOCKET_DROP: "SOCKET_DROP";
63
+ readonly XRAY_JSON: "XRAY_JSON";
64
+ readonly XRAY_BASE64: "XRAY_BASE64";
65
+ readonly MIHOMO: "MIHOMO";
66
+ readonly STASH: "STASH";
67
+ readonly CLASH: "CLASH";
68
+ readonly SINGBOX: "SINGBOX";
69
+ }>;
70
+ responseModifications: z.ZodObject<{
71
+ headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
72
+ key: z.ZodString;
73
+ value: z.ZodString;
74
+ }, "strip", z.ZodTypeAny, {
75
+ value: string;
76
+ key: string;
77
+ }, {
78
+ value: string;
79
+ key: string;
80
+ }>, "many">>;
81
+ }, "strip", z.ZodTypeAny, {
82
+ headers?: {
83
+ value: string;
84
+ key: string;
85
+ }[] | undefined;
86
+ }, {
87
+ headers?: {
88
+ value: string;
89
+ key: string;
90
+ }[] | undefined;
91
+ }>;
92
+ }, "strip", z.ZodTypeAny, {
93
+ name: string;
94
+ operator: "AND" | "OR";
95
+ enabled: boolean;
96
+ conditions: {
97
+ value: string;
98
+ headerName: string;
99
+ operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
100
+ caseSensitive: boolean;
101
+ }[];
102
+ responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
103
+ responseModifications: {
104
+ headers?: {
105
+ value: string;
106
+ key: string;
107
+ }[] | undefined;
108
+ };
109
+ description?: string | undefined;
110
+ }, {
111
+ name: string;
112
+ operator: "AND" | "OR";
113
+ enabled: boolean;
114
+ conditions: {
115
+ value: string;
116
+ headerName: string;
117
+ operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
118
+ caseSensitive: boolean;
119
+ }[];
120
+ responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
121
+ responseModifications: {
122
+ headers?: {
123
+ value: string;
124
+ key: string;
125
+ }[] | undefined;
126
+ };
127
+ description?: string | undefined;
128
+ }>, "many">;
129
+ }, "strip", z.ZodTypeAny, {
130
+ version: "1";
131
+ rules: {
132
+ name: string;
133
+ operator: "AND" | "OR";
134
+ enabled: boolean;
135
+ conditions: {
136
+ value: string;
137
+ headerName: string;
138
+ operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
139
+ caseSensitive: boolean;
140
+ }[];
141
+ responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
142
+ responseModifications: {
143
+ headers?: {
144
+ value: string;
145
+ key: string;
146
+ }[] | undefined;
147
+ };
148
+ description?: string | undefined;
149
+ }[];
150
+ }, {
151
+ version: "1";
152
+ rules: {
153
+ name: string;
154
+ operator: "AND" | "OR";
155
+ enabled: boolean;
156
+ conditions: {
157
+ value: string;
158
+ headerName: string;
159
+ operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
160
+ caseSensitive: boolean;
161
+ }[];
162
+ responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
163
+ responseModifications: {
164
+ headers?: {
165
+ value: string;
166
+ key: string;
167
+ }[] | undefined;
168
+ };
169
+ description?: string | undefined;
170
+ }[];
171
+ }>>;
18
172
  createdAt: z.ZodEffects<z.ZodString, Date, string>;
19
173
  updatedAt: z.ZodEffects<z.ZodString, Date, string>;
20
174
  }, "strip", z.ZodTypeAny, {
@@ -35,6 +189,28 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
35
189
  disabledUsersRemarks: string[];
36
190
  customResponseHeaders: Record<string, string> | null;
37
191
  randomizeHosts: boolean;
192
+ responseRules: {
193
+ version: "1";
194
+ rules: {
195
+ name: string;
196
+ operator: "AND" | "OR";
197
+ enabled: boolean;
198
+ conditions: {
199
+ value: string;
200
+ headerName: string;
201
+ operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
202
+ caseSensitive: boolean;
203
+ }[];
204
+ responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
205
+ responseModifications: {
206
+ headers?: {
207
+ value: string;
208
+ key: string;
209
+ }[] | undefined;
210
+ };
211
+ description?: string | undefined;
212
+ }[];
213
+ } | null;
38
214
  }, {
39
215
  uuid: string;
40
216
  createdAt: string;
@@ -53,5 +229,27 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
53
229
  disabledUsersRemarks: string[];
54
230
  customResponseHeaders: Record<string, string> | null;
55
231
  randomizeHosts: boolean;
232
+ responseRules: {
233
+ version: "1";
234
+ rules: {
235
+ name: string;
236
+ operator: "AND" | "OR";
237
+ enabled: boolean;
238
+ conditions: {
239
+ value: string;
240
+ headerName: string;
241
+ operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
242
+ caseSensitive: boolean;
243
+ }[];
244
+ responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
245
+ responseModifications: {
246
+ headers?: {
247
+ value: string;
248
+ key: string;
249
+ }[] | undefined;
250
+ };
251
+ description?: string | undefined;
252
+ }[];
253
+ } | null;
56
254
  }>;
57
255
  //# sourceMappingURL=subscription-settings.schema.d.ts.map
package/build/backend/models/subscription-settings.schema.d.ts.map CHANGED
@@ -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;AAExB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkCrC,CAAC"}
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;AAIxB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoCrC,CAAC"}
package/build/backend/models/subscription-settings.schema.js CHANGED
@@ -2,6 +2,7 @@
2
2
  Object.defineProperty(exports, "__esModule", { value: true });
3
3
  exports.SubscriptionSettingsSchema = void 0;
4
4
  const zod_1 = require("zod");
5
+ const response_rules_1 = require("./response-rules");
5
6
  exports.SubscriptionSettingsSchema = zod_1.z.object({
6
7
  uuid: zod_1.z.string().uuid(),
7
8
  profileTitle: zod_1.z.string(),
@@ -21,6 +22,7 @@ exports.SubscriptionSettingsSchema = zod_1.z.object({
21
22
  disabledUsersRemarks: zod_1.z.array(zod_1.z.string()),
22
23
  customResponseHeaders: zod_1.z.nullable(zod_1.z.record(zod_1.z.string(), zod_1.z.string())),
23
24
  randomizeHosts: zod_1.z.boolean(),
25
+ responseRules: zod_1.z.nullable(response_rules_1.ResponseRulesConfigSchema),
24
26
  createdAt: zod_1.z
25
27
  .string()
26
28
  .datetime()
package/build/frontend/commands/subscription-settings/update-subscription-settings.command.js CHANGED
@@ -2,8 +2,8 @@
2
2
  Object.defineProperty(exports, "__esModule", { value: true });
3
3
  exports.UpdateSubscriptionSettingsCommand = void 0;
4
4
  const zod_1 = require("zod");
5
- const api_1 = require("../../api");
6
5
  const models_1 = require("../../models");
6
+ const api_1 = require("../../api");
7
7
  const constants_1 = require("../../constants");
8
8
  var UpdateSubscriptionSettingsCommand;
9
9
  (function (UpdateSubscriptionSettingsCommand) {
@@ -31,6 +31,7 @@ var UpdateSubscriptionSettingsCommand;
31
31
  .string()
32
32
  .regex(/^[a-zA-Z0-9_-]+$/, 'Invalid header name. Only letters(a-z, A-Z), numbers(0-9), underscores(_) and hyphens(-) are allowed.'), zod_1.z.string())),
33
33
  randomizeHosts: zod_1.z.optional(zod_1.z.boolean()),
34
+ responseRules: zod_1.z.optional(models_1.ResponseRulesConfigSchema),
34
35
  });
35
36
  UpdateSubscriptionSettingsCommand.ResponseSchema = zod_1.z.object({
36
37
  response: models_1.SubscriptionSettingsSchema,
package/build/frontend/constants/response-rules/response-rules.contants.js CHANGED
@@ -1,6 +1,6 @@
1
1
  "use strict";
2
2
  Object.defineProperty(exports, "__esModule", { value: true });
3
- exports.RESPONSE_RULES_RESPONSE_TYPES_DESCRIPTION = exports.RESPONSE_RULES_RESPONSE_TYPES = exports.RESPONSE_RULES_CONDITION_OPERATORS_DESCRIPTION = exports.RESPONSE_RULES_CONDITION_OPERATORS = exports.RESPONSE_RULE_CONDITION_TYPES = exports.RESPONSE_RULES_OPERATORS = exports.RESPONSE_RULES_CONFIG_VERSION = void 0;
3
+ exports.RESPONSE_RULES_CONDITION_OPERATORS_DESCRIPTION = exports.RESPONSE_RULES_RESPONSE_TYPES_DESCRIPTION = exports.RESPONSE_RULES_CONDITION_OPERATORS_VALUES = exports.RESPONSE_RULES_RESPONSE_TYPES_VALUES = exports.RESPONSE_RULES_RESPONSE_TYPES = exports.RESPONSE_RULES_CONDITION_OPERATORS = exports.RESPONSE_RULE_CONDITION_TYPES = exports.RESPONSE_RULES_OPERATORS = exports.RESPONSE_RULES_CONFIG_VERSION = void 0;
4
4
  const subscription_template_1 = require("../subscription-template");
5
5
  exports.RESPONSE_RULES_CONFIG_VERSION = {
6
6
  1: '1',
@@ -24,19 +24,9 @@ exports.RESPONSE_RULES_CONDITION_OPERATORS = {
24
24
  REGEX: 'REGEX',
25
25
  NOT_REGEX: 'NOT_REGEX',
26
26
  };
27
- exports.RESPONSE_RULES_CONDITION_OPERATORS_DESCRIPTION = {
28
- [exports.RESPONSE_RULES_CONDITION_OPERATORS.EQUALS]: 'Equals operator checks if the header value exactly matches the specified string, case sensitive. Underlying implementation uses strict string comparison – ===.',
29
- [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_EQUALS]: 'Not equals operator checks if the header value does not match the specified string, case sensitive. Underlying implementation uses strict string comparison – !==.',
30
- [exports.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS]: 'Contains operator checks if the header value contains the specified string, case sensitive. Underlying implementation uses string.includes().',
31
- [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_CONTAINS]: 'Not contains operator checks if the header value does not contain the specified string, case sensitive. Underlying implementation uses string.includes().',
32
- [exports.RESPONSE_RULES_CONDITION_OPERATORS.STARTS_WITH]: 'Starts with operator checks if the header value starts with the specified string, case sensitive. Underlying implementation uses string.startsWith().',
33
- [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_STARTS_WITH]: 'Not starts with operator checks if the header value does not start with the specified string, case sensitive. Underlying implementation uses string.startsWith().',
34
- [exports.RESPONSE_RULES_CONDITION_OPERATORS.ENDS_WITH]: 'Ends with operator checks if the header value ends with the specified string, case sensitive. Underlying implementation uses string.endsWith().',
35
- [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_ENDS_WITH]: 'Not ends with operator checks if the header value does not end with the specified string, case sensitive. Underlying implementation uses string.endsWith().',
36
- [exports.RESPONSE_RULES_CONDITION_OPERATORS.REGEX]: 'Regex operator checks if the header value matches the specified regex. Underlying implementation uses regex.test().',
37
- [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_REGEX]: 'Inverse regex operator checks if the header value does not match the specified regex. Underlying implementation uses regex.test().',
38
- };
39
- exports.RESPONSE_RULES_RESPONSE_TYPES = Object.assign(Object.assign({}, subscription_template_1.SUBSCRIPTION_TEMPLATE_TYPE), { BLOCK: 'BLOCK', XRAY_BASE64: 'XRAY_BASE64', STATUS_CODE_404: 'STATUS_CODE_404', STATUS_CODE_403: 'STATUS_CODE_403', STATUS_CODE_451: 'STATUS_CODE_451', SOCKET_DROP: 'SOCKET_DROP' });
27
+ exports.RESPONSE_RULES_RESPONSE_TYPES = Object.assign(Object.assign({}, subscription_template_1.SUBSCRIPTION_TEMPLATE_TYPE), { BROWSER: 'BROWSER', BLOCK: 'BLOCK', STATUS_CODE_404: 'STATUS_CODE_404', STATUS_CODE_451: 'STATUS_CODE_451', SOCKET_DROP: 'SOCKET_DROP' });
28
+ exports.RESPONSE_RULES_RESPONSE_TYPES_VALUES = Object.values(exports.RESPONSE_RULES_RESPONSE_TYPES);
29
+ exports.RESPONSE_RULES_CONDITION_OPERATORS_VALUES = Object.values(exports.RESPONSE_RULES_CONDITION_OPERATORS);
40
30
  exports.RESPONSE_RULES_RESPONSE_TYPES_DESCRIPTION = {
41
31
  [exports.RESPONSE_RULES_RESPONSE_TYPES.BLOCK]: 'Block response type blocks the request and returns a 403 status code.',
42
32
  [exports.RESPONSE_RULES_RESPONSE_TYPES.XRAY_BASE64]: 'Previously used as fallback response type. It return subscription as base64 encoded string. Compatible with most client application with Xray core.',
@@ -46,7 +36,19 @@ exports.RESPONSE_RULES_RESPONSE_TYPES_DESCRIPTION = {
46
36
  [exports.RESPONSE_RULES_RESPONSE_TYPES.CLASH]: 'Useful for client application that use Legacy Clash core. It return subscription as Clash YAML format.',
47
37
  [exports.RESPONSE_RULES_RESPONSE_TYPES.STASH]: 'Format which is used by Stash client application.',
48
38
  [exports.RESPONSE_RULES_RESPONSE_TYPES.SINGBOX]: 'Format which is used by Singbox client application.',
49
- [exports.RESPONSE_RULES_RESPONSE_TYPES.SINGBOX_LEGACY]: 'Format which is used by Singbox client application (legacy version).',
50
39
  [exports.RESPONSE_RULES_RESPONSE_TYPES.MIHOMO]: 'Return subscription as Mihomo Core YAML format.',
51
40
  [exports.RESPONSE_RULES_RESPONSE_TYPES.XRAY_JSON]: 'Return subscription as Xray JSON format.',
41
+ [exports.RESPONSE_RULES_RESPONSE_TYPES.BROWSER]: 'Return subscription as browser format.',
42
+ };
43
+ exports.RESPONSE_RULES_CONDITION_OPERATORS_DESCRIPTION = {
44
+ [exports.RESPONSE_RULES_CONDITION_OPERATORS.EQUALS]: 'Equals operator checks if the header value exactly matches the specified string, case sensitive. Underlying implementation uses strict string comparison – ===.',
45
+ [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_EQUALS]: 'Not equals operator checks if the header value does not match the specified string, case sensitive. Underlying implementation uses strict string comparison – !==.',
46
+ [exports.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS]: 'Contains operator checks if the header value contains the specified string, case sensitive. Underlying implementation uses string.includes().',
47
+ [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_CONTAINS]: 'Not contains operator checks if the header value does not contain the specified string, case sensitive. Underlying implementation uses string.includes().',
48
+ [exports.RESPONSE_RULES_CONDITION_OPERATORS.STARTS_WITH]: 'Starts with operator checks if the header value starts with the specified string, case sensitive. Underlying implementation uses string.startsWith().',
49
+ [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_STARTS_WITH]: 'Not starts with operator checks if the header value does not start with the specified string, case sensitive. Underlying implementation uses string.startsWith().',
50
+ [exports.RESPONSE_RULES_CONDITION_OPERATORS.ENDS_WITH]: 'Ends with operator checks if the header value ends with the specified string, case sensitive. Underlying implementation uses string.endsWith().',
51
+ [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_ENDS_WITH]: 'Not ends with operator checks if the header value does not end with the specified string, case sensitive. Underlying implementation uses string.endsWith().',
52
+ [exports.RESPONSE_RULES_CONDITION_OPERATORS.REGEX]: 'Regex operator checks if the header value matches the specified regex. Underlying implementation uses regex.test().',
53
+ [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_REGEX]: 'Inverse regex operator checks if the header value does not match the specified regex. Underlying implementation uses regex.test().',
52
54
  };
package/build/frontend/constants/subscription-template/template-type/request-template-type.constant.js CHANGED
@@ -4,7 +4,6 @@ exports.REQUEST_TEMPLATE_TYPE_VALUES = exports.REQUEST_TEMPLATE_TYPE = void 0;
4
4
  exports.REQUEST_TEMPLATE_TYPE = {
5
5
  STASH: 'stash',
6
6
  SINGBOX: 'singbox',
7
- SINGBOX_LEGACY: 'singbox-legacy',
8
7
  MIHOMO: 'mihomo',
9
8
  XRAY_JSON: 'json',
10
9
  V2RAY_JSON: 'v2ray-json',
package/build/frontend/constants/subscription-template/template-type/template-type.constant.js CHANGED
@@ -2,11 +2,11 @@
2
2
  Object.defineProperty(exports, "__esModule", { value: true });
3
3
  exports.SUBSCRIPTION_TEMPLATE_TYPE_VALUES = exports.SUBSCRIPTION_TEMPLATE_TYPE = void 0;
4
4
  exports.SUBSCRIPTION_TEMPLATE_TYPE = {
5
- STASH: 'STASH',
6
- SINGBOX: 'SINGBOX',
7
- SINGBOX_LEGACY: 'SINGBOX_LEGACY',
8
- MIHOMO: 'MIHOMO',
9
5
  XRAY_JSON: 'XRAY_JSON',
6
+ XRAY_BASE64: 'XRAY_BASE64',
7
+ MIHOMO: 'MIHOMO',
8
+ STASH: 'STASH',
10
9
  CLASH: 'CLASH',
10
+ SINGBOX: 'SINGBOX',
11
11
  };
12
12
  exports.SUBSCRIPTION_TEMPLATE_TYPE_VALUES = Object.values(exports.SUBSCRIPTION_TEMPLATE_TYPE);
package/build/frontend/models/response-rules/index.js CHANGED
@@ -14,5 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
14
14
  for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
15
15
  };
16
16
  Object.defineProperty(exports, "__esModule", { value: true });
17
+ __exportStar(require("./response-rule-condition.schema"), exports);
17
18
  __exportStar(require("./response-rule.schema"), exports);
18
19
  __exportStar(require("./response-rules-config.schema"), exports);
package/build/frontend/models/response-rules/response-rule-condition.schema.js ADDED
@@ -0,0 +1,29 @@
1
+ "use strict";
2
+ Object.defineProperty(exports, "__esModule", { value: true });
3
+ exports.ResponseRuleConditionSchema = void 0;
4
+ const zod_1 = require("zod");
5
+ const constants_1 = require("../../constants");
6
+ exports.ResponseRuleConditionSchema = zod_1.z.object({
7
+ headerName: zod_1.z
8
+ .string()
9
+ .regex(/^[!#$%&'*+\-.0-9A-Z^_`a-z|~]+$/, 'Invalid header name. Only letters(a-z, A-Z), numbers(0-9), underscores(_) and hyphens(-) are allowed.')
10
+ .describe(JSON.stringify({
11
+ title: 'Header Name',
12
+ markdownDescription: 'Name of the HTTP header to check, case insensitive, must comply with RFC 7230.',
13
+ })),
14
+ operator: zod_1.z.nativeEnum(constants_1.RESPONSE_RULES_CONDITION_OPERATORS).describe(JSON.stringify({
15
+ markdownDescription: `Comparison operator to compare the header value against.\n\n${Object.entries(constants_1.RESPONSE_RULES_CONDITION_OPERATORS_DESCRIPTION)
16
+ .map(([key, description]) => `- **${key}**: ${description}\n`)
17
+ .join('\n')}`,
18
+ })),
19
+ value: zod_1.z
20
+ .string()
21
+ .min(1, 'Value is required')
22
+ .max(255, 'Value must be less than 255 characters')
23
+ .describe(JSON.stringify({
24
+ markdownDescription: `Value to check against the header, case sensitive (excluding regex/not_regex operator). Maximum length is 255 characters.`,
25
+ })),
26
+ caseSensitive: zod_1.z.boolean().describe(JSON.stringify({
27
+ markdownDescription: 'Whether the value is case sensitive. If true, the value will be compared case sensitive. If false, the value will be lowercased before comparison.',
28
+ })),
29
+ });
package/build/frontend/models/response-rules/response-rule.schema.js CHANGED
@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
3
3
  exports.ResponseRuleSchema = void 0;
4
4
  const zod_1 = require("zod");
5
5
  const constants_1 = require("../../constants");
6
+ const response_rule_condition_schema_1 = require("./response-rule-condition.schema");
6
7
  const RuleExampleJson = JSON.stringify({
7
8
  name: 'Block Legacy Clients',
8
9
  description: 'Block requests from legacy clients',
@@ -13,11 +14,13 @@ const RuleExampleJson = JSON.stringify({
13
14
  headerName: 'user-agent',
14
15
  operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
15
16
  value: 'Hiddify',
17
+ caseSensitive: true,
16
18
  },
17
19
  {
18
20
  headerName: 'user-agent',
19
21
  operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
20
22
  value: 'FoxRay',
23
+ caseSensitive: true,
21
24
  },
22
25
  ],
23
26
  responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
@@ -48,32 +51,35 @@ exports.ResponseRuleSchema = zod_1.z
48
51
  title: 'Operator',
49
52
  markdownDescription: 'Operator to use for combining conditions in the rule.',
50
53
  })),
51
- conditions: zod_1.z.array(zod_1.z.object({
52
- headerName: zod_1.z
53
- .string()
54
- .regex(/^[!#$%&'*+\-.0-9A-Z^_`a-z|~]+$/, 'Invalid header name. Only letters(a-z, A-Z), numbers(0-9), underscores(_) and hyphens(-) are allowed.')
55
- .describe(JSON.stringify({
56
- title: 'Header Name',
57
- markdownDescription: 'Name of the HTTP header to check, case insensitive, must comply with RFC 7230.',
58
- })),
59
- operator: zod_1.z.nativeEnum(constants_1.RESPONSE_RULES_CONDITION_OPERATORS).describe(JSON.stringify({
60
- markdownDescription: `Comparison operator to compare the header value against.\n\n${Object.entries(constants_1.RESPONSE_RULES_CONDITION_OPERATORS_DESCRIPTION)
61
- .map(([key, description]) => `- **${key}**: ${description}\n`)
62
- .join('\n')}`,
63
- })),
64
- value: zod_1.z
65
- .string()
66
- .min(1, 'Value is required')
67
- .max(255, 'Value must be less than 255 characters')
68
- .describe(JSON.stringify({
69
- markdownDescription: `Value to check against the header, case sensitive (excluding regex/not_regex operator). Maximum length is 255 characters.`,
70
- })),
71
- })),
54
+ conditions: zod_1.z.array(response_rule_condition_schema_1.ResponseRuleConditionSchema),
72
55
  responseType: zod_1.z.nativeEnum(constants_1.RESPONSE_RULES_RESPONSE_TYPES).describe(JSON.stringify({
73
56
  markdownDescription: `Type of the response. Determines the type of **response** to be returned when the rule is matched.\n\n${Object.entries(constants_1.RESPONSE_RULES_RESPONSE_TYPES_DESCRIPTION)
74
57
  .map(([key, description]) => `- **${key}**: ${description}\n`)
75
58
  .join('\n')}`,
76
59
  })),
60
+ responseModifications: zod_1.z.object({
61
+ headers: zod_1.z
62
+ .array(zod_1.z.object({
63
+ key: zod_1.z
64
+ .string()
65
+ .regex(/^[!#$%&'*+\-.0-9A-Z^_`a-z|~]+$/, 'Invalid header name. Only letters(a-z, A-Z), numbers(0-9), underscores(_) and hyphens(-) are allowed.')
66
+ .describe(JSON.stringify({
67
+ title: 'Key',
68
+ markdownDescription: 'Key of the response header. Must comply with RFC 7230.',
69
+ })),
70
+ value: zod_1.z
71
+ .string()
72
+ .min(1, 'Value is required')
73
+ .describe(JSON.stringify({
74
+ title: 'Value',
75
+ markdownDescription: 'Value of the response header. ',
76
+ })),
77
+ }))
78
+ .optional()
79
+ .describe(JSON.stringify({
80
+ markdownDescription: 'Response headers to be added when the rule is matched.',
81
+ })),
82
+ }),
77
83
  })
78
84
  .describe(JSON.stringify({
79
85
  title: 'Response Rule',
@@ -89,6 +95,7 @@ exports.ResponseRuleSchema = zod_1.z
89
95
  headerName: 'user-agent',
90
96
  operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
91
97
  value: 'Example Rule Value, replace with your own value',
98
+ caseSensitive: true,
92
99
  },
93
100
  ],
94
101
  responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,