@remnawave/backend-contract 2.9.31 → 2.9.32

package/build/backend/commands/subscription-settings/get-subscription-settings.command.d.ts

@@ -19,9 +19,7 @@ export declare namespace GetSubscriptionSettingsCommand {
             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>>;
@@ -29,27 +27,7 @@ export declare namespace GetSubscriptionSettingsCommand {
                     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("../../models").TResponseRuleConditionNode, unknown, z.core.$ZodTypeInternals<import("../../models").TResponseRuleConditionNode, unknown>>>;
                     responseType: z.ZodEnum<{
                         readonly BROWSER: "BROWSER";
                         readonly BLOCK: "BLOCK";
@@ -83,7 +61,7 @@ export declare namespace GetSubscriptionSettingsCommand {
                         }, 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/commands/subscription-settings/get-subscription-settings.command.d.ts.map

@@ -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,2CAK3B,CAAC;IAEK,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAEzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}
+{"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,2CAK3B,CAAC;IAEK,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAEzB,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

@@ -18,9 +18,7 @@ export declare namespace UpdateSubscriptionSettingsCommand {
         customResponseHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         randomizeHosts: z.ZodOptional<z.ZodBoolean>;
         responseRules: z.ZodOptional<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>>;
@@ -28,27 +26,7 @@ export declare namespace UpdateSubscriptionSettingsCommand {
                 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("../../models").TResponseRuleConditionNode, unknown, z.core.$ZodTypeInternals<import("../../models").TResponseRuleConditionNode, unknown>>>;
                 responseType: z.ZodEnum<{
                     readonly BROWSER: "BROWSER";
                     readonly BLOCK: "BLOCK";
@@ -82,7 +60,7 @@ export declare namespace UpdateSubscriptionSettingsCommand {
                     }, z.core.$strip>>;
                     excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 }, z.core.$strip>>;
-            }, z.core.$strip>>;
+            }, z.core.$strict>>;
         }, z.core.$strip>>;
         hwidSettings: z.ZodOptional<z.ZodObject<{
             enabled: z.ZodBoolean;
@@ -106,9 +84,7 @@ export declare namespace UpdateSubscriptionSettingsCommand {
             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>>;
@@ -116,27 +92,7 @@ export declare namespace UpdateSubscriptionSettingsCommand {
                     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("../../models").TResponseRuleConditionNode, unknown, z.core.$ZodTypeInternals<import("../../models").TResponseRuleConditionNode, unknown>>>;
                     responseType: z.ZodEnum<{
                         readonly BROWSER: "BROWSER";
                         readonly BLOCK: "BLOCK";
@@ -170,7 +126,7 @@ export declare namespace UpdateSubscriptionSettingsCommand {
                         }, 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/commands/subscription-settings/update-subscription-settings.command.d.ts.map

@@ -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,2CAK3B,CAAC;IAEK,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmB5B,CAAC;IAEI,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAEzB,CAAC;IAEH,KAAY,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;IAC5D,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}
+{"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,2CAK3B,CAAC;IAEK,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAmB5B,CAAC;IAEI,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAEzB,CAAC;IAEH,KAAY,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;IAC5D,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/backend/commands/system/testers/test-srr-matcher.command.d.ts

@@ -5,9 +5,7 @@ export declare namespace TestSrrMatcherCommand {
     const endpointDetails: import("../../../constants").EndpointDetails;
     const RequestBodySchema: z.ZodObject<{
         responseRules: 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>>;
@@ -15,27 +13,7 @@ export declare namespace TestSrrMatcherCommand {
                 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("../../../models").TResponseRuleConditionNode, unknown, z.core.$ZodTypeInternals<import("../../../models").TResponseRuleConditionNode, unknown>>>;
                 responseType: z.ZodEnum<{
                     readonly BROWSER: "BROWSER";
                     readonly BLOCK: "BLOCK";
@@ -69,7 +47,7 @@ export declare namespace TestSrrMatcherCommand {
                     }, z.core.$strip>>;
                     excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 }, z.core.$strip>>;
-            }, z.core.$strip>>;
+            }, z.core.$strict>>;
         }, z.core.$strip>;
     }, z.core.$strip>;
     const ResponseSchema: z.ZodObject<{
@@ -92,27 +70,7 @@ export declare namespace TestSrrMatcherCommand {
                 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("../../../models").TResponseRuleConditionNode, unknown, z.core.$ZodTypeInternals<import("../../../models").TResponseRuleConditionNode, unknown>>>;
                 responseType: z.ZodEnum<{
                     readonly BROWSER: "BROWSER";
                     readonly BLOCK: "BLOCK";
@@ -146,7 +104,7 @@ export declare namespace TestSrrMatcherCommand {
                     }, z.core.$strip>>;
                     excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
                 }, z.core.$strip>>;
-            }, z.core.$strip>>;
+            }, z.core.$strict>>;
             inputHeaders: z.ZodRecord<z.ZodString, z.ZodString>;
             outputHeaders: z.ZodRecord<z.ZodString, z.ZodString>;
         }, z.core.$strip>;

package/build/backend/commands/system/testers/test-srr-matcher.command.d.ts.map

@@ -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,8CAK3B,CAAC;IACK,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAE5B,CAAC;IAEI,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAQzB,CAAC;IAEH,KAAY,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;IAC5D,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}
+{"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,8CAK3B,CAAC;IACK,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAE5B,CAAC;IAEI,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAQzB,CAAC;IAEH,KAAY,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;IAC5D,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/backend/constants/response-rules/response-rules.contants.d.ts

@@ -1,12 +1,28 @@
 export declare const RESPONSE_RULES_CONFIG_VERSION: {
     readonly 1: "1";
+    readonly 2: "2";
 };
+/**
+ * Version 1
+ */
 export declare const RESPONSE_RULES_OPERATORS: {
     readonly AND: "AND";
     readonly OR: "OR";
 };
-export declare const RESPONSE_RULE_CONDITION_TYPES: {
-    readonly HEADER: "HEADER";
+/**
+ * Version 2
+ */
+export declare const RESPONSE_RULES_GROUP_OPERATORS: {
+    readonly AND: "AND";
+    readonly OR: "OR";
+    readonly NOT: "NOT";
+};
+export type TResponseRulesGroupOperator = keyof typeof RESPONSE_RULES_GROUP_OPERATORS;
+export declare const RESPONSE_RULES_GROUP_OPERATORS_VALUES: ("AND" | "OR" | "NOT")[];
+export declare const RESPONSE_RULES_GROUP_OPERATORS_DESCRIPTION: {
+    readonly AND: "Matches only if **all** nested conditions match. `conditions.every()`";
+    readonly OR: "Matches if **at least one** nested condition matches. `conditions.some()`";
+    readonly NOT: "Inverts the result of the nested **condition**. `!condition`";
 };
 export declare const RESPONSE_RULES_CONDITION_OPERATORS: {
     readonly EQUALS: "EQUALS";
@@ -19,6 +35,8 @@ export declare const RESPONSE_RULES_CONDITION_OPERATORS: {
     readonly NOT_ENDS_WITH: "NOT_ENDS_WITH";
     readonly REGEX: "REGEX";
     readonly NOT_REGEX: "NOT_REGEX";
+    readonly EXISTS: "EXISTS";
+    readonly NOT_EXISTS: "NOT_EXISTS";
 };
 export declare const RESPONSE_RULES_RESPONSE_TYPES: {
     readonly BROWSER: "BROWSER";
@@ -39,7 +57,7 @@ export type TResponseRulesResponseTypeKeys = (typeof RESPONSE_RULES_RESPONSE_TYP
 export type TResponseRulesConditionOperator = [
     keyof typeof RESPONSE_RULES_CONDITION_OPERATORS
 ][number];
-export declare const RESPONSE_RULES_CONDITION_OPERATORS_VALUES: ("EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX")[];
+export declare const RESPONSE_RULES_CONDITION_OPERATORS_VALUES: ("EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX" | "EXISTS" | "NOT_EXISTS")[];
 export type TResponseRulesConditionOperatorKeys = (typeof RESPONSE_RULES_CONDITION_OPERATORS)[keyof typeof RESPONSE_RULES_CONDITION_OPERATORS];
 export declare const RESPONSE_RULES_RESPONSE_TYPES_DESCRIPTION: {
     readonly XRAY_JSON: "Return **subscription** in XRAY-JSON format. (Using `Xray Json` template)";
@@ -65,5 +83,7 @@ export declare const RESPONSE_RULES_CONDITION_OPERATORS_DESCRIPTION: {
     readonly NOT_ENDS_WITH: "Confirms the header value does not end with the specified string. `!string.endsWith()`";
     readonly REGEX: "Evaluates if the header value matches the specified regular expression pattern. `regex.test()`";
     readonly NOT_REGEX: "Evaluates if the header value does not match the specified regular expression pattern. `!regex.test()`";
+    readonly EXISTS: "Checks that the header is present in the request, regardless of its value. `value` is not required. `string !== undefined`";
+    readonly NOT_EXISTS: "Checks that the header is not present in the request. `value` is not required. `string === undefined`";
 };
 //# sourceMappingURL=response-rules.contants.d.ts.map

package/build/backend/constants/response-rules/response-rules.contants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"response-rules.contants.d.ts","sourceRoot":"","sources":["../../../../constants/response-rules/response-rules.contants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,6BAA6B;;CAEhC,CAAC;AAEX,eAAO,MAAM,wBAAwB;;;CAG3B,CAAC;AAEX,eAAO,MAAM,6BAA6B;;CAEhC,CAAC;AAEX,eAAO,MAAM,kCAAkC;;;;;;;;;;;CAWrC,CAAC;AAEX,eAAO,MAAM,6BAA6B;;;;;;;;;;;;CAOhC,CAAC;AAEX,MAAM,MAAM,0BAA0B,GAAG,CAAC,MAAM,OAAO,6BAA6B,CAAC,CAAC,MAAM,CAAC,CAAC;AAC9F,eAAO,MAAM,oCAAoC,0JAA+C,CAAC;AACjG,MAAM,MAAM,8BAA8B,GACtC,CAAC,OAAO,6BAA6B,CAAC,CAAC,MAAM,OAAO,6BAA6B,CAAC,CAAC;AAEvF,MAAM,MAAM,+BAA+B,GAAG;IAC1C,MAAM,OAAO,kCAAkC;CAClD,CAAC,MAAM,CAAC,CAAC;AACV,eAAO,MAAM,yCAAyC,uJAErD,CAAC;AACF,MAAM,MAAM,mCAAmC,GAC3C,CAAC,OAAO,kCAAkC,CAAC,CAAC,MAAM,OAAO,kCAAkC,CAAC,CAAC;AAEjG,eAAO,MAAM,yCAAyC;;;;;;;;;;;;CAqB5C,CAAC;AAEX,eAAO,MAAM,8CAA8C;;;;;;;;;;;CAqBjD,CAAC"}
+{"version":3,"file":"response-rules.contants.d.ts","sourceRoot":"","sources":["../../../../constants/response-rules/response-rules.contants.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,6BAA6B;;;CAGhC,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,wBAAwB;;;CAG3B,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,8BAA8B;;;;CAIjC,CAAC;AAEX,MAAM,MAAM,2BAA2B,GAAG,MAAM,OAAO,8BAA8B,CAAC;AACtF,eAAO,MAAM,qCAAqC,0BAAgD,CAAC;AAEnG,eAAO,MAAM,0CAA0C;;;;CAO7C,CAAC;AAEX,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;CAarC,CAAC;AAEX,eAAO,MAAM,6BAA6B;;;;;;;;;;;;CAOhC,CAAC;AAEX,MAAM,MAAM,0BAA0B,GAAG,CAAC,MAAM,OAAO,6BAA6B,CAAC,CAAC,MAAM,CAAC,CAAC;AAC9F,eAAO,MAAM,oCAAoC,0JAA+C,CAAC;AACjG,MAAM,MAAM,8BAA8B,GACtC,CAAC,OAAO,6BAA6B,CAAC,CAAC,MAAM,OAAO,6BAA6B,CAAC,CAAC;AAEvF,MAAM,MAAM,+BAA+B,GAAG;IAC1C,MAAM,OAAO,kCAAkC;CAClD,CAAC,MAAM,CAAC,CAAC;AACV,eAAO,MAAM,yCAAyC,iLAErD,CAAC;AACF,MAAM,MAAM,mCAAmC,GAC3C,CAAC,OAAO,kCAAkC,CAAC,CAAC,MAAM,OAAO,kCAAkC,CAAC,CAAC;AAEjG,eAAO,MAAM,yCAAyC;;;;;;;;;;;;CAqB5C,CAAC;AAEX,eAAO,MAAM,8CAA8C;;;;;;;;;;;;;CAyBjD,CAAC"}

package/build/backend/constants/response-rules/response-rules.contants.js

@@ -1,16 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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;
+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_RULES_GROUP_OPERATORS_DESCRIPTION = exports.RESPONSE_RULES_GROUP_OPERATORS_VALUES = exports.RESPONSE_RULES_GROUP_OPERATORS = exports.RESPONSE_RULES_OPERATORS = exports.RESPONSE_RULES_CONFIG_VERSION = void 0;
 const subscription_template_1 = require("../subscription-template");
 exports.RESPONSE_RULES_CONFIG_VERSION = {
     1: '1',
+    2: '2',
 };
+/**
+ * Version 1
+ */
 exports.RESPONSE_RULES_OPERATORS = {
     AND: 'AND',
     OR: 'OR',
 };
-exports.RESPONSE_RULE_CONDITION_TYPES = {
-    HEADER: 'HEADER',
+/**
+ * Version 2
+ */
+exports.RESPONSE_RULES_GROUP_OPERATORS = {
+    AND: 'AND',
+    OR: 'OR',
+    NOT: 'NOT',
+};
+exports.RESPONSE_RULES_GROUP_OPERATORS_VALUES = Object.values(exports.RESPONSE_RULES_GROUP_OPERATORS);
+exports.RESPONSE_RULES_GROUP_OPERATORS_DESCRIPTION = {
+    [exports.RESPONSE_RULES_GROUP_OPERATORS.AND]: 'Matches only if **all** nested conditions match. `conditions.every()`',
+    [exports.RESPONSE_RULES_GROUP_OPERATORS.OR]: 'Matches if **at least one** nested condition matches. `conditions.some()`',
+    [exports.RESPONSE_RULES_GROUP_OPERATORS.NOT]: 'Inverts the result of the nested **condition**. `!condition`',
 };
 exports.RESPONSE_RULES_CONDITION_OPERATORS = {
     EQUALS: 'EQUALS',
@@ -23,6 +38,8 @@ exports.RESPONSE_RULES_CONDITION_OPERATORS = {
     NOT_ENDS_WITH: 'NOT_ENDS_WITH',
     REGEX: 'REGEX',
     NOT_REGEX: 'NOT_REGEX',
+    EXISTS: 'EXISTS',
+    NOT_EXISTS: 'NOT_EXISTS',
 };
 exports.RESPONSE_RULES_RESPONSE_TYPES = {
     ...subscription_template_1.SUBSCRIPTION_TEMPLATE_TYPE,
@@ -58,4 +75,6 @@ exports.RESPONSE_RULES_CONDITION_OPERATORS_DESCRIPTION = {
     [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_ENDS_WITH]: 'Confirms the header value does not end with the specified string. `!string.endsWith()`',
     [exports.RESPONSE_RULES_CONDITION_OPERATORS.REGEX]: 'Evaluates if the header value matches the specified regular expression pattern. `regex.test()`',
     [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_REGEX]: 'Evaluates if the header value does not match the specified regular expression pattern. `!regex.test()`',
+    [exports.RESPONSE_RULES_CONDITION_OPERATORS.EXISTS]: 'Checks that the header is present in the request, regardless of its value. `value` is not required. `string !== undefined`',
+    [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_EXISTS]: 'Checks that the header is not present in the request. `value` is not required. `string === undefined`',
 };

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

@@ -2,4 +2,6 @@ export * from './response-rule-condition.schema';
 export * from './response-rule-modifications.schema';
 export * from './response-rule.schema';
 export * from './response-rules-config.schema';
+export * from './response-rules-legacy.schema';
+export * from './response-rules-migration';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,sCAAsC,CAAC;AACrD,cAAc,wBAAwB,CAAC;AACvC,cAAc,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,sCAAsC,CAAC;AACrD,cAAc,wBAAwB,CAAC;AACvC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC"}

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

@@ -18,3 +18,5 @@ __exportStar(require("./response-rule-condition.schema"), exports);
 __exportStar(require("./response-rule-modifications.schema"), exports);
 __exportStar(require("./response-rule.schema"), exports);
 __exportStar(require("./response-rules-config.schema"), exports);
+__exportStar(require("./response-rules-legacy.schema"), exports);
+__exportStar(require("./response-rules-migration"), exports);

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

@@ -1,4 +1,22 @@
 import { z } from 'zod';
+import { RESPONSE_RULES_GROUP_OPERATORS, TResponseRulesConditionOperatorKeys } from '../../constants';
+export declare const RESPONSE_RULES_MAX_CONDITION_DEPTH = 10;
+export declare const RESPONSE_RULES_MAX_CONDITION_NODES = 100;
+export interface IResponseRuleCondition {
+    caseSensitive?: boolean;
+    headerName: string;
+    operator: TResponseRulesConditionOperatorKeys;
+    value?: string;
+}
+export interface IResponseRuleConditionGroup {
+    conditions: TResponseRuleConditionNode[];
+    operator: typeof RESPONSE_RULES_GROUP_OPERATORS.AND | typeof RESPONSE_RULES_GROUP_OPERATORS.OR;
+}
+export interface IResponseRuleConditionNot {
+    condition: TResponseRuleConditionNode;
+    operator: typeof RESPONSE_RULES_GROUP_OPERATORS.NOT;
+}
+export type TResponseRuleConditionNode = IResponseRuleCondition | IResponseRuleConditionGroup | IResponseRuleConditionNot;
 export declare const ResponseRuleConditionSchema: z.ZodObject<{
     headerName: z.ZodString;
     operator: z.ZodEnum<{
@@ -12,8 +30,27 @@ export declare const ResponseRuleConditionSchema: z.ZodObject<{
         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>;
+    value: z.ZodOptional<z.ZodString>;
+    caseSensitive: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export declare const ResponseRuleConditionGroupSchema: z.ZodObject<{
+    operator: z.ZodEnum<{
+        AND: "AND";
+        OR: "OR";
+    }>;
+    conditions: z.ZodArray<z.ZodType<TResponseRuleConditionNode, unknown, z.core.$ZodTypeInternals<TResponseRuleConditionNode, unknown>>>;
+}, z.core.$strict>;
+export declare const ResponseRuleConditionNotSchema: z.ZodObject<{
+    operator: z.ZodLiteral<"NOT">;
+    condition: z.ZodType<TResponseRuleConditionNode, unknown, z.core.$ZodTypeInternals<TResponseRuleConditionNode, unknown>>;
+}, z.core.$strict>;
+export declare const ResponseRuleConditionNodeSchema: z.ZodType<TResponseRuleConditionNode>;
+export declare function forEachResponseRuleCondition(node: TResponseRuleConditionNode, callback: (condition: IResponseRuleCondition) => void): void;
+export declare function measureResponseRuleConditionTree(node: TResponseRuleConditionNode): {
+    depth: number;
+    nodes: number;
+};
 //# sourceMappingURL=response-rule-condition.schema.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"response-rule-condition.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rule-condition.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;iBA8ClC,CAAC"}
+{"version":3,"file":"response-rule-condition.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rule-condition.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAGH,8BAA8B,EAE9B,mCAAmC,EACtC,MAAM,iBAAiB,CAAC;AAEzB,eAAO,MAAM,kCAAkC,KAAK,CAAC;AACrD,eAAO,MAAM,kCAAkC,MAAM,CAAC;AAEtD,MAAM,WAAW,sBAAsB;IACnC,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,mCAAmC,CAAC;IAC9C,KAAK,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,2BAA2B;IACxC,UAAU,EAAE,0BAA0B,EAAE,CAAC;IACzC,QAAQ,EACF,OAAO,8BAA8B,CAAC,GAAG,GACzC,OAAO,8BAA8B,CAAC,EAAE,CAAC;CAClD;AAED,MAAM,WAAW,yBAAyB;IACtC,SAAS,EAAE,0BAA0B,CAAC;IACtC,QAAQ,EAAE,OAAO,8BAA8B,CAAC,GAAG,CAAC;CACvD;AAED,MAAM,MAAM,0BAA0B,GAChC,sBAAsB,GACtB,2BAA2B,GAC3B,yBAAyB,CAAC;AAOhC,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;kBAsElC,CAAC;AAEP,eAAO,MAAM,gCAAgC;;;;;;kBAgDvC,CAAC;AAEP,eAAO,MAAM,8BAA8B;;;kBA+BrC,CAAC;AAEP,eAAO,MAAM,+BAA+B,EAAE,CAAC,CAAC,OAAO,CAAC,0BAA0B,CAY5E,CAAC;AAEP,wBAAgB,4BAA4B,CACxC,IAAI,EAAE,0BAA0B,EAChC,QAAQ,EAAE,CAAC,SAAS,EAAE,sBAAsB,KAAK,IAAI,GACtD,IAAI,CAcN;AAED,wBAAgB,gCAAgC,CAAC,IAAI,EAAE,0BAA0B,GAAG;IAChF,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACjB,CAoBA"}

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

@@ -1,10 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResponseRuleConditionSchema = void 0;
+exports.ResponseRuleConditionNodeSchema = exports.ResponseRuleConditionNotSchema = exports.ResponseRuleConditionGroupSchema = exports.ResponseRuleConditionSchema = exports.RESPONSE_RULES_MAX_CONDITION_NODES = exports.RESPONSE_RULES_MAX_CONDITION_DEPTH = void 0;
+exports.forEachResponseRuleCondition = forEachResponseRuleCondition;
+exports.measureResponseRuleConditionTree = measureResponseRuleConditionTree;
 const zod_1 = require("zod");
 const constants_1 = require("../../constants");
+exports.RESPONSE_RULES_MAX_CONDITION_DEPTH = 10;
+exports.RESPONSE_RULES_MAX_CONDITION_NODES = 100;
+const OPERATORS_WITHOUT_VALUE = [
+    constants_1.RESPONSE_RULES_CONDITION_OPERATORS.EXISTS,
+    constants_1.RESPONSE_RULES_CONDITION_OPERATORS.NOT_EXISTS,
+];
 exports.ResponseRuleConditionSchema = zod_1.z
-    .object({
+    .strictObject({
     headerName: zod_1.z
         .string()
         .regex(/^[!#$%&'*+\-.0-9A-Z^_`a-z|~]+$/, 'Invalid header name. Only letters(a-z, A-Z), numbers(0-9), underscores(_) and hyphens(-) are allowed.')
@@ -21,14 +29,27 @@ exports.ResponseRuleConditionSchema = zod_1.z
         .string()
         .min(1, 'Value is required')
         .max(255, 'Value must be less than 255 characters')
+        .optional()
         .meta({
-        markdownDescription: '**Value** to check against the **headerName**.',
+        markdownDescription: '**Value** to check against the **headerName**. Required for all operators except `EXISTS` and `NOT_EXISTS`.',
     }),
-    caseSensitive: zod_1.z.boolean().meta({
-        markdownDescription: 'Whether the value is **case sensitive**. \n\n - `true`: the value will be compared as is. \n\n - `false`: the value will be lowercased **before** comparison.',
+    caseSensitive: zod_1.z.boolean().optional().meta({
+        default: false,
+        markdownDescription: 'Whether the value is **case sensitive**. Optional, defaults to `false`. \n\n - `true`: the value will be compared as is. \n\n - `false`: the value will be lowercased **before** comparison.',
     }),
+})
+    .superRefine((condition, ctx) => {
+    if (condition.value === undefined &&
+        !OPERATORS_WITHOUT_VALUE.includes(condition.operator)) {
+        ctx.addIssue({
+            code: 'custom',
+            path: ['value'],
+            message: `Value is required for operator "${condition.operator}".`,
+        });
+    }
 })
     .meta({
+    title: 'Condition',
     markdownDescription: 'Condition to check against the **headerName**.',
     defaultSnippets: [
         {
@@ -38,8 +59,137 @@ exports.ResponseRuleConditionSchema = zod_1.z
                 headerName: 'accept',
                 operator: 'CONTAINS',
                 value: 'text/html',
-                caseSensitive: true,
+            },
+        },
+        {
+            label: 'Examples: Check if header exists',
+            markdownDescription: 'Condition to check if **headerName** is present in the request',
+            body: {
+                headerName: 'x-hwid',
+                operator: 'EXISTS',
+            },
+        },
+    ],
+});
+exports.ResponseRuleConditionGroupSchema = zod_1.z
+    .strictObject({
+    operator: zod_1.z
+        .enum([constants_1.RESPONSE_RULES_GROUP_OPERATORS.AND, constants_1.RESPONSE_RULES_GROUP_OPERATORS.OR])
+        .meta({
+        markdownDescription: 'Logical operator to use for combining nested **conditions**.',
+        markdownEnumDescriptions: [
+            constants_1.RESPONSE_RULES_GROUP_OPERATORS_DESCRIPTION.AND,
+            constants_1.RESPONSE_RULES_GROUP_OPERATORS_DESCRIPTION.OR,
+        ],
+    }),
+    get conditions() {
+        return zod_1.z
+            .array(exports.ResponseRuleConditionNodeSchema)
+            .min(1, 'Group must contain at least one condition')
+            .meta({
+            title: 'Conditions',
+            markdownDescription: 'Array of nested conditions. Each item is either a **condition** or another **group** (`AND`/`OR`/`NOT`), so groups can be nested to express complex logic.',
+        });
+    },
+})
+    .meta({
+    title: 'Condition Group',
+    markdownDescription: 'Group of nested conditions combined with a logical **operator** (`AND`/`OR`). Groups can be nested inside each other.',
+    defaultSnippets: [
+        {
+            label: 'Examples: OR group',
+            markdownDescription: 'Group that matches if **at least one** nested condition matches',
+            body: {
+                operator: 'OR',
+                conditions: [
+                    {
+                        headerName: 'user-agent',
+                        operator: 'CONTAINS',
+                        value: 'Hiddify',
+                    },
+                    {
+                        headerName: 'user-agent',
+                        operator: 'CONTAINS',
+                        value: 'FoxRay',
+                    },
+                ],
+            },
+        },
+    ],
+});
+exports.ResponseRuleConditionNotSchema = zod_1.z
+    .strictObject({
+    operator: zod_1.z.literal(constants_1.RESPONSE_RULES_GROUP_OPERATORS.NOT).meta({
+        markdownDescription: constants_1.RESPONSE_RULES_GROUP_OPERATORS_DESCRIPTION.NOT,
+    }),
+    get condition() {
+        return exports.ResponseRuleConditionNodeSchema.meta({
+            title: 'Condition',
+            markdownDescription: 'Nested condition to invert. Can be a **condition** or a **group**.',
+        });
+    },
+})
+    .meta({
+    title: 'NOT Group',
+    markdownDescription: 'Inverts the result of the nested **condition**. The nested condition can be a single condition or a whole group.',
+    defaultSnippets: [
+        {
+            label: 'Examples: NOT group',
+            markdownDescription: 'Matches if the nested condition does **not** match',
+            body: {
+                operator: 'NOT',
+                condition: {
+                    headerName: 'user-agent',
+                    operator: 'CONTAINS',
+                    value: 'Happ',
+                },
             },
         },
     ],
 });
+exports.ResponseRuleConditionNodeSchema = zod_1.z
+    .lazy(() => zod_1.z.discriminatedUnion('operator', [
+    exports.ResponseRuleConditionSchema,
+    exports.ResponseRuleConditionGroupSchema,
+    exports.ResponseRuleConditionNotSchema,
+]))
+    .meta({
+    title: 'Condition Node',
+    markdownDescription: 'Either a single **condition** (header check) or a **group** (`AND`/`OR`/`NOT`) with nested conditions. Groups can be nested to express complex logic, e.g. `A AND (B OR C)`.',
+});
+function forEachResponseRuleCondition(node, callback) {
+    switch (node.operator) {
+        case constants_1.RESPONSE_RULES_GROUP_OPERATORS.AND:
+        case constants_1.RESPONSE_RULES_GROUP_OPERATORS.OR:
+            for (const child of node.conditions) {
+                forEachResponseRuleCondition(child, callback);
+            }
+            return;
+        case constants_1.RESPONSE_RULES_GROUP_OPERATORS.NOT:
+            forEachResponseRuleCondition(node.condition, callback);
+            return;
+        default:
+            callback(node);
+    }
+}
+function measureResponseRuleConditionTree(node) {
+    switch (node.operator) {
+        case constants_1.RESPONSE_RULES_GROUP_OPERATORS.AND:
+        case constants_1.RESPONSE_RULES_GROUP_OPERATORS.OR: {
+            let depth = 0;
+            let nodes = 1;
+            for (const child of node.conditions) {
+                const childMetrics = measureResponseRuleConditionTree(child);
+                depth = Math.max(depth, childMetrics.depth);
+                nodes += childMetrics.nodes;
+            }
+            return { depth: depth + 1, nodes };
+        }
+        case constants_1.RESPONSE_RULES_GROUP_OPERATORS.NOT: {
+            const childMetrics = measureResponseRuleConditionTree(node.condition);
+            return { depth: childMetrics.depth + 1, nodes: childMetrics.nodes + 1 };
+        }
+        default:
+            return { depth: 1, nodes: 1 };
+    }
+}