@remnawave/backend-contract 2.9.30 → 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/commands/users/actions/revoke-user-subscription.command.js

@@ -21,8 +21,8 @@ var RevokeUserSubscriptionCommand;
             .describe('Optional. If true, only passwords will be revoked, without changing the short UUID (Subscription URL).')),
         shortUuid: zod_1.z.optional(zod_1.z
             .string()
-            .min(6)
-            .max(48)
+            .min(16)
+            .max(64)
             .describe('Optional. If not provided, a new short UUID will be generated by Remnawave. Please note that it is strongly recommended to allow Remnawave to generate the short UUID.')),
     }));
     RevokeUserSubscriptionCommand.ResponseSchema = user_response_1.UserResponseSchema;

package/build/backend/commands/users/resolve-user.command.d.ts

@@ -4,7 +4,6 @@ export declare namespace ResolveUserCommand {
     const TSQ_url: "/api/users/resolve";
     const endpointDetails: import("../../constants").EndpointDetails;
     const RequestBodySchema: z.ZodObject<{
-        uuid: z.ZodOptional<z.ZodUUID>;
         id: z.ZodOptional<z.ZodNumber>;
         shortUuid: z.ZodOptional<z.ZodString>;
         username: z.ZodOptional<z.ZodString>;
@@ -14,7 +13,6 @@ export declare namespace ResolveUserCommand {
             id: z.ZodNumber;
             username: z.ZodString;
             shortUuid: z.ZodString;
-            uuid: z.ZodUUID;
         }, z.core.$strip>;
     }, z.core.$strip>;
     type RequestBody = z.infer<typeof RequestBodySchema>;

package/build/backend/commands/users/resolve-user.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-user.command.d.ts","sourceRoot":"","sources":["../../../../commands/users/resolve-user.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,yBAAiB,kBAAkB,CAAC;IACzB,MAAM,GAAG,sBAAyB,CAAC;IACnC,MAAM,OAAO,sBAAM,CAAC;IAEpB,MAAM,eAAe,2CAM3B,CAAC;IAEK,MAAM,iBAAiB;;;;;qBAiBzB,CAAC;IAEC,MAAM,cAAc;;;;;;;qBAOzB,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":"resolve-user.command.d.ts","sourceRoot":"","sources":["../../../../commands/users/resolve-user.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,yBAAiB,kBAAkB,CAAC;IACzB,MAAM,GAAG,sBAAyB,CAAC;IACnC,MAAM,OAAO,sBAAM,CAAC;IAEpB,MAAM,eAAe,2CAM3B,CAAC;IAEK,MAAM,iBAAiB;;;;qBAgBzB,CAAC;IAEC,MAAM,cAAc;;;;;;qBAMzB,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/users/resolve-user.command.js

@@ -11,23 +11,21 @@ var ResolveUserCommand;
     ResolveUserCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.USERS_ROUTES.RESOLVE, 'post', 'Resolve a user', { scope: 'resolve', kind: 'read' }, 'Resolve a user by ID, Short UUID or username. Exactly one of the fields must be provided.');
     ResolveUserCommand.RequestBodySchema = zod_1.z
         .object({
-        uuid: zod_1.z.uuid().optional().meta({ deprecated: true }),
         id: zod_1.z.number().optional(),
         shortUuid: zod_1.z.string().optional(),
         username: zod_1.z.string().optional(),
     })
         .refine((data) => {
-        const provided = [data.uuid, data.id, data.shortUuid, data.username].filter((v) => v !== undefined);
+        const provided = [data.id, data.shortUuid, data.username].filter((v) => v !== undefined);
         return provided.length === 1;
     }, {
-        error: 'Exactly one of uuid, id, shortUuid, or username must be provided',
+        error: 'Exactly one of id, shortUuid, or username must be provided',
     });
     ResolveUserCommand.ResponseSchema = zod_1.z.object({
         response: zod_1.z.object({
             id: zod_1.z.number(),
             username: zod_1.z.string(),
             shortUuid: zod_1.z.string(),
-            uuid: zod_1.z.uuid().meta({ deprecated: true }),
         }),
     });
 })(ResolveUserCommand || (exports.ResolveUserCommand = ResolveUserCommand = {}));

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"}