@remnawave/backend-contract 2.9.31 → 2.9.32

package/build/backend/models/response-rules/response-rule.schema.d.ts

@@ -3,27 +3,7 @@ export declare const ResponseRuleSchemaBase: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
     enabled: z.ZodBoolean;
-    operator: z.ZodEnum<{
-        readonly AND: "AND";
-        readonly OR: "OR";
-    }>;
-    conditions: z.ZodArray<z.ZodObject<{
-        headerName: z.ZodString;
-        operator: z.ZodEnum<{
-            readonly EQUALS: "EQUALS";
-            readonly NOT_EQUALS: "NOT_EQUALS";
-            readonly CONTAINS: "CONTAINS";
-            readonly NOT_CONTAINS: "NOT_CONTAINS";
-            readonly STARTS_WITH: "STARTS_WITH";
-            readonly NOT_STARTS_WITH: "NOT_STARTS_WITH";
-            readonly ENDS_WITH: "ENDS_WITH";
-            readonly NOT_ENDS_WITH: "NOT_ENDS_WITH";
-            readonly REGEX: "REGEX";
-            readonly NOT_REGEX: "NOT_REGEX";
-        }>;
-        value: z.ZodString;
-        caseSensitive: z.ZodBoolean;
-    }, z.core.$strip>>;
+    when: z.ZodOptional<z.ZodType<import("./response-rule-condition.schema").TResponseRuleConditionNode, unknown, z.core.$ZodTypeInternals<import("./response-rule-condition.schema").TResponseRuleConditionNode, unknown>>>;
     responseType: z.ZodEnum<{
         readonly BROWSER: "BROWSER";
         readonly BLOCK: "BLOCK";
@@ -57,32 +37,12 @@ export declare const ResponseRuleSchemaBase: z.ZodObject<{
         }, z.core.$strip>>;
         excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
-}, z.core.$strip>;
+}, z.core.$strict>;
 export declare const ResponseRuleSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
     enabled: z.ZodBoolean;
-    operator: z.ZodEnum<{
-        readonly AND: "AND";
-        readonly OR: "OR";
-    }>;
-    conditions: z.ZodArray<z.ZodObject<{
-        headerName: z.ZodString;
-        operator: z.ZodEnum<{
-            readonly EQUALS: "EQUALS";
-            readonly NOT_EQUALS: "NOT_EQUALS";
-            readonly CONTAINS: "CONTAINS";
-            readonly NOT_CONTAINS: "NOT_CONTAINS";
-            readonly STARTS_WITH: "STARTS_WITH";
-            readonly NOT_STARTS_WITH: "NOT_STARTS_WITH";
-            readonly ENDS_WITH: "ENDS_WITH";
-            readonly NOT_ENDS_WITH: "NOT_ENDS_WITH";
-            readonly REGEX: "REGEX";
-            readonly NOT_REGEX: "NOT_REGEX";
-        }>;
-        value: z.ZodString;
-        caseSensitive: z.ZodBoolean;
-    }, z.core.$strip>>;
+    when: z.ZodOptional<z.ZodType<import("./response-rule-condition.schema").TResponseRuleConditionNode, unknown, z.core.$ZodTypeInternals<import("./response-rule-condition.schema").TResponseRuleConditionNode, unknown>>>;
     responseType: z.ZodEnum<{
         readonly BROWSER: "BROWSER";
         readonly BLOCK: "BLOCK";
@@ -116,5 +76,5 @@ export declare const ResponseRuleSchema: z.ZodObject<{
         }, z.core.$strip>>;
         excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
-}, z.core.$strip>;
+}, z.core.$strict>;
 //# sourceMappingURL=response-rule.schema.d.ts.map

package/build/backend/models/response-rules/response-rule.schema.d.ts.map

@@ -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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuCjC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmB7B,CAAC"}
+{"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;AAmBxB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA0DjC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAmB7B,CAAC"}

package/build/backend/models/response-rules/response-rule.schema.js

@@ -6,7 +6,7 @@ const constants_1 = require("../../constants");
 const response_rule_condition_schema_1 = require("./response-rule-condition.schema");
 const response_rule_modifications_schema_1 = require("./response-rule-modifications.schema");
 const response_rules_examples_1 = require("./response-rules-examples");
-exports.ResponseRuleSchemaBase = zod_1.z.object({
+exports.ResponseRuleSchemaBase = zod_1.z.strictObject({
     name: zod_1.z
         .string()
         .min(1, 'Name is required')
@@ -28,12 +28,28 @@ exports.ResponseRuleSchemaBase = zod_1.z.object({
         title: 'Enabled',
         markdownDescription: 'Control whether the response rule is enabled or disabled. \n\n - `true` the rule will be applied. \n\n - `false` the rule will be always ignored.',
     }),
-    operator: zod_1.z.enum(constants_1.RESPONSE_RULES_OPERATORS).meta({
-        markdownDescription: 'Operator to use for combining conditions in the rule.',
-    }),
-    conditions: zod_1.z.array(response_rule_condition_schema_1.ResponseRuleConditionSchema).meta({
-        title: 'Conditions',
-        markdownDescription: 'Array of conditions to check against the request headers. Conditions are applied with **operator**. If conditions are empty, the rule will be matched.',
+    when: response_rule_condition_schema_1.ResponseRuleConditionNodeSchema.optional()
+        .superRefine((node, ctx) => {
+        if (!node) {
+            return;
+        }
+        const { depth, nodes } = (0, response_rule_condition_schema_1.measureResponseRuleConditionTree)(node);
+        if (depth > response_rule_condition_schema_1.RESPONSE_RULES_MAX_CONDITION_DEPTH) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `Condition tree is too deep. Maximum depth is ${response_rule_condition_schema_1.RESPONSE_RULES_MAX_CONDITION_DEPTH}.`,
+            });
+        }
+        if (nodes > response_rule_condition_schema_1.RESPONSE_RULES_MAX_CONDITION_NODES) {
+            ctx.addIssue({
+                code: 'custom',
+                message: `Condition tree is too big. Maximum number of nodes is ${response_rule_condition_schema_1.RESPONSE_RULES_MAX_CONDITION_NODES}.`,
+            });
+        }
+    })
+        .meta({
+        title: 'When',
+        markdownDescription: 'Condition tree to check against the request headers. The root is either a single **condition** or a **group** (`AND`/`OR`/`NOT`) with nested conditions — groups can be nested to express complex logic, e.g. `A AND (B OR C)`. If **when** is omitted, the rule will always be matched.',
     }),
     responseType: zod_1.z.enum(constants_1.RESPONSE_RULES_RESPONSE_TYPES).meta({
         errorMessage: 'Invalid response type. Please select a valid response type.',
@@ -54,10 +70,10 @@ exports.ResponseRuleSchema = exports.ResponseRuleSchemaBase.meta({
             },
         },
         {
-            label: 'Examples: Block Legacy Clients',
-            markdownDescription: `Block requests from legacy clients\n\`\`\`json\n${JSON.stringify(response_rules_examples_1.EXAMPLES_SRR_BLOCK_LEGACY_CLIENTS_RULE, null, 2)}\n\`\`\``,
+            label: 'Examples: Nested conditions (AND with OR inside)',
+            markdownDescription: `Block browser requests from legacy clients using nested conditions: \`accept AND (user-agent OR user-agent)\`\n\`\`\`json\n${JSON.stringify(response_rules_examples_1.EXAMPLES_SRR_NESTED_CONDITIONS_RULE, null, 2)}\n\`\`\``,
             body: {
-                ...response_rules_examples_1.EXAMPLES_SRR_BLOCK_LEGACY_CLIENTS_RULE,
+                ...response_rules_examples_1.EXAMPLES_SRR_NESTED_CONDITIONS_RULE,
             },
         },
     ],

package/build/backend/models/response-rules/response-rules-config.schema.d.ts

@@ -1,8 +1,6 @@
 import { z } from 'zod';
 export declare const ResponseRulesConfigSchema: z.ZodObject<{
-    version: z.ZodEnum<{
-        readonly 1: "1";
-    }>;
+    version: z.ZodLiteral<"2">;
     settings: z.ZodOptional<z.ZodObject<{
         disableSubscriptionAccessByPath: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>>;
@@ -10,27 +8,7 @@ export declare const ResponseRulesConfigSchema: z.ZodObject<{
         name: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
         enabled: z.ZodBoolean;
-        operator: z.ZodEnum<{
-            readonly AND: "AND";
-            readonly OR: "OR";
-        }>;
-        conditions: z.ZodArray<z.ZodObject<{
-            headerName: z.ZodString;
-            operator: z.ZodEnum<{
-                readonly EQUALS: "EQUALS";
-                readonly NOT_EQUALS: "NOT_EQUALS";
-                readonly CONTAINS: "CONTAINS";
-                readonly NOT_CONTAINS: "NOT_CONTAINS";
-                readonly STARTS_WITH: "STARTS_WITH";
-                readonly NOT_STARTS_WITH: "NOT_STARTS_WITH";
-                readonly ENDS_WITH: "ENDS_WITH";
-                readonly NOT_ENDS_WITH: "NOT_ENDS_WITH";
-                readonly REGEX: "REGEX";
-                readonly NOT_REGEX: "NOT_REGEX";
-            }>;
-            value: z.ZodString;
-            caseSensitive: z.ZodBoolean;
-        }, z.core.$strip>>;
+        when: z.ZodOptional<z.ZodType<import("./response-rule-condition.schema").TResponseRuleConditionNode, unknown, z.core.$ZodTypeInternals<import("./response-rule-condition.schema").TResponseRuleConditionNode, unknown>>>;
         responseType: z.ZodEnum<{
             readonly BROWSER: "BROWSER";
             readonly BLOCK: "BLOCK";
@@ -64,6 +42,6 @@ export declare const ResponseRulesConfigSchema: z.ZodObject<{
             }, z.core.$strip>>;
             excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>>;
-    }, z.core.$strip>>;
+    }, z.core.$strict>>;
 }, z.core.$strip>;
 //# sourceMappingURL=response-rules-config.schema.d.ts.map

package/build/backend/models/response-rules/response-rules-config.schema.d.ts.map

@@ -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;AAOxB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYpC,CAAC"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiBhC,CAAC"}

package/build/backend/models/response-rules/response-rules-config.schema.js

@@ -6,15 +6,20 @@ const constants_1 = require("../../constants");
 const response_rule_settings_schema_1 = require("./response-rule-settings.schema");
 const response_rule_schema_1 = require("./response-rule.schema");
 const response_rules_examples_1 = require("./response-rules-examples");
-exports.ResponseRulesConfigSchema = zod_1.z.object({
-    version: zod_1.z.enum(constants_1.RESPONSE_RULES_CONFIG_VERSION).meta({
+exports.ResponseRulesConfigSchema = zod_1.z
+    .object({
+    version: zod_1.z.literal(constants_1.RESPONSE_RULES_CONFIG_VERSION[2]).meta({
         title: 'Response Rules Config Version',
-        markdownDescription: 'Version of the **response rules** config. Currently supported version is **1**.',
+        markdownDescription: 'Version of the **response rules** config. Currently supported version is **2**. Legacy version **1** configs can be migrated with `migrateResponseRulesConfig`.',
     }),
     settings: response_rule_settings_schema_1.ResponseRuleSettingsSchema,
     rules: zod_1.z.array(response_rule_schema_1.ResponseRuleSchema).meta({
         title: 'Response Rules',
-        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\`\`\``,
+        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_NESTED_CONDITIONS_RULE], null, 2)}\n\`\`\``,
         defaultSnippets: [],
     }),
+})
+    .meta({
+    title: 'Response Rules Config',
+    markdownDescription: 'Configuration of the **response rules**.',
 });

package/build/backend/models/response-rules/response-rules-examples.d.ts

@@ -1,6 +1,6 @@
-import z from 'zod';
 import type { ResponseRuleSchemaBase } from './response-rule.schema';
+import z from 'zod';
 export declare const EXAMPLES_SRR_BLANK_RULE: z.infer<typeof ResponseRuleSchemaBase>;
-export declare const EXAMPLES_SRR_BLOCK_LEGACY_CLIENTS_RULE: z.infer<typeof ResponseRuleSchemaBase>;
+export declare const EXAMPLES_SRR_NESTED_CONDITIONS_RULE: z.infer<typeof ResponseRuleSchemaBase>;
 export declare function generateResponseRuleDescription(schema: typeof ResponseRuleSchemaBase): string;
 //# sourceMappingURL=response-rules-examples.d.ts.map

package/build/backend/models/response-rules/response-rules-examples.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"response-rules-examples.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rules-examples.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAOpB,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAErE,eAAO,MAAM,uBAAuB,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAU1E,CAAC;AAEF,eAAO,MAAM,sCAAsC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAoBzF,CAAC;AAEF,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,OAAO,sBAAsB,UAcpF"}
+{"version":3,"file":"response-rules-examples.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rules-examples.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAErE,OAAO,CAAC,MAAM,KAAK,CAAC;AAQpB,eAAO,MAAM,uBAAuB,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAQ1E,CAAC;AAEF,eAAO,MAAM,mCAAmC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CA8BtF,CAAC;AAEF,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,OAAO,sBAAsB,UAcpF"}

package/build/backend/models/response-rules/response-rules-examples.js

@@ -1,38 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EXAMPLES_SRR_BLOCK_LEGACY_CLIENTS_RULE = exports.EXAMPLES_SRR_BLANK_RULE = void 0;
+exports.EXAMPLES_SRR_NESTED_CONDITIONS_RULE = exports.EXAMPLES_SRR_BLANK_RULE = void 0;
 exports.generateResponseRuleDescription = generateResponseRuleDescription;
 const constants_1 = require("../../constants");
 exports.EXAMPLES_SRR_BLANK_RULE = {
     name: 'Blank rule',
     description: 'Blank rule',
-    operator: 'AND',
     enabled: true,
-    conditions: [],
     responseType: 'BLOCK',
     responseModifications: {
         headers: [],
     },
 };
-exports.EXAMPLES_SRR_BLOCK_LEGACY_CLIENTS_RULE = {
-    name: 'Block Legacy Clients',
-    description: 'Block requests from legacy clients',
+exports.EXAMPLES_SRR_NESTED_CONDITIONS_RULE = {
+    name: 'Block Legacy Browsers',
+    description: 'Block browser requests from legacy clients',
     enabled: true,
-    operator: constants_1.RESPONSE_RULES_OPERATORS.OR,
-    conditions: [
-        {
-            headerName: 'user-agent',
-            operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
-            value: 'Hiddify',
-            caseSensitive: true,
-        },
-        {
-            headerName: 'user-agent',
-            operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
-            value: 'FoxRay',
-            caseSensitive: true,
-        },
-    ],
+    when: {
+        operator: constants_1.RESPONSE_RULES_GROUP_OPERATORS.AND,
+        conditions: [
+            {
+                headerName: 'accept',
+                operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
+                value: 'text/html',
+            },
+            {
+                operator: constants_1.RESPONSE_RULES_GROUP_OPERATORS.OR,
+                conditions: [
+                    {
+                        headerName: 'user-agent',
+                        operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
+                        value: 'Hiddify',
+                    },
+                    {
+                        headerName: 'user-agent',
+                        operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
+                        value: 'FoxRay',
+                    },
+                ],
+            },
+        ],
+    },
     responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
 };
 function generateResponseRuleDescription(schema) {
@@ -46,5 +54,5 @@ function generateResponseRuleDescription(schema) {
     const fieldsText = fields
         .map((field) => `- **${field.name}**: ${field.description}`)
         .join('\n');
-    return `Response rule configuration.\n\n**Fields:**\n${fieldsText}\n\n**Example:**\n\`\`\`json\n${JSON.stringify(exports.EXAMPLES_SRR_BLOCK_LEGACY_CLIENTS_RULE, null, 2)}\n\`\`\``;
+    return `Response rule configuration.\n\n**Fields:**\n${fieldsText}\n\n**Example:**\n\`\`\`json\n${JSON.stringify(exports.EXAMPLES_SRR_NESTED_CONDITIONS_RULE, null, 2)}\n\`\`\``;
 }

package/build/backend/models/response-rules/response-rules-legacy.schema.d.ts

@@ -0,0 +1,157 @@
+import { z } from 'zod';
+/**
+ * Frozen legacy (version 1) response rules config.
+ *
+ * Kept only to accept old configs and migrate them to version 2
+ * via `migrateResponseRulesConfig`. Do not extend.
+ */
+export declare const ResponseRuleLegacyConditionSchema: z.ZodObject<{
+    headerName: z.ZodString;
+    operator: z.ZodEnum<{
+        readonly EQUALS: "EQUALS";
+        readonly NOT_EQUALS: "NOT_EQUALS";
+        readonly CONTAINS: "CONTAINS";
+        readonly NOT_CONTAINS: "NOT_CONTAINS";
+        readonly STARTS_WITH: "STARTS_WITH";
+        readonly NOT_STARTS_WITH: "NOT_STARTS_WITH";
+        readonly ENDS_WITH: "ENDS_WITH";
+        readonly NOT_ENDS_WITH: "NOT_ENDS_WITH";
+        readonly REGEX: "REGEX";
+        readonly NOT_REGEX: "NOT_REGEX";
+        readonly EXISTS: "EXISTS";
+        readonly NOT_EXISTS: "NOT_EXISTS";
+    }>;
+    value: z.ZodString;
+    caseSensitive: z.ZodBoolean;
+}, z.core.$strip>;
+export declare const ResponseRuleLegacySchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodBoolean;
+    operator: z.ZodEnum<{
+        readonly AND: "AND";
+        readonly OR: "OR";
+    }>;
+    conditions: z.ZodArray<z.ZodObject<{
+        headerName: z.ZodString;
+        operator: z.ZodEnum<{
+            readonly EQUALS: "EQUALS";
+            readonly NOT_EQUALS: "NOT_EQUALS";
+            readonly CONTAINS: "CONTAINS";
+            readonly NOT_CONTAINS: "NOT_CONTAINS";
+            readonly STARTS_WITH: "STARTS_WITH";
+            readonly NOT_STARTS_WITH: "NOT_STARTS_WITH";
+            readonly ENDS_WITH: "ENDS_WITH";
+            readonly NOT_ENDS_WITH: "NOT_ENDS_WITH";
+            readonly REGEX: "REGEX";
+            readonly NOT_REGEX: "NOT_REGEX";
+            readonly EXISTS: "EXISTS";
+            readonly NOT_EXISTS: "NOT_EXISTS";
+        }>;
+        value: z.ZodString;
+        caseSensitive: z.ZodBoolean;
+    }, z.core.$strip>>;
+    responseType: z.ZodEnum<{
+        readonly BROWSER: "BROWSER";
+        readonly BLOCK: "BLOCK";
+        readonly STATUS_CODE_404: "STATUS_CODE_404";
+        readonly STATUS_CODE_451: "STATUS_CODE_451";
+        readonly SOCKET_DROP: "SOCKET_DROP";
+        readonly XRAY_JSON: "XRAY_JSON";
+        readonly XRAY_BASE64: "XRAY_BASE64";
+        readonly MIHOMO: "MIHOMO";
+        readonly STASH: "STASH";
+        readonly CLASH: "CLASH";
+        readonly SINGBOX: "SINGBOX";
+    }>;
+    responseModifications: z.ZodOptional<z.ZodObject<{
+        headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodString;
+        }, z.core.$strip>>>;
+        applyHeadersToEnd: z.ZodOptional<z.ZodBoolean>;
+        subscriptionTemplate: z.ZodOptional<z.ZodString>;
+        ignoreHostXrayJsonTemplate: z.ZodOptional<z.ZodBoolean>;
+        ignoreServeJsonAtBaseSubscription: z.ZodOptional<z.ZodBoolean>;
+        additionalExtendedClientsRegex: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        disableHwidCheck: z.ZodOptional<z.ZodBoolean>;
+        encryption: z.ZodOptional<z.ZodObject<{
+            method: z.ZodEnum<{
+                age1: "age1";
+                age1pq1: "age1pq1";
+            }>;
+            key: z.ZodString;
+        }, z.core.$strip>>;
+        excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const ResponseRulesLegacyConfigSchema: z.ZodObject<{
+    version: z.ZodLiteral<"1">;
+    settings: z.ZodOptional<z.ZodObject<{
+        disableSubscriptionAccessByPath: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    rules: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodBoolean;
+        operator: z.ZodEnum<{
+            readonly AND: "AND";
+            readonly OR: "OR";
+        }>;
+        conditions: z.ZodArray<z.ZodObject<{
+            headerName: z.ZodString;
+            operator: z.ZodEnum<{
+                readonly EQUALS: "EQUALS";
+                readonly NOT_EQUALS: "NOT_EQUALS";
+                readonly CONTAINS: "CONTAINS";
+                readonly NOT_CONTAINS: "NOT_CONTAINS";
+                readonly STARTS_WITH: "STARTS_WITH";
+                readonly NOT_STARTS_WITH: "NOT_STARTS_WITH";
+                readonly ENDS_WITH: "ENDS_WITH";
+                readonly NOT_ENDS_WITH: "NOT_ENDS_WITH";
+                readonly REGEX: "REGEX";
+                readonly NOT_REGEX: "NOT_REGEX";
+                readonly EXISTS: "EXISTS";
+                readonly NOT_EXISTS: "NOT_EXISTS";
+            }>;
+            value: z.ZodString;
+            caseSensitive: z.ZodBoolean;
+        }, z.core.$strip>>;
+        responseType: z.ZodEnum<{
+            readonly BROWSER: "BROWSER";
+            readonly BLOCK: "BLOCK";
+            readonly STATUS_CODE_404: "STATUS_CODE_404";
+            readonly STATUS_CODE_451: "STATUS_CODE_451";
+            readonly SOCKET_DROP: "SOCKET_DROP";
+            readonly XRAY_JSON: "XRAY_JSON";
+            readonly XRAY_BASE64: "XRAY_BASE64";
+            readonly MIHOMO: "MIHOMO";
+            readonly STASH: "STASH";
+            readonly CLASH: "CLASH";
+            readonly SINGBOX: "SINGBOX";
+        }>;
+        responseModifications: z.ZodOptional<z.ZodObject<{
+            headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                key: z.ZodString;
+                value: z.ZodString;
+            }, z.core.$strip>>>;
+            applyHeadersToEnd: z.ZodOptional<z.ZodBoolean>;
+            subscriptionTemplate: z.ZodOptional<z.ZodString>;
+            ignoreHostXrayJsonTemplate: z.ZodOptional<z.ZodBoolean>;
+            ignoreServeJsonAtBaseSubscription: z.ZodOptional<z.ZodBoolean>;
+            additionalExtendedClientsRegex: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            disableHwidCheck: z.ZodOptional<z.ZodBoolean>;
+            encryption: z.ZodOptional<z.ZodObject<{
+                method: z.ZodEnum<{
+                    age1: "age1";
+                    age1pq1: "age1pq1";
+                }>;
+                key: z.ZodString;
+            }, z.core.$strip>>;
+            excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type TResponseRuleLegacy = z.infer<typeof ResponseRuleLegacySchema>;
+export type TResponseRulesLegacyConfig = z.infer<typeof ResponseRulesLegacyConfigSchema>;
+//# sourceMappingURL=response-rules-legacy.schema.d.ts.map

package/build/backend/models/response-rules/response-rules-legacy.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-rules-legacy.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rules-legacy.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAWxB;;;;;GAKG;AAEH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;iBAK5C,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAQnC,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAI1C,CAAC;AAEH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC3E,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC"}

package/build/backend/models/response-rules/response-rules-legacy.schema.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseRulesLegacyConfigSchema = exports.ResponseRuleLegacySchema = exports.ResponseRuleLegacyConditionSchema = void 0;
+const zod_1 = require("zod");
+const constants_1 = require("../../constants");
+const response_rule_modifications_schema_1 = require("./response-rule-modifications.schema");
+const response_rule_settings_schema_1 = require("./response-rule-settings.schema");
+/**
+ * Frozen legacy (version 1) response rules config.
+ *
+ * Kept only to accept old configs and migrate them to version 2
+ * via `migrateResponseRulesConfig`. Do not extend.
+ */
+exports.ResponseRuleLegacyConditionSchema = zod_1.z.object({
+    headerName: zod_1.z.string(),
+    operator: zod_1.z.enum(constants_1.RESPONSE_RULES_CONDITION_OPERATORS),
+    value: zod_1.z.string(),
+    caseSensitive: zod_1.z.boolean(),
+});
+exports.ResponseRuleLegacySchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    description: zod_1.z.string().optional(),
+    enabled: zod_1.z.boolean(),
+    operator: zod_1.z.enum(constants_1.RESPONSE_RULES_OPERATORS),
+    conditions: zod_1.z.array(exports.ResponseRuleLegacyConditionSchema),
+    responseType: zod_1.z.enum(constants_1.RESPONSE_RULES_RESPONSE_TYPES),
+    responseModifications: response_rule_modifications_schema_1.ResponseRuleModificationsSchema,
+});
+exports.ResponseRulesLegacyConfigSchema = zod_1.z.object({
+    version: zod_1.z.literal(constants_1.RESPONSE_RULES_CONFIG_VERSION[1]),
+    settings: response_rule_settings_schema_1.ResponseRuleSettingsSchema,
+    rules: zod_1.z.array(exports.ResponseRuleLegacySchema),
+});

package/build/backend/models/response-rules/response-rules-migration.d.ts

@@ -0,0 +1,10 @@
+import type { ResponseRulesConfigSchema } from './response-rules-config.schema';
+import type { TResponseRulesLegacyConfig } from './response-rules-legacy.schema';
+import type { z } from 'zod';
+type TResponseRulesConfig = z.infer<typeof ResponseRulesConfigSchema>;
+/**
+ * Migrates a legacy (version 1) response rules config to version 2.
+ */
+export declare function migrateResponseRulesConfig(config: TResponseRulesConfig | TResponseRulesLegacyConfig): TResponseRulesConfig;
+export {};
+//# sourceMappingURL=response-rules-migration.d.ts.map

package/build/backend/models/response-rules/response-rules-migration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-rules-migration.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rules-migration.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AAChF,OAAO,KAAK,EAGR,0BAA0B,EAC7B,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAK7B,KAAK,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAGtE;;GAEG;AACH,wBAAgB,0BAA0B,CACtC,MAAM,EAAE,oBAAoB,GAAG,0BAA0B,GAC1D,oBAAoB,CAUtB"}

package/build/backend/models/response-rules/response-rules-migration.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateResponseRulesConfig = migrateResponseRulesConfig;
+const constants_1 = require("../../constants");
+/**
+ * Migrates a legacy (version 1) response rules config to version 2.
+ */
+function migrateResponseRulesConfig(config) {
+    if (config.version === constants_1.RESPONSE_RULES_CONFIG_VERSION[2]) {
+        return config;
+    }
+    return {
+        version: constants_1.RESPONSE_RULES_CONFIG_VERSION[2],
+        ...(config.settings !== undefined && { settings: config.settings }),
+        rules: config.rules.map(migrateLegacyResponseRule),
+    };
+}
+function migrateLegacyResponseRule(rule) {
+    const { operator, conditions, ...rest } = rule;
+    const when = migrateLegacyConditions(operator, conditions);
+    return {
+        ...rest,
+        ...(when !== undefined && { when }),
+    };
+}
+function migrateLegacyConditions(operator, conditions) {
+    if (conditions.length === 0) {
+        return undefined;
+    }
+    if (conditions.length === 1) {
+        return migrateLegacyCondition(conditions[0]);
+    }
+    return {
+        operator,
+        conditions: conditions.map(migrateLegacyCondition),
+    };
+}
+function migrateLegacyCondition(condition) {
+    return {
+        headerName: condition.headerName,
+        operator: condition.operator,
+        value: condition.value,
+        ...(condition.caseSensitive && { caseSensitive: true }),
+    };
+}

package/build/backend/models/subscription-settings.schema.d.ts

@@ -14,9 +14,7 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
     customResponseHeaders: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
     randomizeHosts: z.ZodBoolean;
     responseRules: z.ZodNullable<z.ZodObject<{
-        version: z.ZodEnum<{
-            readonly 1: "1";
-        }>;
+        version: z.ZodLiteral<"2">;
         settings: z.ZodOptional<z.ZodObject<{
             disableSubscriptionAccessByPath: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strip>>;
@@ -24,27 +22,7 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
             name: z.ZodString;
             description: z.ZodOptional<z.ZodString>;
             enabled: z.ZodBoolean;
-            operator: z.ZodEnum<{
-                readonly AND: "AND";
-                readonly OR: "OR";
-            }>;
-            conditions: z.ZodArray<z.ZodObject<{
-                headerName: z.ZodString;
-                operator: z.ZodEnum<{
-                    readonly EQUALS: "EQUALS";
-                    readonly NOT_EQUALS: "NOT_EQUALS";
-                    readonly CONTAINS: "CONTAINS";
-                    readonly NOT_CONTAINS: "NOT_CONTAINS";
-                    readonly STARTS_WITH: "STARTS_WITH";
-                    readonly NOT_STARTS_WITH: "NOT_STARTS_WITH";
-                    readonly ENDS_WITH: "ENDS_WITH";
-                    readonly NOT_ENDS_WITH: "NOT_ENDS_WITH";
-                    readonly REGEX: "REGEX";
-                    readonly NOT_REGEX: "NOT_REGEX";
-                }>;
-                value: z.ZodString;
-                caseSensitive: z.ZodBoolean;
-            }, z.core.$strip>>;
+            when: z.ZodOptional<z.ZodType<import("./response-rules").TResponseRuleConditionNode, unknown, z.core.$ZodTypeInternals<import("./response-rules").TResponseRuleConditionNode, unknown>>>;
             responseType: z.ZodEnum<{
                 readonly BROWSER: "BROWSER";
                 readonly BLOCK: "BLOCK";
@@ -78,7 +56,7 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
                 }, z.core.$strip>>;
                 excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
             }, z.core.$strip>>;
-        }, z.core.$strip>>;
+        }, z.core.$strict>>;
     }, z.core.$strip>>;
     hwidSettings: z.ZodNullable<z.ZodObject<{
         enabled: z.ZodBoolean;

package/build/backend/models/subscription-settings.schema.d.ts.map

@@ -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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiBrC,CAAC"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiBrC,CAAC"}