@remnawave/backend-contract 2.1.82 → 2.2.1

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

@@ -42,28 +42,28 @@ export type TResponseRulesConditionOperator = [
 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 type TResponseRulesConditionOperatorKeys = (typeof RESPONSE_RULES_CONDITION_OPERATORS)[keyof typeof RESPONSE_RULES_CONDITION_OPERATORS];
 export declare const RESPONSE_RULES_RESPONSE_TYPES_DESCRIPTION: {
-    readonly BLOCK: "Block response type blocks the request and returns a 403 status code.";
-    readonly XRAY_BASE64: "Previously used as fallback response type. It return subscription as base64 encoded string. Compatible with most client application with Xray core.";
-    readonly STATUS_CODE_404: "Status code 404 response type returns a 404 status code. This response type is used to return a 404 status code.";
-    readonly STATUS_CODE_451: "Status code 451 response type returns a 451 status code. This response type is used to return a 451 status code.";
-    readonly SOCKET_DROP: "Socket drop response type drops the socket connection. This response type is used to drop the socket connection.";
-    readonly CLASH: "Useful for client application that use Legacy Clash core. It return subscription as Clash YAML format.";
-    readonly STASH: "Format which is used by Stash client application.";
-    readonly SINGBOX: "Format which is used by Singbox client application.";
-    readonly MIHOMO: "Return subscription as Mihomo Core YAML format.";
-    readonly XRAY_JSON: "Return subscription as Xray JSON format.";
-    readonly BROWSER: "Return subscription as browser format.";
+    readonly XRAY_JSON: "Return **subscription** in XRAY-JSON format. (Using `Xray Json` template)";
+    readonly XRAY_BASE64: "Return **subscription** in BASE64 encoded string. Compatible with most client application with Xray core.";
+    readonly MIHOMO: "Return **subscription** in Mihomo format. (Using `Mihomo` template)";
+    readonly STASH: "Return **subscription** in Stash format. (Using `Stash` template)";
+    readonly CLASH: "Return **subscription** in Clash format. (Using `Clash` template) Useful for client application that use Legacy Clash core.";
+    readonly SINGBOX: "Return **subscription** in Singbox format. (Using `Singbox` template) Format which is used by Singbox client application.";
+    readonly BROWSER: "Return **subscription** as browser format. The same as on `/info` route.";
+    readonly BLOCK: "**Drop** request and return `403` status code.";
+    readonly STATUS_CODE_404: "**Drop** request and return `404` status code.";
+    readonly STATUS_CODE_451: "**Drop** request and return `451` status code.";
+    readonly SOCKET_DROP: "**Drop** the socket connection.";
 };
 export declare const RESPONSE_RULES_CONDITION_OPERATORS_DESCRIPTION: {
-    readonly EQUALS: "Equals operator checks if the header value exactly matches the specified string, case sensitive. Underlying implementation uses strict string comparison – ===.";
-    readonly NOT_EQUALS: "Not equals operator checks if the header value does not match the specified string, case sensitive. Underlying implementation uses strict string comparison – !==.";
-    readonly CONTAINS: "Contains operator checks if the header value contains the specified string, case sensitive. Underlying implementation uses string.includes().";
-    readonly NOT_CONTAINS: "Not contains operator checks if the header value does not contain the specified string, case sensitive. Underlying implementation uses string.includes().";
-    readonly STARTS_WITH: "Starts with operator checks if the header value starts with the specified string, case sensitive. Underlying implementation uses string.startsWith().";
-    readonly NOT_STARTS_WITH: "Not starts with operator checks if the header value does not start with the specified string, case sensitive. Underlying implementation uses string.startsWith().";
-    readonly ENDS_WITH: "Ends with operator checks if the header value ends with the specified string, case sensitive. Underlying implementation uses string.endsWith().";
-    readonly NOT_ENDS_WITH: "Not ends with operator checks if the header value does not end with the specified string, case sensitive. Underlying implementation uses string.endsWith().";
-    readonly REGEX: "Regex operator checks if the header value matches the specified regex. Underlying implementation uses regex.test().";
-    readonly NOT_REGEX: "Inverse regex operator checks if the header value does not match the specified regex. Underlying implementation uses regex.test().";
+    readonly EQUALS: "Performs an exact, comparison between the header value and specified string. `string === value`";
+    readonly NOT_EQUALS: "Ensures the header value does not exactly match the specified string. `string !== value`";
+    readonly CONTAINS: "Checks if the header value contains the specified string as a substring. `string.includes()`";
+    readonly NOT_CONTAINS: "Verifies the header value does not contain the specified string as a substring. `!string.includes()`";
+    readonly STARTS_WITH: "Validates that the header value begins with the specified string. `string.startsWith()`";
+    readonly NOT_STARTS_WITH: "Validates that the header value does not begin with the specified string. `!string.startsWith()`";
+    readonly ENDS_WITH: "Confirms the header value ends with the specified string. `string.endsWith()`";
+    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()`";
 };
 //# 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;;;;;;;;;;;;CAkB5C,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;;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"}

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

@@ -35,27 +35,27 @@ exports.RESPONSE_RULES_RESPONSE_TYPES = {
 exports.RESPONSE_RULES_RESPONSE_TYPES_VALUES = Object.values(exports.RESPONSE_RULES_RESPONSE_TYPES);
 exports.RESPONSE_RULES_CONDITION_OPERATORS_VALUES = Object.values(exports.RESPONSE_RULES_CONDITION_OPERATORS);
 exports.RESPONSE_RULES_RESPONSE_TYPES_DESCRIPTION = {
-    [exports.RESPONSE_RULES_RESPONSE_TYPES.BLOCK]: 'Block response type blocks the request and returns a 403 status code.',
-    [exports.RESPONSE_RULES_RESPONSE_TYPES.XRAY_BASE64]: 'Previously used as fallback response type. It return subscription as base64 encoded string. Compatible with most client application with Xray core.',
-    [exports.RESPONSE_RULES_RESPONSE_TYPES.STATUS_CODE_404]: 'Status code 404 response type returns a 404 status code. This response type is used to return a 404 status code.',
-    [exports.RESPONSE_RULES_RESPONSE_TYPES.STATUS_CODE_451]: 'Status code 451 response type returns a 451 status code. This response type is used to return a 451 status code.',
-    [exports.RESPONSE_RULES_RESPONSE_TYPES.SOCKET_DROP]: 'Socket drop response type drops the socket connection. This response type is used to drop the socket connection.',
-    [exports.RESPONSE_RULES_RESPONSE_TYPES.CLASH]: 'Useful for client application that use Legacy Clash core. It return subscription as Clash YAML format.',
-    [exports.RESPONSE_RULES_RESPONSE_TYPES.STASH]: 'Format which is used by Stash client application.',
-    [exports.RESPONSE_RULES_RESPONSE_TYPES.SINGBOX]: 'Format which is used by Singbox client application.',
-    [exports.RESPONSE_RULES_RESPONSE_TYPES.MIHOMO]: 'Return subscription as Mihomo Core YAML format.',
-    [exports.RESPONSE_RULES_RESPONSE_TYPES.XRAY_JSON]: 'Return subscription as Xray JSON format.',
-    [exports.RESPONSE_RULES_RESPONSE_TYPES.BROWSER]: 'Return subscription as browser format.',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.XRAY_JSON]: 'Return **subscription** in XRAY-JSON format. (Using `Xray Json` template)',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.XRAY_BASE64]: 'Return **subscription** in BASE64 encoded string. Compatible with most client application with Xray core.',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.MIHOMO]: 'Return **subscription** in Mihomo format. (Using `Mihomo` template)',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.STASH]: 'Return **subscription** in Stash format. (Using `Stash` template)',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.CLASH]: 'Return **subscription** in Clash format. (Using `Clash` template) Useful for client application that use Legacy Clash core.',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.SINGBOX]: 'Return **subscription** in Singbox format. (Using `Singbox` template) Format which is used by Singbox client application.',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.BROWSER]: 'Return **subscription** as browser format. The same as on `/info` route.',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.BLOCK]: '**Drop** request and return `403` status code.',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.STATUS_CODE_404]: '**Drop** request and return `404` status code.',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.STATUS_CODE_451]: '**Drop** request and return `451` status code.',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.SOCKET_DROP]: '**Drop** the socket connection.',
 };
 exports.RESPONSE_RULES_CONDITION_OPERATORS_DESCRIPTION = {
-    [exports.RESPONSE_RULES_CONDITION_OPERATORS.EQUALS]: 'Equals operator checks if the header value exactly matches the specified string, case sensitive. Underlying implementation uses strict string comparison – ===.',
-    [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_EQUALS]: 'Not equals operator checks if the header value does not match the specified string, case sensitive. Underlying implementation uses strict string comparison – !==.',
-    [exports.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS]: 'Contains operator checks if the header value contains the specified string, case sensitive. Underlying implementation uses string.includes().',
-    [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_CONTAINS]: 'Not contains operator checks if the header value does not contain the specified string, case sensitive. Underlying implementation uses string.includes().',
-    [exports.RESPONSE_RULES_CONDITION_OPERATORS.STARTS_WITH]: 'Starts with operator checks if the header value starts with the specified string, case sensitive. Underlying implementation uses string.startsWith().',
-    [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_STARTS_WITH]: 'Not starts with operator checks if the header value does not start with the specified string, case sensitive. Underlying implementation uses string.startsWith().',
-    [exports.RESPONSE_RULES_CONDITION_OPERATORS.ENDS_WITH]: 'Ends with operator checks if the header value ends with the specified string, case sensitive. Underlying implementation uses string.endsWith().',
-    [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_ENDS_WITH]: 'Not ends with operator checks if the header value does not end with the specified string, case sensitive. Underlying implementation uses string.endsWith().',
-    [exports.RESPONSE_RULES_CONDITION_OPERATORS.REGEX]: 'Regex operator checks if the header value matches the specified regex. Underlying implementation uses regex.test().',
-    [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_REGEX]: 'Inverse regex operator checks if the header value does not match the specified regex. Underlying implementation uses regex.test().',
+    [exports.RESPONSE_RULES_CONDITION_OPERATORS.EQUALS]: 'Performs an exact, comparison between the header value and specified string. `string === value`',
+    [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_EQUALS]: 'Ensures the header value does not exactly match the specified string. `string !== value`',
+    [exports.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS]: 'Checks if the header value contains the specified string as a substring. `string.includes()`',
+    [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_CONTAINS]: 'Verifies the header value does not contain the specified string as a substring. `!string.includes()`',
+    [exports.RESPONSE_RULES_CONDITION_OPERATORS.STARTS_WITH]: 'Validates that the header value begins with the specified string. `string.startsWith()`',
+    [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_STARTS_WITH]: 'Validates that the header value does not begin with the specified string. `!string.startsWith()`',
+    [exports.RESPONSE_RULES_CONDITION_OPERATORS.ENDS_WITH]: 'Confirms the header value ends with the specified string. `string.endsWith()`',
+    [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()`',
 };

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;;;;;;;;;;;;;;;;;;;;;;;;;;EAsCtC,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;;;;;;;;;;;;;;;;;;;;;;;;;;EAyDnC,CAAC"}

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

@@ -3,27 +3,42 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResponseRuleConditionSchema = void 0;
 const zod_1 = require("zod");
 const constants_1 = require("../../constants");
-exports.ResponseRuleConditionSchema = zod_1.z.object({
+exports.ResponseRuleConditionSchema = zod_1.z
+    .object({
     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({
-        title: 'Header Name',
-        markdownDescription: 'Name of the HTTP header to check, case insensitive, must comply with RFC 7230.',
+        markdownDescription: '**Name** of the HTTP header to check. Must comply with RFC 7230.',
     })),
     operator: zod_1.z.nativeEnum(constants_1.RESPONSE_RULES_CONDITION_OPERATORS).describe(JSON.stringify({
-        markdownDescription: `Comparison operator to compare the header value against.\n\n${Object.entries(constants_1.RESPONSE_RULES_CONDITION_OPERATORS_DESCRIPTION)
-            .map(([key, description]) => `- **${key}**: ${description}\n`)
-            .join('\n')}`,
+        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 header, case sensitive (excluding regex/not_regex operator). Maximum length is 255 characters.`,
+        markdownDescription: `**Value** to check against the **headerName**.`,
     })),
     caseSensitive: zod_1.z.boolean().describe(JSON.stringify({
-        markdownDescription: 'Whether the value is case sensitive. If true, the value will be compared case sensitive. If false, the value will be lowercased before comparison.',
+        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({
+    markdownDescription: 'Condition to check against the **headerName**.',
+    defaultSnippets: [
+        {
+            label: 'Examples: Check if header contains "text/html"',
+            markdownDescription: 'Condition to check if **headerName** contains "text/html"',
+            body: {
+                headerName: 'accept',
+                operator: 'CONTAINS',
+                value: 'text/html',
+                caseSensitive: true,
+            },
+        },
+    ],
+}));

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;AA0BpB,eAAO,MAAM,+BAA+B;;;;;;;;;;;;;;;;;;;;;GAyCvC,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,+BAA+B;;;;;;;;;;;;;;;;;;;;;GAoEvC,CAAC"}

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

@@ -5,44 +5,54 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResponseRuleModificationsSchema = void 0;
 const zod_1 = __importDefault(require("zod"));
-const exampleJson = JSON.stringify({
-    headers: [
-        {
-            key: 'X-Custom-Header',
-            value: 'Custom Value',
-        },
-    ],
-}, null, 2);
-const exampleHeaderJson = JSON.stringify([
-    {
-        key: 'X-Custom-Header',
-        value: 'Custom Value',
-    },
-], null, 2);
 exports.ResponseRuleModificationsSchema = zod_1.default
     .object({
     headers: zod_1.default
-        .array(zod_1.default.object({
+        .array(zod_1.default
+        .object({
         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({
-            title: '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({
-            title: 'Value',
             markdownDescription: 'Value of the response header. ',
         })),
-    }))
+    })
+        .describe(JSON.stringify({
+        markdownDescription: '**Key** and **value** of the response header will be added to the response.',
+    })))
         .describe(JSON.stringify({
-        markdownDescription: `Array of headers to be added when the rule is matched.\n\nExample:\n\`\`\`json\n${exampleHeaderJson}\n\`\`\``,
+        defaultSnippets: [
+            {
+                label: 'Examples: Add custom header',
+                markdownDescription: 'Add a custom header to the response',
+                body: [
+                    {
+                        key: 'X-Custom-Header',
+                        value: 'CustomValue',
+                    },
+                ],
+            },
+        ],
+        markdownDescription: 'Array of headers to be added when the rule is matched.',
     })),
 })
     .optional()
     .describe(JSON.stringify({
-    markdownDescription: `Response modifications to be applied when the rule is matched.\n\nExample:\n\`\`\`json\n${exampleJson}\n\`\`\``,
+    examples: [
+        {
+            headers: [
+                {
+                    key: 'X-Custom-Header',
+                    value: 'CustomValue',
+                },
+            ],
+        },
+    ],
+    markdownDescription: 'Response modifications to be applied when the rule is matched. Optional.',
 }));

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

@@ -1,4 +1,111 @@
 import { z } from 'zod';
+export declare const ResponseRuleSchemaBase: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodBoolean;
+    operator: z.ZodNativeEnum<{
+        readonly AND: "AND";
+        readonly OR: "OR";
+    }>;
+    conditions: z.ZodArray<z.ZodObject<{
+        headerName: z.ZodString;
+        operator: z.ZodNativeEnum<{
+            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;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        headerName: string;
+        operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
+        caseSensitive: boolean;
+    }, {
+        value: string;
+        headerName: string;
+        operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
+        caseSensitive: boolean;
+    }>, "many">;
+    responseType: z.ZodNativeEnum<{
+        readonly BROWSER: "BROWSER";
+        readonly BLOCK: "BLOCK";
+        readonly STATUS_CODE_404: "STATUS_CODE_404";
+        readonly STATUS_CODE_451: "STATUS_CODE_451";
+        readonly SOCKET_DROP: "SOCKET_DROP";
+        readonly XRAY_JSON: "XRAY_JSON";
+        readonly XRAY_BASE64: "XRAY_BASE64";
+        readonly MIHOMO: "MIHOMO";
+        readonly STASH: "STASH";
+        readonly CLASH: "CLASH";
+        readonly SINGBOX: "SINGBOX";
+    }>;
+    responseModifications: z.ZodOptional<z.ZodObject<{
+        headers: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            value: string;
+            key: string;
+        }, {
+            value: string;
+            key: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        headers: {
+            value: string;
+            key: string;
+        }[];
+    }, {
+        headers: {
+            value: string;
+            key: string;
+        }[];
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    operator: "AND" | "OR";
+    enabled: boolean;
+    conditions: {
+        value: string;
+        headerName: string;
+        operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
+        caseSensitive: boolean;
+    }[];
+    responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
+    description?: string | undefined;
+    responseModifications?: {
+        headers: {
+            value: string;
+            key: string;
+        }[];
+    } | undefined;
+}, {
+    name: string;
+    operator: "AND" | "OR";
+    enabled: boolean;
+    conditions: {
+        value: string;
+        headerName: string;
+        operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
+        caseSensitive: boolean;
+    }[];
+    responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
+    description?: string | undefined;
+    responseModifications?: {
+        headers: {
+            value: string;
+            key: string;
+        }[];
+    } | undefined;
+}>;
 export declare const ResponseRuleSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;

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;AAqCxB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6E1B,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgDjC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqB9B,CAAC"}

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

@@ -1,39 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResponseRuleSchema = void 0;
+exports.ResponseRuleSchema = exports.ResponseRuleSchemaBase = void 0;
 const zod_1 = require("zod");
+const response_rules_examples_1 = require("./response-rules-examples");
 const constants_1 = require("../../constants");
 const response_rule_modifications_schema_1 = require("./response-rule-modifications.schema");
 const response_rule_condition_schema_1 = require("./response-rule-condition.schema");
-const RuleExampleJson = JSON.stringify({
-    name: 'Block Legacy Clients',
-    description: 'Block requests from legacy clients',
-    enabled: true,
-    operator: constants_1.RESPONSE_RULES_OPERATORS.OR,
-    conditions: [
-        {
-            headerName: 'user-agent',
-            operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
-            value: 'Hiddify',
-            caseSensitive: true,
-        },
-        {
-            headerName: 'user-agent',
-            operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
-            value: 'FoxRay',
-            caseSensitive: true,
-        },
-    ],
-    responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
-}, null, 2);
-exports.ResponseRuleSchema = zod_1.z
-    .object({
+exports.ResponseRuleSchemaBase = zod_1.z.object({
     name: zod_1.z
         .string()
         .min(1, 'Name is required')
         .max(50, 'Name must be less than 50 characters')
         .describe(JSON.stringify({
-        title: 'Name',
         markdownDescription: 'Name of the response rule.',
     })),
     description: zod_1.z
@@ -42,49 +20,41 @@ exports.ResponseRuleSchema = zod_1.z
         .max(250, 'Description must be less than 250 characters')
         .optional()
         .describe(JSON.stringify({
-        title: 'Description',
-        markdownDescription: 'Description of the response rule. Maximum length is 250 characters.',
+        markdownDescription: 'Description of the response rule. Optional.',
     })),
     enabled: zod_1.z.boolean().describe(JSON.stringify({
-        markdownDescription: 'Whether the response rule is enabled. If disabled, the rule will not be applied.',
+        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.nativeEnum(constants_1.RESPONSE_RULES_OPERATORS).describe(JSON.stringify({
-        title: 'Operator',
         markdownDescription: 'Operator to use for combining conditions in the rule.',
     })),
-    conditions: zod_1.z.array(response_rule_condition_schema_1.ResponseRuleConditionSchema),
+    conditions: zod_1.z.array(response_rule_condition_schema_1.ResponseRuleConditionSchema).describe(JSON.stringify({
+        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.nativeEnum(constants_1.RESPONSE_RULES_RESPONSE_TYPES).describe(JSON.stringify({
-        markdownDescription: `Type of the response. Determines the type of **response** to be returned when the rule is matched.\n\n${Object.entries(constants_1.RESPONSE_RULES_RESPONSE_TYPES_DESCRIPTION)
-            .map(([key, description]) => `- **${key}**: ${description}\n`)
-            .join('\n')}`,
+        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,
-})
-    .describe(JSON.stringify({
-    title: 'Response Rule',
-    markdownDescription: `\n\nFields:\n- **name**: Name of the response rule (required)\n- **description**: Description of the response rule (optional)\n- **enabled**: Whether the response rule is enabled. If disabled, the rule will not be applied.\n- **operator**: Operator to combine conditions (AND/OR)\n- **conditions**: Array of conditions to match against HTTP headers\n  - **headerName**: Name of the HTTP header to check (case insensitive)\n  - **operator**: Comparison operator (CONTAINS, EQUALS, etc)\n  - **value**: Value to compare against (case sensitive, max 255 chars)\n- **responseType**: Type of response when rule matches (e.g. BLOCK)\n\nExample:\n\`\`\`json\n${RuleExampleJson}\n\`\`\``,
-    examples: [
+});
+exports.ResponseRuleSchema = exports.ResponseRuleSchemaBase.describe(JSON.stringify({
+    defaultSnippets: [
         {
-            name: 'This is example rule name',
-            description: 'This is example rule description (optional)',
-            enabled: true,
-            operator: constants_1.RESPONSE_RULES_OPERATORS.AND,
-            conditions: [
-                {
-                    headerName: 'user-agent',
-                    operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
-                    value: 'Example Rule Value, replace with your own value',
-                    caseSensitive: true,
-                },
-            ],
-            responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
+            label: 'Examples: Blank rule',
+            markdownDescription: `Simple blank rule with no conditions or modifications.\n\`\`\`json\n${JSON.stringify(response_rules_examples_1.EXAMPLES_SRR_BLANK_RULE, null, 2)}\n\`\`\``,
+            body: {
+                ...response_rules_examples_1.EXAMPLES_SRR_BLANK_RULE,
+            },
         },
         {
-            name: 'Empty rule',
-            enabled: true,
-            operator: constants_1.RESPONSE_RULES_OPERATORS.AND,
-            conditions: [],
-            responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
+            label: 'Examples: Block Legacy Clients',
+            markdownDescription: `Block requests from legacy clients\n\`\`\`json\n${JSON.stringify(response_rules_examples_1.EXAMPLES_SRR_BLOCK_LEGACY_CLIENTS_RULE, null, 2)}\n\`\`\``,
+            body: {
+                ...response_rules_examples_1.EXAMPLES_SRR_BLOCK_LEGACY_CLIENTS_RULE,
+            },
         },
     ],
+    title: 'Response Rule',
+    markdownDescription: (0, response_rules_examples_1.generateResponseRuleDescription)(exports.ResponseRuleSchemaBase),
 }));

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;AAoCxB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiCpC,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;AAMxB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAepC,CAAC"}

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

@@ -2,54 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResponseRulesConfigSchema = void 0;
 const zod_1 = require("zod");
+const response_rules_examples_1 = require("./response-rules-examples");
 const constants_1 = require("../../constants");
 const response_rule_schema_1 = require("./response-rule.schema");
-const RuleExampleJson = JSON.stringify({
-    name: 'Block Legacy Clients',
-    description: 'Block requests from legacy clients',
-    operator: constants_1.RESPONSE_RULES_OPERATORS.OR,
-    enabled: true,
-    conditions: [
-        {
-            headerName: 'user-agent',
-            operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
-            value: 'Hiddify',
-            caseSensitive: true,
-        },
-        {
-            headerName: 'user-agent',
-            operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
-            value: 'FoxRay',
-            caseSensitive: true,
-        },
-    ],
-    responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
-}, null, 2);
 exports.ResponseRulesConfigSchema = zod_1.z.object({
     version: zod_1.z.nativeEnum(constants_1.RESPONSE_RULES_CONFIG_VERSION).describe(JSON.stringify({
         title: 'Response Rules Config Version',
         markdownDescription: 'Version of the **response rules** config. Currently supported version is **1**.',
     })),
     rules: zod_1.z.array(response_rule_schema_1.ResponseRuleSchema).describe(JSON.stringify({
-        examples: [
-            [
-                {
-                    name: 'This is example rule name',
-                    description: 'This is example rule description (optional)',
-                    operator: constants_1.RESPONSE_RULES_OPERATORS.AND,
-                    enabled: true,
-                    conditions: [
-                        {
-                            headerName: 'user-agent',
-                            operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
-                            value: 'Example Rule Value, replace with your own value',
-                            caseSensitive: true,
-                        },
-                    ],
-                    responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
-                },
-            ],
-        ],
-        markdownDescription: `Array of **response rules**.\n\nRules served from top to bottom – first matched rule is applied. Each rule is an object with the following properties:\n\n- **name**: Name of the response rule.\n- **description**: Description of the response rule.(Optional) \n- **enabled**: Whether the response rule is enabled. If disabled, the rule will not be applied.\n- **operator**: Operator to use for the rule.\n- **conditions**: Array of conditions to use for the rule.\n- **responseType**: Type of the response.\n\nExamples:\n\n1. Block legacy clients:\n\n\`\`\`json\n${RuleExampleJson}\n\`\`\`\n\nThis example shows how to block requests from legacy clients by checking if the User-Agent header contains "Hiddify" or "FoxRay".`,
+        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

@@ -0,0 +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>;
+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

@@ -0,0 +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"}

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXAMPLES_SRR_BLOCK_LEGACY_CLIENTS_RULE = exports.EXAMPLES_SRR_BLANK_RULE = void 0;
+exports.generateResponseRuleDescription = generateResponseRuleDescription;
+const constants_1 = require("../../constants");
+exports.EXAMPLES_SRR_BLANK_RULE = {
+    name: 'Blank rule',
+    description: 'Blank rule',
+    operator: 'AND',
+    enabled: true,
+    conditions: [],
+    responseType: 'BLOCK',
+    responseModifications: {
+        headers: [],
+    },
+};
+exports.EXAMPLES_SRR_BLOCK_LEGACY_CLIENTS_RULE = {
+    name: 'Block Legacy Clients',
+    description: 'Block requests from legacy clients',
+    enabled: true,
+    operator: constants_1.RESPONSE_RULES_OPERATORS.OR,
+    conditions: [
+        {
+            headerName: 'user-agent',
+            operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
+            value: 'Hiddify',
+            caseSensitive: true,
+        },
+        {
+            headerName: 'user-agent',
+            operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
+            value: 'FoxRay',
+            caseSensitive: true,
+        },
+    ],
+    responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
+};
+function generateResponseRuleDescription(schema) {
+    const fields = Object.entries(schema.shape).map(([key, value]) => {
+        const desc = value.description ? JSON.parse(value.description) : {};
+        return {
+            name: key,
+            description: desc.markdownDescription || desc.title || 'No description',
+        };
+    });
+    const fieldsText = fields
+        .map((field) => `- **${field.name}**: ${field.description}`)
+        .join('\n');
+    return `Response rule configuration.\n\n**Fields:**\n${fieldsText}\n\n**Example:**\n\`\`\`json\n${JSON.stringify(exports.EXAMPLES_SRR_BLOCK_LEGACY_CLIENTS_RULE, null, 2)}\n\`\`\``;
+}

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

@@ -28,27 +28,27 @@ exports.RESPONSE_RULES_RESPONSE_TYPES = Object.assign(Object.assign({}, subscrip
 exports.RESPONSE_RULES_RESPONSE_TYPES_VALUES = Object.values(exports.RESPONSE_RULES_RESPONSE_TYPES);
 exports.RESPONSE_RULES_CONDITION_OPERATORS_VALUES = Object.values(exports.RESPONSE_RULES_CONDITION_OPERATORS);
 exports.RESPONSE_RULES_RESPONSE_TYPES_DESCRIPTION = {
-    [exports.RESPONSE_RULES_RESPONSE_TYPES.BLOCK]: 'Block response type blocks the request and returns a 403 status code.',
-    [exports.RESPONSE_RULES_RESPONSE_TYPES.XRAY_BASE64]: 'Previously used as fallback response type. It return subscription as base64 encoded string. Compatible with most client application with Xray core.',
-    [exports.RESPONSE_RULES_RESPONSE_TYPES.STATUS_CODE_404]: 'Status code 404 response type returns a 404 status code. This response type is used to return a 404 status code.',
-    [exports.RESPONSE_RULES_RESPONSE_TYPES.STATUS_CODE_451]: 'Status code 451 response type returns a 451 status code. This response type is used to return a 451 status code.',
-    [exports.RESPONSE_RULES_RESPONSE_TYPES.SOCKET_DROP]: 'Socket drop response type drops the socket connection. This response type is used to drop the socket connection.',
-    [exports.RESPONSE_RULES_RESPONSE_TYPES.CLASH]: 'Useful for client application that use Legacy Clash core. It return subscription as Clash YAML format.',
-    [exports.RESPONSE_RULES_RESPONSE_TYPES.STASH]: 'Format which is used by Stash client application.',
-    [exports.RESPONSE_RULES_RESPONSE_TYPES.SINGBOX]: 'Format which is used by Singbox client application.',
-    [exports.RESPONSE_RULES_RESPONSE_TYPES.MIHOMO]: 'Return subscription as Mihomo Core YAML format.',
-    [exports.RESPONSE_RULES_RESPONSE_TYPES.XRAY_JSON]: 'Return subscription as Xray JSON format.',
-    [exports.RESPONSE_RULES_RESPONSE_TYPES.BROWSER]: 'Return subscription as browser format.',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.XRAY_JSON]: 'Return **subscription** in XRAY-JSON format. (Using `Xray Json` template)',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.XRAY_BASE64]: 'Return **subscription** in BASE64 encoded string. Compatible with most client application with Xray core.',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.MIHOMO]: 'Return **subscription** in Mihomo format. (Using `Mihomo` template)',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.STASH]: 'Return **subscription** in Stash format. (Using `Stash` template)',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.CLASH]: 'Return **subscription** in Clash format. (Using `Clash` template) Useful for client application that use Legacy Clash core.',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.SINGBOX]: 'Return **subscription** in Singbox format. (Using `Singbox` template) Format which is used by Singbox client application.',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.BROWSER]: 'Return **subscription** as browser format. The same as on `/info` route.',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.BLOCK]: '**Drop** request and return `403` status code.',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.STATUS_CODE_404]: '**Drop** request and return `404` status code.',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.STATUS_CODE_451]: '**Drop** request and return `451` status code.',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.SOCKET_DROP]: '**Drop** the socket connection.',
 };
 exports.RESPONSE_RULES_CONDITION_OPERATORS_DESCRIPTION = {
-    [exports.RESPONSE_RULES_CONDITION_OPERATORS.EQUALS]: 'Equals operator checks if the header value exactly matches the specified string, case sensitive. Underlying implementation uses strict string comparison – ===.',
-    [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_EQUALS]: 'Not equals operator checks if the header value does not match the specified string, case sensitive. Underlying implementation uses strict string comparison – !==.',
-    [exports.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS]: 'Contains operator checks if the header value contains the specified string, case sensitive. Underlying implementation uses string.includes().',
-    [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_CONTAINS]: 'Not contains operator checks if the header value does not contain the specified string, case sensitive. Underlying implementation uses string.includes().',
-    [exports.RESPONSE_RULES_CONDITION_OPERATORS.STARTS_WITH]: 'Starts with operator checks if the header value starts with the specified string, case sensitive. Underlying implementation uses string.startsWith().',
-    [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_STARTS_WITH]: 'Not starts with operator checks if the header value does not start with the specified string, case sensitive. Underlying implementation uses string.startsWith().',
-    [exports.RESPONSE_RULES_CONDITION_OPERATORS.ENDS_WITH]: 'Ends with operator checks if the header value ends with the specified string, case sensitive. Underlying implementation uses string.endsWith().',
-    [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_ENDS_WITH]: 'Not ends with operator checks if the header value does not end with the specified string, case sensitive. Underlying implementation uses string.endsWith().',
-    [exports.RESPONSE_RULES_CONDITION_OPERATORS.REGEX]: 'Regex operator checks if the header value matches the specified regex. Underlying implementation uses regex.test().',
-    [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_REGEX]: 'Inverse regex operator checks if the header value does not match the specified regex. Underlying implementation uses regex.test().',
+    [exports.RESPONSE_RULES_CONDITION_OPERATORS.EQUALS]: 'Performs an exact, comparison between the header value and specified string. `string === value`',
+    [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_EQUALS]: 'Ensures the header value does not exactly match the specified string. `string !== value`',
+    [exports.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS]: 'Checks if the header value contains the specified string as a substring. `string.includes()`',
+    [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_CONTAINS]: 'Verifies the header value does not contain the specified string as a substring. `!string.includes()`',
+    [exports.RESPONSE_RULES_CONDITION_OPERATORS.STARTS_WITH]: 'Validates that the header value begins with the specified string. `string.startsWith()`',
+    [exports.RESPONSE_RULES_CONDITION_OPERATORS.NOT_STARTS_WITH]: 'Validates that the header value does not begin with the specified string. `!string.startsWith()`',
+    [exports.RESPONSE_RULES_CONDITION_OPERATORS.ENDS_WITH]: 'Confirms the header value ends with the specified string. `string.endsWith()`',
+    [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()`',
 };

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

@@ -3,27 +3,42 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResponseRuleConditionSchema = void 0;
 const zod_1 = require("zod");
 const constants_1 = require("../../constants");
-exports.ResponseRuleConditionSchema = zod_1.z.object({
+exports.ResponseRuleConditionSchema = zod_1.z
+    .object({
     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({
-        title: 'Header Name',
-        markdownDescription: 'Name of the HTTP header to check, case insensitive, must comply with RFC 7230.',
+        markdownDescription: '**Name** of the HTTP header to check. Must comply with RFC 7230.',
     })),
     operator: zod_1.z.nativeEnum(constants_1.RESPONSE_RULES_CONDITION_OPERATORS).describe(JSON.stringify({
-        markdownDescription: `Comparison operator to compare the header value against.\n\n${Object.entries(constants_1.RESPONSE_RULES_CONDITION_OPERATORS_DESCRIPTION)
-            .map(([key, description]) => `- **${key}**: ${description}\n`)
-            .join('\n')}`,
+        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 header, case sensitive (excluding regex/not_regex operator). Maximum length is 255 characters.`,
+        markdownDescription: `**Value** to check against the **headerName**.`,
     })),
     caseSensitive: zod_1.z.boolean().describe(JSON.stringify({
-        markdownDescription: 'Whether the value is case sensitive. If true, the value will be compared case sensitive. If false, the value will be lowercased before comparison.',
+        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({
+    markdownDescription: 'Condition to check against the **headerName**.',
+    defaultSnippets: [
+        {
+            label: 'Examples: Check if header contains "text/html"',
+            markdownDescription: 'Condition to check if **headerName** contains "text/html"',
+            body: {
+                headerName: 'accept',
+                operator: 'CONTAINS',
+                value: 'text/html',
+                caseSensitive: true,
+            },
+        },
+    ],
+}));

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

@@ -5,44 +5,54 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResponseRuleModificationsSchema = void 0;
 const zod_1 = __importDefault(require("zod"));
-const exampleJson = JSON.stringify({
-    headers: [
-        {
-            key: 'X-Custom-Header',
-            value: 'Custom Value',
-        },
-    ],
-}, null, 2);
-const exampleHeaderJson = JSON.stringify([
-    {
-        key: 'X-Custom-Header',
-        value: 'Custom Value',
-    },
-], null, 2);
 exports.ResponseRuleModificationsSchema = zod_1.default
     .object({
     headers: zod_1.default
-        .array(zod_1.default.object({
+        .array(zod_1.default
+        .object({
         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({
-            title: '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({
-            title: 'Value',
             markdownDescription: 'Value of the response header. ',
         })),
-    }))
+    })
+        .describe(JSON.stringify({
+        markdownDescription: '**Key** and **value** of the response header will be added to the response.',
+    })))
         .describe(JSON.stringify({
-        markdownDescription: `Array of headers to be added when the rule is matched.\n\nExample:\n\`\`\`json\n${exampleHeaderJson}\n\`\`\``,
+        defaultSnippets: [
+            {
+                label: 'Examples: Add custom header',
+                markdownDescription: 'Add a custom header to the response',
+                body: [
+                    {
+                        key: 'X-Custom-Header',
+                        value: 'CustomValue',
+                    },
+                ],
+            },
+        ],
+        markdownDescription: 'Array of headers to be added when the rule is matched.',
     })),
 })
     .optional()
     .describe(JSON.stringify({
-    markdownDescription: `Response modifications to be applied when the rule is matched.\n\nExample:\n\`\`\`json\n${exampleJson}\n\`\`\``,
+    examples: [
+        {
+            headers: [
+                {
+                    key: 'X-Custom-Header',
+                    value: 'CustomValue',
+                },
+            ],
+        },
+    ],
+    markdownDescription: 'Response modifications to be applied when the rule is matched. Optional.',
 }));

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

@@ -1,39 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResponseRuleSchema = void 0;
+exports.ResponseRuleSchema = exports.ResponseRuleSchemaBase = void 0;
 const zod_1 = require("zod");
+const response_rules_examples_1 = require("./response-rules-examples");
 const constants_1 = require("../../constants");
 const response_rule_modifications_schema_1 = require("./response-rule-modifications.schema");
 const response_rule_condition_schema_1 = require("./response-rule-condition.schema");
-const RuleExampleJson = JSON.stringify({
-    name: 'Block Legacy Clients',
-    description: 'Block requests from legacy clients',
-    enabled: true,
-    operator: constants_1.RESPONSE_RULES_OPERATORS.OR,
-    conditions: [
-        {
-            headerName: 'user-agent',
-            operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
-            value: 'Hiddify',
-            caseSensitive: true,
-        },
-        {
-            headerName: 'user-agent',
-            operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
-            value: 'FoxRay',
-            caseSensitive: true,
-        },
-    ],
-    responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
-}, null, 2);
-exports.ResponseRuleSchema = zod_1.z
-    .object({
+exports.ResponseRuleSchemaBase = zod_1.z.object({
     name: zod_1.z
         .string()
         .min(1, 'Name is required')
         .max(50, 'Name must be less than 50 characters')
         .describe(JSON.stringify({
-        title: 'Name',
         markdownDescription: 'Name of the response rule.',
     })),
     description: zod_1.z
@@ -42,49 +20,37 @@ exports.ResponseRuleSchema = zod_1.z
         .max(250, 'Description must be less than 250 characters')
         .optional()
         .describe(JSON.stringify({
-        title: 'Description',
-        markdownDescription: 'Description of the response rule. Maximum length is 250 characters.',
+        markdownDescription: 'Description of the response rule. Optional.',
     })),
     enabled: zod_1.z.boolean().describe(JSON.stringify({
-        markdownDescription: 'Whether the response rule is enabled. If disabled, the rule will not be applied.',
+        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.nativeEnum(constants_1.RESPONSE_RULES_OPERATORS).describe(JSON.stringify({
-        title: 'Operator',
         markdownDescription: 'Operator to use for combining conditions in the rule.',
     })),
-    conditions: zod_1.z.array(response_rule_condition_schema_1.ResponseRuleConditionSchema),
+    conditions: zod_1.z.array(response_rule_condition_schema_1.ResponseRuleConditionSchema).describe(JSON.stringify({
+        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.nativeEnum(constants_1.RESPONSE_RULES_RESPONSE_TYPES).describe(JSON.stringify({
-        markdownDescription: `Type of the response. Determines the type of **response** to be returned when the rule is matched.\n\n${Object.entries(constants_1.RESPONSE_RULES_RESPONSE_TYPES_DESCRIPTION)
-            .map(([key, description]) => `- **${key}**: ${description}\n`)
-            .join('\n')}`,
+        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,
-})
-    .describe(JSON.stringify({
-    title: 'Response Rule',
-    markdownDescription: `\n\nFields:\n- **name**: Name of the response rule (required)\n- **description**: Description of the response rule (optional)\n- **enabled**: Whether the response rule is enabled. If disabled, the rule will not be applied.\n- **operator**: Operator to combine conditions (AND/OR)\n- **conditions**: Array of conditions to match against HTTP headers\n  - **headerName**: Name of the HTTP header to check (case insensitive)\n  - **operator**: Comparison operator (CONTAINS, EQUALS, etc)\n  - **value**: Value to compare against (case sensitive, max 255 chars)\n- **responseType**: Type of response when rule matches (e.g. BLOCK)\n\nExample:\n\`\`\`json\n${RuleExampleJson}\n\`\`\``,
-    examples: [
+});
+exports.ResponseRuleSchema = exports.ResponseRuleSchemaBase.describe(JSON.stringify({
+    defaultSnippets: [
         {
-            name: 'This is example rule name',
-            description: 'This is example rule description (optional)',
-            enabled: true,
-            operator: constants_1.RESPONSE_RULES_OPERATORS.AND,
-            conditions: [
-                {
-                    headerName: 'user-agent',
-                    operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
-                    value: 'Example Rule Value, replace with your own value',
-                    caseSensitive: true,
-                },
-            ],
-            responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
+            label: 'Examples: Blank rule',
+            markdownDescription: `Simple blank rule with no conditions or modifications.\n\`\`\`json\n${JSON.stringify(response_rules_examples_1.EXAMPLES_SRR_BLANK_RULE, null, 2)}\n\`\`\``,
+            body: Object.assign({}, response_rules_examples_1.EXAMPLES_SRR_BLANK_RULE),
         },
         {
-            name: 'Empty rule',
-            enabled: true,
-            operator: constants_1.RESPONSE_RULES_OPERATORS.AND,
-            conditions: [],
-            responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
+            label: 'Examples: Block Legacy Clients',
+            markdownDescription: `Block requests from legacy clients\n\`\`\`json\n${JSON.stringify(response_rules_examples_1.EXAMPLES_SRR_BLOCK_LEGACY_CLIENTS_RULE, null, 2)}\n\`\`\``,
+            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

@@ -2,54 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResponseRulesConfigSchema = void 0;
 const zod_1 = require("zod");
+const response_rules_examples_1 = require("./response-rules-examples");
 const constants_1 = require("../../constants");
 const response_rule_schema_1 = require("./response-rule.schema");
-const RuleExampleJson = JSON.stringify({
-    name: 'Block Legacy Clients',
-    description: 'Block requests from legacy clients',
-    operator: constants_1.RESPONSE_RULES_OPERATORS.OR,
-    enabled: true,
-    conditions: [
-        {
-            headerName: 'user-agent',
-            operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
-            value: 'Hiddify',
-            caseSensitive: true,
-        },
-        {
-            headerName: 'user-agent',
-            operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
-            value: 'FoxRay',
-            caseSensitive: true,
-        },
-    ],
-    responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
-}, null, 2);
 exports.ResponseRulesConfigSchema = zod_1.z.object({
     version: zod_1.z.nativeEnum(constants_1.RESPONSE_RULES_CONFIG_VERSION).describe(JSON.stringify({
         title: 'Response Rules Config Version',
         markdownDescription: 'Version of the **response rules** config. Currently supported version is **1**.',
     })),
     rules: zod_1.z.array(response_rule_schema_1.ResponseRuleSchema).describe(JSON.stringify({
-        examples: [
-            [
-                {
-                    name: 'This is example rule name',
-                    description: 'This is example rule description (optional)',
-                    operator: constants_1.RESPONSE_RULES_OPERATORS.AND,
-                    enabled: true,
-                    conditions: [
-                        {
-                            headerName: 'user-agent',
-                            operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
-                            value: 'Example Rule Value, replace with your own value',
-                            caseSensitive: true,
-                        },
-                    ],
-                    responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
-                },
-            ],
-        ],
-        markdownDescription: `Array of **response rules**.\n\nRules served from top to bottom – first matched rule is applied. Each rule is an object with the following properties:\n\n- **name**: Name of the response rule.\n- **description**: Description of the response rule.(Optional) \n- **enabled**: Whether the response rule is enabled. If disabled, the rule will not be applied.\n- **operator**: Operator to use for the rule.\n- **conditions**: Array of conditions to use for the rule.\n- **responseType**: Type of the response.\n\nExamples:\n\n1. Block legacy clients:\n\n\`\`\`json\n${RuleExampleJson}\n\`\`\`\n\nThis example shows how to block requests from legacy clients by checking if the User-Agent header contains "Hiddify" or "FoxRay".`,
+        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/response-rules/response-rules-examples.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXAMPLES_SRR_BLOCK_LEGACY_CLIENTS_RULE = exports.EXAMPLES_SRR_BLANK_RULE = void 0;
+exports.generateResponseRuleDescription = generateResponseRuleDescription;
+const constants_1 = require("../../constants");
+exports.EXAMPLES_SRR_BLANK_RULE = {
+    name: 'Blank rule',
+    description: 'Blank rule',
+    operator: 'AND',
+    enabled: true,
+    conditions: [],
+    responseType: 'BLOCK',
+    responseModifications: {
+        headers: [],
+    },
+};
+exports.EXAMPLES_SRR_BLOCK_LEGACY_CLIENTS_RULE = {
+    name: 'Block Legacy Clients',
+    description: 'Block requests from legacy clients',
+    enabled: true,
+    operator: constants_1.RESPONSE_RULES_OPERATORS.OR,
+    conditions: [
+        {
+            headerName: 'user-agent',
+            operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
+            value: 'Hiddify',
+            caseSensitive: true,
+        },
+        {
+            headerName: 'user-agent',
+            operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
+            value: 'FoxRay',
+            caseSensitive: true,
+        },
+    ],
+    responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
+};
+function generateResponseRuleDescription(schema) {
+    const fields = Object.entries(schema.shape).map(([key, value]) => {
+        const desc = value.description ? JSON.parse(value.description) : {};
+        return {
+            name: key,
+            description: desc.markdownDescription || desc.title || 'No description',
+        };
+    });
+    const fieldsText = fields
+        .map((field) => `- **${field.name}**: ${field.description}`)
+        .join('\n');
+    return `Response rule configuration.\n\n**Fields:**\n${fieldsText}\n\n**Example:**\n\`\`\`json\n${JSON.stringify(exports.EXAMPLES_SRR_BLOCK_LEGACY_CLIENTS_RULE, null, 2)}\n\`\`\``;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnawave/backend-contract",
-  "version": "2.1.82",
+  "version": "2.2.1",
   "public": true,
   "license": "AGPL-3.0-only",
   "description": "A contract library for Remnawave Backend. It can be used in backend and frontend.",