@remnawave/backend-contract 2.9.5 → 2.9.6

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

@@ -74,7 +74,7 @@ export declare namespace GetSubscriptionSettingsCommand {
                             key: z.ZodString;
                             value: z.ZodString;
                         }, z.core.$strip>>>;
-                        applyHeadersToEnd: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+                        applyHeadersToEnd: z.ZodOptional<z.ZodBoolean>;
                         subscriptionTemplate: z.ZodOptional<z.ZodString>;
                         ignoreHostXrayJsonTemplate: z.ZodOptional<z.ZodBoolean>;
                         ignoreServeJsonAtBaseSubscription: z.ZodOptional<z.ZodBoolean>;

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

@@ -73,7 +73,7 @@ export declare namespace UpdateSubscriptionSettingsCommand {
                         key: z.ZodString;
                         value: z.ZodString;
                     }, z.core.$strip>>>;
-                    applyHeadersToEnd: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+                    applyHeadersToEnd: z.ZodOptional<z.ZodBoolean>;
                     subscriptionTemplate: z.ZodOptional<z.ZodString>;
                     ignoreHostXrayJsonTemplate: z.ZodOptional<z.ZodBoolean>;
                     ignoreServeJsonAtBaseSubscription: z.ZodOptional<z.ZodBoolean>;
@@ -167,7 +167,7 @@ export declare namespace UpdateSubscriptionSettingsCommand {
                             key: z.ZodString;
                             value: z.ZodString;
                         }, z.core.$strip>>>;
-                        applyHeadersToEnd: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+                        applyHeadersToEnd: z.ZodOptional<z.ZodBoolean>;
                         subscriptionTemplate: z.ZodOptional<z.ZodString>;
                         ignoreHostXrayJsonTemplate: z.ZodOptional<z.ZodBoolean>;
                         ignoreServeJsonAtBaseSubscription: z.ZodOptional<z.ZodBoolean>;

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

@@ -54,7 +54,7 @@ export declare namespace TestSrrMatcherCommand {
                         key: z.ZodString;
                         value: z.ZodString;
                     }, z.core.$strip>>>;
-                    applyHeadersToEnd: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+                    applyHeadersToEnd: z.ZodOptional<z.ZodBoolean>;
                     subscriptionTemplate: z.ZodOptional<z.ZodString>;
                     ignoreHostXrayJsonTemplate: z.ZodOptional<z.ZodBoolean>;
                     ignoreServeJsonAtBaseSubscription: z.ZodOptional<z.ZodBoolean>;
@@ -131,7 +131,7 @@ export declare namespace TestSrrMatcherCommand {
                         key: z.ZodString;
                         value: z.ZodString;
                     }, z.core.$strip>>>;
-                    applyHeadersToEnd: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+                    applyHeadersToEnd: z.ZodOptional<z.ZodBoolean>;
                     subscriptionTemplate: z.ZodOptional<z.ZodString>;
                     ignoreHostXrayJsonTemplate: z.ZodOptional<z.ZodBoolean>;
                     ignoreServeJsonAtBaseSubscription: z.ZodOptional<z.ZodBoolean>;

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;;;;;;;;;;;;;;;;iBAyDnC,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;AAOxB,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;iBA8ClC,CAAC"}

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

@@ -8,26 +8,27 @@ exports.ResponseRuleConditionSchema = zod_1.z
     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.')
-        .describe(JSON.stringify({
+        .meta({
+        title: 'Header Name',
         markdownDescription: '**Name** of the HTTP header to check. Must comply with RFC 7230.',
-    })),
-    operator: zod_1.z.enum(constants_1.RESPONSE_RULES_CONDITION_OPERATORS).describe(JSON.stringify({
+    }),
+    operator: zod_1.z.enum(constants_1.RESPONSE_RULES_CONDITION_OPERATORS).meta({
         errorMessage: 'Invalid operator. Please select a valid operator.',
         markdownDescription: 'Operator to use for comparing the `headerName` with `value`.',
         markdownEnumDescriptions: Object.entries(constants_1.RESPONSE_RULES_CONDITION_OPERATORS_DESCRIPTION).map(([_key, description]) => description),
-    })),
+    }),
     value: zod_1.z
         .string()
         .min(1, 'Value is required')
         .max(255, 'Value must be less than 255 characters')
-        .describe(JSON.stringify({
-        markdownDescription: `**Value** to check against the **headerName**.`,
-    })),
-    caseSensitive: zod_1.z.boolean().describe(JSON.stringify({
+        .meta({
+        markdownDescription: '**Value** to check against the **headerName**.',
+    }),
+    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.',
-    })),
+    }),
 })
-    .describe(JSON.stringify({
+    .meta({
     markdownDescription: 'Condition to check against the **headerName**.',
     defaultSnippets: [
         {
@@ -41,4 +42,4 @@ exports.ResponseRuleConditionSchema = zod_1.z
             },
         },
     ],
-}));
+});

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

@@ -11,7 +11,7 @@ export declare const ResponseRuleModificationsSchema: z.ZodOptional<z.ZodObject<
         key: z.ZodString;
         value: z.ZodString;
     }, z.core.$strip>>>;
-    applyHeadersToEnd: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+    applyHeadersToEnd: z.ZodOptional<z.ZodBoolean>;
     subscriptionTemplate: z.ZodOptional<z.ZodString>;
     ignoreHostXrayJsonTemplate: z.ZodOptional<z.ZodBoolean>;
     ignoreServeJsonAtBaseSubscription: z.ZodOptional<z.ZodBoolean>;

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

@@ -1 +1 @@
-{"version":3,"file":"response-rule-modifications.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rule-modifications.schema.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,eAAO,MAAM,4BAA4B;;;;;;iBAGvC,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;kBA8JvC,CAAC"}
+{"version":3,"file":"response-rule-modifications.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rule-modifications.schema.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,eAAO,MAAM,4BAA4B;;;;;;iBAGvC,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;kBA+HtC,CAAC"}

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

@@ -17,20 +17,20 @@ exports.ResponseRuleModificationsSchema = zod_1.default
         key: zod_1.default
             .string()
             .regex(/^[!#$%&'*+\-.0-9A-Z^_`a-z|~]+$/, 'Invalid header name. Only letters(a-z, A-Z), numbers(0-9), underscores(_) and hyphens(-) are allowed.')
-            .describe(JSON.stringify({
+            .meta({
+            title: 'Header Key',
             markdownDescription: 'Key of the response header. Must comply with RFC 7230.',
-        })),
-        value: zod_1.default
-            .string()
-            .min(1, 'Value is required')
-            .describe(JSON.stringify({
-            markdownDescription: 'Value of the response header. ',
-        })),
+        }),
+        value: zod_1.default.string().min(1).meta({
+            title: 'Header Value',
+            markdownDescription: 'Value of the response header.',
+        }),
     })
-        .describe(JSON.stringify({
+        .meta({
+        title: 'Headers',
         markdownDescription: '**Key** and **value** of the response header will be added to the response.',
-    })))
-        .describe(JSON.stringify({
+    }))
+        .meta({
         defaultSnippets: [
             {
                 label: 'Examples: Add custom header',
@@ -44,38 +44,32 @@ exports.ResponseRuleModificationsSchema = zod_1.default
             },
         ],
         markdownDescription: 'Array of headers to be added when the rule is matched.',
-    }))
+    })
         .optional(),
-    applyHeadersToEnd: zod_1.default
-        .boolean()
-        .optional()
-        .describe(JSON.stringify({
+    applyHeadersToEnd: zod_1.default.boolean().optional().meta({
+        title: 'Apply Headers to End',
         markdownDescription: 'By default, headers are added when forming the response. In some cases, headers set in SRR may be overridden by headers from other parts of the system. If you set this flag to **true**, headers from SRR will be added at the very end, just before the response is sent. In this case, SRR headers may override headers from other sections.',
-    }))
-        .optional(),
+    }),
     subscriptionTemplate: zod_1.default
         .string()
         .min(1, 'Subscription template name is required')
         .optional()
-        .describe(JSON.stringify({
+        .meta({
+        title: 'Subscription Template',
         markdownDescription: 'Override the subscription template with the given name. If not provided, the default subscription template will be used. If the template name is not found, the default subscription template for this type will be used. **This modification have higher priority than settings from External Squads.**',
-    })),
-    ignoreHostXrayJsonTemplate: zod_1.default
-        .boolean()
-        .optional()
-        .describe(JSON.stringify({
+    }),
+    ignoreHostXrayJsonTemplate: zod_1.default.boolean().optional().meta({
+        title: 'Ignore Host Xray Json Template',
         markdownDescription: "Each Host may have its own Xray Json Template. If you set this flag to **true**, the Xray Json Template defined by the SRR will be used. **The Host's Xray Json Template will be ignored.**",
-    })),
-    ignoreServeJsonAtBaseSubscription: zod_1.default
-        .boolean()
-        .optional()
-        .describe(JSON.stringify({
+    }),
+    ignoreServeJsonAtBaseSubscription: zod_1.default.boolean().optional().meta({
+        title: 'Ignore Serve Json at Base Subscription',
         markdownDescription: 'If you set this flag to **true**, the **Serve JSON at Base Subscription** setting will be ignored (set to **false**).',
-    })),
+    }),
     additionalExtendedClientsRegex: zod_1.default
         .array(zod_1.default.string().min(1))
         .optional()
-        .describe(JSON.stringify({
+        .meta({
         markdownDescription: 'Additional regex patterns to match extended clients. Matched clients will receive `serverDescription` in the subscription response.\n\n' +
             '**Default Mihomo extended clients:**\n' +
             '- `^FlClash ?X/`\n' +
@@ -86,16 +80,15 @@ exports.ResponseRuleModificationsSchema = zod_1.default
             '- `^Happ/`\n' +
             '- `^INCY/`\n\n' +
             '**Example:** `["^MyClient/", "^CustomApp\\\\/v2"]`',
-    })),
-    disableHwidCheck: zod_1.default
-        .boolean()
-        .optional()
-        .describe(JSON.stringify({
+    }),
+    disableHwidCheck: zod_1.default.boolean().optional().meta({
+        title: 'Disable HWID Check',
         markdownDescription: 'If you set this flag to **true**, the HWID check will be disabled. **This modification have higher priority than settings from Subscription Settings.**',
-    })),
-    encryption: exports.ResponseRuleEncryptionSchema.optional().describe(JSON.stringify({
+    }),
+    encryption: exports.ResponseRuleEncryptionSchema.optional().meta({
+        title: 'Encryption',
         markdownDescription: 'Encrypt response body with given parameters. Generate keypairs with Rescue CLI: `docker exec -it remnawave cli`, select "Generate keypairs".',
-    })),
+    }),
     excludeHostsByTags: zod_1.default
         .array(zod_1.default
         .string()
@@ -103,12 +96,14 @@ exports.ResponseRuleModificationsSchema = zod_1.default
         .max(36, 'Each tag must be less than 36 characters'))
         .min(1)
         .optional()
-        .describe(JSON.stringify({
+        .meta({
+        title: 'Exclude Hosts by Tags',
         markdownDescription: 'Excludes hosts from the subscription output if at least one tag in the host matches the given tags.',
-    })),
+    }),
 })
     .optional()
-    .describe(JSON.stringify({
+    .meta({
+    title: 'Response Modifications',
     examples: [
         {
             headers: [
@@ -120,4 +115,4 @@ exports.ResponseRuleModificationsSchema = zod_1.default
         },
     ],
     markdownDescription: 'Response modifications to be applied when the rule is matched. Optional.',
-}));
+});

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

@@ -1 +1 @@
-{"version":3,"file":"response-rule-settings.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rule-settings.schema.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,eAAO,MAAM,0BAA0B;;kBAiBlC,CAAC"}
+{"version":3,"file":"response-rule-settings.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rule-settings.schema.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,eAAO,MAAM,0BAA0B;;kBAYjC,CAAC"}

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

@@ -7,14 +7,13 @@ exports.ResponseRuleSettingsSchema = void 0;
 const zod_1 = __importDefault(require("zod"));
 exports.ResponseRuleSettingsSchema = zod_1.default
     .object({
-    disableSubscriptionAccessByPath: zod_1.default
-        .boolean()
-        .optional()
-        .describe(JSON.stringify({
+    disableSubscriptionAccessByPath: zod_1.default.boolean().optional().meta({
+        title: 'Disable Subscription Access by Path',
         markdownDescription: "Usually, a user's subscription may also be available via additional paths such as **/json**, **/stash**, or **/mihomo**. If this flag is set to **true**, access via these additional paths will be disabled.",
-    })),
+    }),
 })
     .optional()
-    .describe(JSON.stringify({
+    .meta({
+    title: 'Response Rule Settings',
     markdownDescription: 'Settings for the **response rules** config. Optional.',
-}));
+});

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

@@ -42,7 +42,7 @@ export declare const ResponseRuleSchemaBase: z.ZodObject<{
             key: z.ZodString;
             value: z.ZodString;
         }, z.core.$strip>>>;
-        applyHeadersToEnd: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+        applyHeadersToEnd: z.ZodOptional<z.ZodBoolean>;
         subscriptionTemplate: z.ZodOptional<z.ZodString>;
         ignoreHostXrayJsonTemplate: z.ZodOptional<z.ZodBoolean>;
         ignoreServeJsonAtBaseSubscription: z.ZodOptional<z.ZodBoolean>;
@@ -101,7 +101,7 @@ export declare const ResponseRuleSchema: z.ZodObject<{
             key: z.ZodString;
             value: z.ZodString;
         }, z.core.$strip>>>;
-        applyHeadersToEnd: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+        applyHeadersToEnd: z.ZodOptional<z.ZodBoolean>;
         subscriptionTemplate: z.ZodOptional<z.ZodString>;
         ignoreHostXrayJsonTemplate: z.ZodOptional<z.ZodBoolean>;
         ignoreServeJsonAtBaseSubscription: z.ZodOptional<z.ZodBoolean>;

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgDjC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqB9B,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;AAexB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuCjC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmB7B,CAAC"}

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

@@ -11,34 +11,40 @@ exports.ResponseRuleSchemaBase = zod_1.z.object({
         .string()
         .min(1, 'Name is required')
         .max(50, 'Name must be less than 50 characters')
-        .describe(JSON.stringify({
+        .meta({
+        title: 'Name',
         markdownDescription: 'Name of the response rule.',
-    })),
+    }),
     description: zod_1.z
         .string()
         .min(1, 'Description is required')
         .max(250, 'Description must be less than 250 characters')
         .optional()
-        .describe(JSON.stringify({
+        .meta({
+        title: 'Description',
         markdownDescription: 'Description of the response rule. Optional.',
-    })),
-    enabled: zod_1.z.boolean().describe(JSON.stringify({
+    }),
+    enabled: zod_1.z.boolean().meta({
+        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).describe(JSON.stringify({
+    }),
+    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).describe(JSON.stringify({
+    }),
+    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.',
-    })),
-    responseType: zod_1.z.enum(constants_1.RESPONSE_RULES_RESPONSE_TYPES).describe(JSON.stringify({
+    }),
+    responseType: zod_1.z.enum(constants_1.RESPONSE_RULES_RESPONSE_TYPES).meta({
         errorMessage: 'Invalid response type. Please select a valid response type.',
         markdownDescription: `Type of the response. Determines the type of **response** to be returned when the rule is matched.`,
         markdownEnumDescriptions: Object.entries(constants_1.RESPONSE_RULES_RESPONSE_TYPES_DESCRIPTION).map(([_key, description]) => description),
-    })),
+    }),
     responseModifications: response_rule_modifications_schema_1.ResponseRuleModificationsSchema,
 });
-exports.ResponseRuleSchema = exports.ResponseRuleSchemaBase.describe(JSON.stringify({
+exports.ResponseRuleSchema = exports.ResponseRuleSchemaBase.meta({
+    title: 'Response Rule',
+    markdownDescription: (0, response_rules_examples_1.generateResponseRuleDescription)(exports.ResponseRuleSchemaBase),
     defaultSnippets: [
         {
             label: 'Examples: Blank rule',
@@ -55,6 +61,4 @@ exports.ResponseRuleSchema = exports.ResponseRuleSchemaBase.describe(JSON.string
             },
         },
     ],
-    title: 'Response Rule',
-    markdownDescription: (0, response_rules_examples_1.generateResponseRuleDescription)(exports.ResponseRuleSchemaBase),
-}));
+});

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

@@ -49,7 +49,7 @@ export declare const ResponseRulesConfigSchema: z.ZodObject<{
                 key: z.ZodString;
                 value: z.ZodString;
             }, z.core.$strip>>>;
-            applyHeadersToEnd: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+            applyHeadersToEnd: z.ZodOptional<z.ZodBoolean>;
             subscriptionTemplate: z.ZodOptional<z.ZodString>;
             ignoreHostXrayJsonTemplate: z.ZodOptional<z.ZodBoolean>;
             ignoreServeJsonAtBaseSubscription: z.ZodOptional<z.ZodBoolean>;

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAcpC,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAYpC,CAAC"}

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

@@ -12,9 +12,9 @@ exports.ResponseRulesConfigSchema = zod_1.z.object({
         markdownDescription: 'Version of the **response rules** config. Currently supported version is **1**.',
     }),
     settings: response_rule_settings_schema_1.ResponseRuleSettingsSchema,
-    rules: zod_1.z.array(response_rule_schema_1.ResponseRuleSchema).describe(JSON.stringify({
+    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\`\`\``,
         defaultSnippets: [],
-    })),
+    }),
 });

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

@@ -1,6 +1,6 @@
 import z from 'zod';
-import { ResponseRuleSchema, ResponseRuleSchemaBase } from './response-rule.schema';
-export declare const EXAMPLES_SRR_BLANK_RULE: z.infer<typeof ResponseRuleSchema>;
-export declare const EXAMPLES_SRR_BLOCK_LEGACY_CLIENTS_RULE: z.infer<typeof ResponseRuleSchema>;
+import type { ResponseRuleSchemaBase } from './response-rule.schema';
+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 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,EAAE,kBAAkB,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAEpF,eAAO,MAAM,uBAAuB,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAUtE,CAAC;AAEF,eAAO,MAAM,sCAAsC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAoBrF,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,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"}

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

@@ -1 +1 @@
-{"version":3,"file":"hwid-settings.schema.d.ts","sourceRoot":"","sources":["../../../../models/subscription-settings/hwid-settings.schema.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,eAAO,MAAM,kBAAkB;;;;iBAM7B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}
+{"version":3,"file":"hwid-settings.schema.d.ts","sourceRoot":"","sources":["../../../../models/subscription-settings/hwid-settings.schema.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,eAAO,MAAM,kBAAkB;;;;iBAI7B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/build/backend/models/subscription-settings/hwid-settings.schema.js

@@ -8,5 +8,5 @@ const zod_1 = __importDefault(require("zod"));
 exports.HwidSettingsSchema = zod_1.default.object({
     enabled: zod_1.default.boolean(),
     fallbackDeviceLimit: zod_1.default.number(),
-    maxDevicesAnnounce: zod_1.default.nullable(zod_1.default.string().max(200, { message: 'Announce must be less than 200 characters' })),
+    maxDevicesAnnounce: zod_1.default.nullable(zod_1.default.string().max(200)),
 });

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

@@ -69,7 +69,7 @@ export declare const SubscriptionSettingsSchema: z.ZodObject<{
                     key: z.ZodString;
                     value: z.ZodString;
                 }, z.core.$strip>>>;
-                applyHeadersToEnd: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
+                applyHeadersToEnd: z.ZodOptional<z.ZodBoolean>;
                 subscriptionTemplate: z.ZodOptional<z.ZodString>;
                 ignoreHostXrayJsonTemplate: z.ZodOptional<z.ZodBoolean>;
                 ignoreServeJsonAtBaseSubscription: z.ZodOptional<z.ZodBoolean>;

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

@@ -8,26 +8,27 @@ exports.ResponseRuleConditionSchema = zod_1.z
     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.')
-        .describe(JSON.stringify({
+        .meta({
+        title: 'Header Name',
         markdownDescription: '**Name** of the HTTP header to check. Must comply with RFC 7230.',
-    })),
-    operator: zod_1.z.enum(constants_1.RESPONSE_RULES_CONDITION_OPERATORS).describe(JSON.stringify({
+    }),
+    operator: zod_1.z.enum(constants_1.RESPONSE_RULES_CONDITION_OPERATORS).meta({
         errorMessage: 'Invalid operator. Please select a valid operator.',
         markdownDescription: 'Operator to use for comparing the `headerName` with `value`.',
         markdownEnumDescriptions: Object.entries(constants_1.RESPONSE_RULES_CONDITION_OPERATORS_DESCRIPTION).map(([_key, description]) => description),
-    })),
+    }),
     value: zod_1.z
         .string()
         .min(1, 'Value is required')
         .max(255, 'Value must be less than 255 characters')
-        .describe(JSON.stringify({
-        markdownDescription: `**Value** to check against the **headerName**.`,
-    })),
-    caseSensitive: zod_1.z.boolean().describe(JSON.stringify({
+        .meta({
+        markdownDescription: '**Value** to check against the **headerName**.',
+    }),
+    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.',
-    })),
+    }),
 })
-    .describe(JSON.stringify({
+    .meta({
     markdownDescription: 'Condition to check against the **headerName**.',
     defaultSnippets: [
         {
@@ -41,4 +42,4 @@ exports.ResponseRuleConditionSchema = zod_1.z
             },
         },
     ],
-}));
+});

package/build/frontend/models/response-rules/response-rule-modifications.schema.js

@@ -17,20 +17,20 @@ exports.ResponseRuleModificationsSchema = zod_1.default
         key: zod_1.default
             .string()
             .regex(/^[!#$%&'*+\-.0-9A-Z^_`a-z|~]+$/, 'Invalid header name. Only letters(a-z, A-Z), numbers(0-9), underscores(_) and hyphens(-) are allowed.')
-            .describe(JSON.stringify({
+            .meta({
+            title: 'Header Key',
             markdownDescription: 'Key of the response header. Must comply with RFC 7230.',
-        })),
-        value: zod_1.default
-            .string()
-            .min(1, 'Value is required')
-            .describe(JSON.stringify({
-            markdownDescription: 'Value of the response header. ',
-        })),
+        }),
+        value: zod_1.default.string().min(1).meta({
+            title: 'Header Value',
+            markdownDescription: 'Value of the response header.',
+        }),
     })
-        .describe(JSON.stringify({
+        .meta({
+        title: 'Headers',
         markdownDescription: '**Key** and **value** of the response header will be added to the response.',
-    })))
-        .describe(JSON.stringify({
+    }))
+        .meta({
         defaultSnippets: [
             {
                 label: 'Examples: Add custom header',
@@ -44,38 +44,32 @@ exports.ResponseRuleModificationsSchema = zod_1.default
             },
         ],
         markdownDescription: 'Array of headers to be added when the rule is matched.',
-    }))
+    })
         .optional(),
-    applyHeadersToEnd: zod_1.default
-        .boolean()
-        .optional()
-        .describe(JSON.stringify({
+    applyHeadersToEnd: zod_1.default.boolean().optional().meta({
+        title: 'Apply Headers to End',
         markdownDescription: 'By default, headers are added when forming the response. In some cases, headers set in SRR may be overridden by headers from other parts of the system. If you set this flag to **true**, headers from SRR will be added at the very end, just before the response is sent. In this case, SRR headers may override headers from other sections.',
-    }))
-        .optional(),
+    }),
     subscriptionTemplate: zod_1.default
         .string()
         .min(1, 'Subscription template name is required')
         .optional()
-        .describe(JSON.stringify({
+        .meta({
+        title: 'Subscription Template',
         markdownDescription: 'Override the subscription template with the given name. If not provided, the default subscription template will be used. If the template name is not found, the default subscription template for this type will be used. **This modification have higher priority than settings from External Squads.**',
-    })),
-    ignoreHostXrayJsonTemplate: zod_1.default
-        .boolean()
-        .optional()
-        .describe(JSON.stringify({
+    }),
+    ignoreHostXrayJsonTemplate: zod_1.default.boolean().optional().meta({
+        title: 'Ignore Host Xray Json Template',
         markdownDescription: "Each Host may have its own Xray Json Template. If you set this flag to **true**, the Xray Json Template defined by the SRR will be used. **The Host's Xray Json Template will be ignored.**",
-    })),
-    ignoreServeJsonAtBaseSubscription: zod_1.default
-        .boolean()
-        .optional()
-        .describe(JSON.stringify({
+    }),
+    ignoreServeJsonAtBaseSubscription: zod_1.default.boolean().optional().meta({
+        title: 'Ignore Serve Json at Base Subscription',
         markdownDescription: 'If you set this flag to **true**, the **Serve JSON at Base Subscription** setting will be ignored (set to **false**).',
-    })),
+    }),
     additionalExtendedClientsRegex: zod_1.default
         .array(zod_1.default.string().min(1))
         .optional()
-        .describe(JSON.stringify({
+        .meta({
         markdownDescription: 'Additional regex patterns to match extended clients. Matched clients will receive `serverDescription` in the subscription response.\n\n' +
             '**Default Mihomo extended clients:**\n' +
             '- `^FlClash ?X/`\n' +
@@ -86,16 +80,15 @@ exports.ResponseRuleModificationsSchema = zod_1.default
             '- `^Happ/`\n' +
             '- `^INCY/`\n\n' +
             '**Example:** `["^MyClient/", "^CustomApp\\\\/v2"]`',
-    })),
-    disableHwidCheck: zod_1.default
-        .boolean()
-        .optional()
-        .describe(JSON.stringify({
+    }),
+    disableHwidCheck: zod_1.default.boolean().optional().meta({
+        title: 'Disable HWID Check',
         markdownDescription: 'If you set this flag to **true**, the HWID check will be disabled. **This modification have higher priority than settings from Subscription Settings.**',
-    })),
-    encryption: exports.ResponseRuleEncryptionSchema.optional().describe(JSON.stringify({
+    }),
+    encryption: exports.ResponseRuleEncryptionSchema.optional().meta({
+        title: 'Encryption',
         markdownDescription: 'Encrypt response body with given parameters. Generate keypairs with Rescue CLI: `docker exec -it remnawave cli`, select "Generate keypairs".',
-    })),
+    }),
     excludeHostsByTags: zod_1.default
         .array(zod_1.default
         .string()
@@ -103,12 +96,14 @@ exports.ResponseRuleModificationsSchema = zod_1.default
         .max(36, 'Each tag must be less than 36 characters'))
         .min(1)
         .optional()
-        .describe(JSON.stringify({
+        .meta({
+        title: 'Exclude Hosts by Tags',
         markdownDescription: 'Excludes hosts from the subscription output if at least one tag in the host matches the given tags.',
-    })),
+    }),
 })
     .optional()
-    .describe(JSON.stringify({
+    .meta({
+    title: 'Response Modifications',
     examples: [
         {
             headers: [
@@ -120,4 +115,4 @@ exports.ResponseRuleModificationsSchema = zod_1.default
         },
     ],
     markdownDescription: 'Response modifications to be applied when the rule is matched. Optional.',
-}));
+});

package/build/frontend/models/response-rules/response-rule-settings.schema.js

@@ -7,14 +7,13 @@ exports.ResponseRuleSettingsSchema = void 0;
 const zod_1 = __importDefault(require("zod"));
 exports.ResponseRuleSettingsSchema = zod_1.default
     .object({
-    disableSubscriptionAccessByPath: zod_1.default
-        .boolean()
-        .optional()
-        .describe(JSON.stringify({
+    disableSubscriptionAccessByPath: zod_1.default.boolean().optional().meta({
+        title: 'Disable Subscription Access by Path',
         markdownDescription: "Usually, a user's subscription may also be available via additional paths such as **/json**, **/stash**, or **/mihomo**. If this flag is set to **true**, access via these additional paths will be disabled.",
-    })),
+    }),
 })
     .optional()
-    .describe(JSON.stringify({
+    .meta({
+    title: 'Response Rule Settings',
     markdownDescription: 'Settings for the **response rules** config. Optional.',
-}));
+});

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

@@ -11,34 +11,40 @@ exports.ResponseRuleSchemaBase = zod_1.z.object({
         .string()
         .min(1, 'Name is required')
         .max(50, 'Name must be less than 50 characters')
-        .describe(JSON.stringify({
+        .meta({
+        title: 'Name',
         markdownDescription: 'Name of the response rule.',
-    })),
+    }),
     description: zod_1.z
         .string()
         .min(1, 'Description is required')
         .max(250, 'Description must be less than 250 characters')
         .optional()
-        .describe(JSON.stringify({
+        .meta({
+        title: 'Description',
         markdownDescription: 'Description of the response rule. Optional.',
-    })),
-    enabled: zod_1.z.boolean().describe(JSON.stringify({
+    }),
+    enabled: zod_1.z.boolean().meta({
+        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).describe(JSON.stringify({
+    }),
+    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).describe(JSON.stringify({
+    }),
+    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.',
-    })),
-    responseType: zod_1.z.enum(constants_1.RESPONSE_RULES_RESPONSE_TYPES).describe(JSON.stringify({
+    }),
+    responseType: zod_1.z.enum(constants_1.RESPONSE_RULES_RESPONSE_TYPES).meta({
         errorMessage: 'Invalid response type. Please select a valid response type.',
         markdownDescription: `Type of the response. Determines the type of **response** to be returned when the rule is matched.`,
         markdownEnumDescriptions: Object.entries(constants_1.RESPONSE_RULES_RESPONSE_TYPES_DESCRIPTION).map(([_key, description]) => description),
-    })),
+    }),
     responseModifications: response_rule_modifications_schema_1.ResponseRuleModificationsSchema,
 });
-exports.ResponseRuleSchema = exports.ResponseRuleSchemaBase.describe(JSON.stringify({
+exports.ResponseRuleSchema = exports.ResponseRuleSchemaBase.meta({
+    title: 'Response Rule',
+    markdownDescription: (0, response_rules_examples_1.generateResponseRuleDescription)(exports.ResponseRuleSchemaBase),
     defaultSnippets: [
         {
             label: 'Examples: Blank rule',
@@ -51,6 +57,4 @@ exports.ResponseRuleSchema = exports.ResponseRuleSchemaBase.describe(JSON.string
             body: Object.assign({}, response_rules_examples_1.EXAMPLES_SRR_BLOCK_LEGACY_CLIENTS_RULE),
         },
     ],
-    title: 'Response Rule',
-    markdownDescription: (0, response_rules_examples_1.generateResponseRuleDescription)(exports.ResponseRuleSchemaBase),
-}));
+});

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

@@ -12,9 +12,9 @@ exports.ResponseRulesConfigSchema = zod_1.z.object({
         markdownDescription: 'Version of the **response rules** config. Currently supported version is **1**.',
     }),
     settings: response_rule_settings_schema_1.ResponseRuleSettingsSchema,
-    rules: zod_1.z.array(response_rule_schema_1.ResponseRuleSchema).describe(JSON.stringify({
+    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\`\`\``,
         defaultSnippets: [],
-    })),
+    }),
 });

package/build/frontend/models/subscription-settings/hwid-settings.schema.js

@@ -8,5 +8,5 @@ const zod_1 = __importDefault(require("zod"));
 exports.HwidSettingsSchema = zod_1.default.object({
     enabled: zod_1.default.boolean(),
     fallbackDeviceLimit: zod_1.default.number(),
-    maxDevicesAnnounce: zod_1.default.nullable(zod_1.default.string().max(200, { message: 'Announce must be less than 200 characters' })),
+    maxDevicesAnnounce: zod_1.default.nullable(zod_1.default.string().max(200)),
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnawave/backend-contract",
-  "version": "2.9.5",
+  "version": "2.9.6",
   "description": "A contract library for Remnawave Backend. It can be used in backend and frontend.",
   "keywords": [],
   "homepage": "https://github.com/remnawave",