@remnawave/backend-contract 2.1.74 → 2.1.76

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

@@ -20,9 +20,21 @@ export declare const RESPONSE_RULES_CONDITION_OPERATORS: {
     readonly REGEX: "REGEX";
     readonly NOT_REGEX: "NOT_REGEX";
 };
+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().";
+};
 export declare const RESPONSE_RULES_RESPONSE_TYPES: {
     readonly BLOCK: "BLOCK";
-    readonly BASE64: "BASE64";
+    readonly XRAY_BASE64: "XRAY_BASE64";
     readonly STATUS_CODE_404: "STATUS_CODE_404";
     readonly STATUS_CODE_403: "STATUS_CODE_403";
     readonly STATUS_CODE_451: "STATUS_CODE_451";
@@ -34,4 +46,17 @@ export declare const RESPONSE_RULES_RESPONSE_TYPES: {
     readonly XRAY_JSON: "XRAY_JSON";
     readonly CLASH: "CLASH";
 };
+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 SINGBOX_LEGACY: "Format which is used by Singbox client application (legacy version).";
+    readonly MIHOMO: "Return subscription as Mihomo Core YAML format.";
+    readonly XRAY_JSON: "Return subscription as Xray JSON format.";
+};
 //# 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;;;;;;;;;;;;;CAQhC,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,8CAA8C;;;;;;;;;;;CAqBjD,CAAC;AAEX,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;CAQhC,CAAC;AAEX,eAAO,MAAM,yCAAyC;;;;;;;;;;;;CAmB5C,CAAC"}

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RESPONSE_RULES_RESPONSE_TYPES = exports.RESPONSE_RULES_CONDITION_OPERATORS = exports.RESPONSE_RULE_CONDITION_TYPES = exports.RESPONSE_RULES_OPERATORS = exports.RESPONSE_RULES_CONFIG_VERSION = void 0;
+exports.RESPONSE_RULES_RESPONSE_TYPES_DESCRIPTION = exports.RESPONSE_RULES_RESPONSE_TYPES = exports.RESPONSE_RULES_CONDITION_OPERATORS_DESCRIPTION = exports.RESPONSE_RULES_CONDITION_OPERATORS = exports.RESPONSE_RULE_CONDITION_TYPES = exports.RESPONSE_RULES_OPERATORS = exports.RESPONSE_RULES_CONFIG_VERSION = void 0;
 const subscription_template_1 = require("../subscription-template");
 exports.RESPONSE_RULES_CONFIG_VERSION = {
     1: '1',
@@ -24,12 +24,37 @@ exports.RESPONSE_RULES_CONDITION_OPERATORS = {
     REGEX: 'REGEX',
     NOT_REGEX: 'NOT_REGEX',
 };
+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_RESPONSE_TYPES = {
     ...subscription_template_1.SUBSCRIPTION_TEMPLATE_TYPE,
     BLOCK: 'BLOCK',
-    BASE64: 'BASE64',
+    XRAY_BASE64: 'XRAY_BASE64',
     STATUS_CODE_404: 'STATUS_CODE_404',
     STATUS_CODE_403: 'STATUS_CODE_403',
     STATUS_CODE_451: 'STATUS_CODE_451',
     SOCKET_DROP: 'SOCKET_DROP',
 };
+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.SINGBOX_LEGACY]: 'Format which is used by Singbox client application (legacy version).',
+    [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.',
+};

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

@@ -1,4 +1,3 @@
 export * from './response-rule.schema';
 export * from './response-rules-config.schema';
-export * from './response-rules-json-schema';
 //# sourceMappingURL=index.d.ts.map

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

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

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

@@ -16,4 +16,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./response-rule.schema"), exports);
 __exportStar(require("./response-rules-config.schema"), exports);
-__exportStar(require("./response-rules-json-schema"), exports);

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

@@ -2,6 +2,7 @@ import { z } from 'zod';
 export declare const ResponseRuleSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodBoolean;
     operator: z.ZodNativeEnum<{
         readonly AND: "AND";
         readonly OR: "OR";
@@ -32,7 +33,7 @@ export declare const ResponseRuleSchema: z.ZodObject<{
     }>, "many">;
     responseType: z.ZodNativeEnum<{
         readonly BLOCK: "BLOCK";
-        readonly BASE64: "BASE64";
+        readonly XRAY_BASE64: "XRAY_BASE64";
         readonly STATUS_CODE_404: "STATUS_CODE_404";
         readonly STATUS_CODE_403: "STATUS_CODE_403";
         readonly STATUS_CODE_451: "STATUS_CODE_451";
@@ -46,23 +47,25 @@ export declare const ResponseRuleSchema: z.ZodObject<{
     }>;
 }, "strip", z.ZodTypeAny, {
     name: string;
+    enabled: boolean;
     operator: "AND" | "OR";
     conditions: {
         value: string;
         operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
         headerName: string;
     }[];
-    responseType: "STASH" | "SINGBOX" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "BLOCK" | "BASE64" | "STATUS_CODE_404" | "STATUS_CODE_403" | "STATUS_CODE_451" | "SOCKET_DROP";
+    responseType: "STASH" | "SINGBOX" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "BLOCK" | "XRAY_BASE64" | "STATUS_CODE_404" | "STATUS_CODE_403" | "STATUS_CODE_451" | "SOCKET_DROP";
     description?: string | undefined;
 }, {
     name: string;
+    enabled: boolean;
     operator: "AND" | "OR";
     conditions: {
         value: string;
         operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
         headerName: string;
     }[];
-    responseType: "STASH" | "SINGBOX" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "BLOCK" | "BASE64" | "STATUS_CODE_404" | "STATUS_CODE_403" | "STATUS_CODE_451" | "SOCKET_DROP";
+    responseType: "STASH" | "SINGBOX" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "BLOCK" | "XRAY_BASE64" | "STATUS_CODE_404" | "STATUS_CODE_403" | "STATUS_CODE_451" | "SOCKET_DROP";
     description?: string | undefined;
 }>;
 //# sourceMappingURL=response-rule.schema.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"response-rule.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rule.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8B7B,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;AAkCxB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6G1B,CAAC"}

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

@@ -3,27 +3,102 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResponseRuleSchema = void 0;
 const zod_1 = require("zod");
 const constants_1 = require("../../constants");
-exports.ResponseRuleSchema = zod_1.z.object({
-    name: zod_1.z.string().min(1, 'Name is required').max(50, 'Name must be less than 50 characters'),
+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',
+        },
+        {
+            headerName: 'user-agent',
+            operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
+            value: 'FoxRay',
+        },
+    ],
+    responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
+}, null, 2);
+exports.ResponseRuleSchema = 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
         .string()
         .min(1, 'Description is required')
         .max(250, 'Description must be less than 250 characters')
-        .optional(),
-    operator: zod_1.z.nativeEnum(constants_1.RESPONSE_RULES_OPERATORS).describe('Operator to use for the rule.'),
+        .optional()
+        .describe(JSON.stringify({
+        title: 'Description',
+        markdownDescription: 'Description of the response rule. Maximum length is 250 characters.',
+    })),
+    enabled: zod_1.z.boolean().describe(JSON.stringify({
+        markdownDescription: 'Whether the response rule is enabled. If disabled, the rule will not be applied.',
+    })),
+    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(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('Name of the HTTP header to check, case insensitive, must comply with RFC 7230.'),
-        operator: zod_1.z
-            .nativeEnum(constants_1.RESPONSE_RULES_CONDITION_OPERATORS)
-            .describe('Operator to use for the condition.'),
+            .describe(JSON.stringify({
+            title: 'Header Name',
+            markdownDescription: 'Name of the HTTP header to check, case insensitive, 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')}`,
+        })),
         value: zod_1.z
             .string()
             .min(1, 'Value is required')
             .max(255, 'Value must be less than 255 characters')
-            .describe('Value to check against the header, case sensitive.'),
+            .describe(JSON.stringify({
+            markdownDescription: `Value to check against the header, case sensitive (excluding regex/not_regex operator). Maximum length is 255 characters.`,
+        })),
+    })),
+    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')}`,
     })),
-    responseType: zod_1.z.nativeEnum(constants_1.RESPONSE_RULES_RESPONSE_TYPES).describe('Type of the response.'),
-});
+})
+    .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: [
+        {
+            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',
+                },
+            ],
+            responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
+        },
+        {
+            name: 'Empty rule',
+            enabled: true,
+            operator: constants_1.RESPONSE_RULES_OPERATORS.AND,
+            conditions: [],
+            responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
+        },
+    ],
+}));

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

@@ -6,6 +6,7 @@ export declare const ResponseRulesConfigSchema: z.ZodObject<{
     rules: z.ZodArray<z.ZodObject<{
         name: z.ZodString;
         description: z.ZodOptional<z.ZodString>;
+        enabled: z.ZodBoolean;
         operator: z.ZodNativeEnum<{
             readonly AND: "AND";
             readonly OR: "OR";
@@ -36,7 +37,7 @@ export declare const ResponseRulesConfigSchema: z.ZodObject<{
         }>, "many">;
         responseType: z.ZodNativeEnum<{
             readonly BLOCK: "BLOCK";
-            readonly BASE64: "BASE64";
+            readonly XRAY_BASE64: "XRAY_BASE64";
             readonly STATUS_CODE_404: "STATUS_CODE_404";
             readonly STATUS_CODE_403: "STATUS_CODE_403";
             readonly STATUS_CODE_451: "STATUS_CODE_451";
@@ -50,49 +51,53 @@ export declare const ResponseRulesConfigSchema: z.ZodObject<{
         }>;
     }, "strip", z.ZodTypeAny, {
         name: string;
+        enabled: boolean;
         operator: "AND" | "OR";
         conditions: {
             value: string;
             operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
             headerName: string;
         }[];
-        responseType: "STASH" | "SINGBOX" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "BLOCK" | "BASE64" | "STATUS_CODE_404" | "STATUS_CODE_403" | "STATUS_CODE_451" | "SOCKET_DROP";
+        responseType: "STASH" | "SINGBOX" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "BLOCK" | "XRAY_BASE64" | "STATUS_CODE_404" | "STATUS_CODE_403" | "STATUS_CODE_451" | "SOCKET_DROP";
         description?: string | undefined;
     }, {
         name: string;
+        enabled: boolean;
         operator: "AND" | "OR";
         conditions: {
             value: string;
             operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
             headerName: string;
         }[];
-        responseType: "STASH" | "SINGBOX" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "BLOCK" | "BASE64" | "STATUS_CODE_404" | "STATUS_CODE_403" | "STATUS_CODE_451" | "SOCKET_DROP";
+        responseType: "STASH" | "SINGBOX" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "BLOCK" | "XRAY_BASE64" | "STATUS_CODE_404" | "STATUS_CODE_403" | "STATUS_CODE_451" | "SOCKET_DROP";
         description?: string | undefined;
     }>, "many">;
 }, "strip", z.ZodTypeAny, {
     version: "1";
     rules: {
         name: string;
+        enabled: boolean;
         operator: "AND" | "OR";
         conditions: {
             value: string;
             operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
             headerName: string;
         }[];
-        responseType: "STASH" | "SINGBOX" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "BLOCK" | "BASE64" | "STATUS_CODE_404" | "STATUS_CODE_403" | "STATUS_CODE_451" | "SOCKET_DROP";
+        responseType: "STASH" | "SINGBOX" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "BLOCK" | "XRAY_BASE64" | "STATUS_CODE_404" | "STATUS_CODE_403" | "STATUS_CODE_451" | "SOCKET_DROP";
         description?: string | undefined;
     }[];
 }, {
     version: "1";
     rules: {
         name: string;
+        enabled: boolean;
         operator: "AND" | "OR";
         conditions: {
             value: string;
             operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
             headerName: string;
         }[];
-        responseType: "STASH" | "SINGBOX" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "BLOCK" | "BASE64" | "STATUS_CODE_404" | "STATUS_CODE_403" | "STATUS_CODE_451" | "SOCKET_DROP";
+        responseType: "STASH" | "SINGBOX" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "BLOCK" | "XRAY_BASE64" | "STATUS_CODE_404" | "STATUS_CODE_403" | "STATUS_CODE_451" | "SOCKET_DROP";
         description?: string | undefined;
     }[];
 }>;

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;AAKxB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGpC,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;AAkCxB,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgCpC,CAAC"}

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

@@ -4,7 +4,49 @@ exports.ResponseRulesConfigSchema = void 0;
 const zod_1 = require("zod");
 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',
+        },
+        {
+            headerName: 'user-agent',
+            operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
+            value: 'FoxRay',
+        },
+    ],
+    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),
-    rules: zod_1.z.array(response_rule_schema_1.ResponseRuleSchema),
+    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',
+                        },
+                    ],
+                    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".`,
+    })),
 });

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RESPONSE_RULES_RESPONSE_TYPES = exports.RESPONSE_RULES_CONDITION_OPERATORS = exports.RESPONSE_RULE_CONDITION_TYPES = exports.RESPONSE_RULES_OPERATORS = exports.RESPONSE_RULES_CONFIG_VERSION = void 0;
+exports.RESPONSE_RULES_RESPONSE_TYPES_DESCRIPTION = exports.RESPONSE_RULES_RESPONSE_TYPES = exports.RESPONSE_RULES_CONDITION_OPERATORS_DESCRIPTION = exports.RESPONSE_RULES_CONDITION_OPERATORS = exports.RESPONSE_RULE_CONDITION_TYPES = exports.RESPONSE_RULES_OPERATORS = exports.RESPONSE_RULES_CONFIG_VERSION = void 0;
 const subscription_template_1 = require("../subscription-template");
 exports.RESPONSE_RULES_CONFIG_VERSION = {
     1: '1',
@@ -24,4 +24,29 @@ exports.RESPONSE_RULES_CONDITION_OPERATORS = {
     REGEX: 'REGEX',
     NOT_REGEX: 'NOT_REGEX',
 };
-exports.RESPONSE_RULES_RESPONSE_TYPES = Object.assign(Object.assign({}, subscription_template_1.SUBSCRIPTION_TEMPLATE_TYPE), { BLOCK: 'BLOCK', BASE64: 'BASE64', STATUS_CODE_404: 'STATUS_CODE_404', STATUS_CODE_403: 'STATUS_CODE_403', STATUS_CODE_451: 'STATUS_CODE_451', SOCKET_DROP: 'SOCKET_DROP' });
+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_RESPONSE_TYPES = Object.assign(Object.assign({}, subscription_template_1.SUBSCRIPTION_TEMPLATE_TYPE), { BLOCK: 'BLOCK', XRAY_BASE64: 'XRAY_BASE64', STATUS_CODE_404: 'STATUS_CODE_404', STATUS_CODE_403: 'STATUS_CODE_403', STATUS_CODE_451: 'STATUS_CODE_451', SOCKET_DROP: 'SOCKET_DROP' });
+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.SINGBOX_LEGACY]: 'Format which is used by Singbox client application (legacy version).',
+    [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.',
+};

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

@@ -16,4 +16,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./response-rule.schema"), exports);
 __exportStar(require("./response-rules-config.schema"), exports);
-__exportStar(require("./response-rules-json-schema"), exports);

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

@@ -3,27 +3,102 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResponseRuleSchema = void 0;
 const zod_1 = require("zod");
 const constants_1 = require("../../constants");
-exports.ResponseRuleSchema = zod_1.z.object({
-    name: zod_1.z.string().min(1, 'Name is required').max(50, 'Name must be less than 50 characters'),
+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',
+        },
+        {
+            headerName: 'user-agent',
+            operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
+            value: 'FoxRay',
+        },
+    ],
+    responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
+}, null, 2);
+exports.ResponseRuleSchema = 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
         .string()
         .min(1, 'Description is required')
         .max(250, 'Description must be less than 250 characters')
-        .optional(),
-    operator: zod_1.z.nativeEnum(constants_1.RESPONSE_RULES_OPERATORS).describe('Operator to use for the rule.'),
+        .optional()
+        .describe(JSON.stringify({
+        title: 'Description',
+        markdownDescription: 'Description of the response rule. Maximum length is 250 characters.',
+    })),
+    enabled: zod_1.z.boolean().describe(JSON.stringify({
+        markdownDescription: 'Whether the response rule is enabled. If disabled, the rule will not be applied.',
+    })),
+    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(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('Name of the HTTP header to check, case insensitive, must comply with RFC 7230.'),
-        operator: zod_1.z
-            .nativeEnum(constants_1.RESPONSE_RULES_CONDITION_OPERATORS)
-            .describe('Operator to use for the condition.'),
+            .describe(JSON.stringify({
+            title: 'Header Name',
+            markdownDescription: 'Name of the HTTP header to check, case insensitive, 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')}`,
+        })),
         value: zod_1.z
             .string()
             .min(1, 'Value is required')
             .max(255, 'Value must be less than 255 characters')
-            .describe('Value to check against the header, case sensitive.'),
+            .describe(JSON.stringify({
+            markdownDescription: `Value to check against the header, case sensitive (excluding regex/not_regex operator). Maximum length is 255 characters.`,
+        })),
+    })),
+    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')}`,
     })),
-    responseType: zod_1.z.nativeEnum(constants_1.RESPONSE_RULES_RESPONSE_TYPES).describe('Type of the response.'),
-});
+})
+    .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: [
+        {
+            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',
+                },
+            ],
+            responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
+        },
+        {
+            name: 'Empty rule',
+            enabled: true,
+            operator: constants_1.RESPONSE_RULES_OPERATORS.AND,
+            conditions: [],
+            responseType: constants_1.RESPONSE_RULES_RESPONSE_TYPES.BLOCK,
+        },
+    ],
+}));

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

@@ -4,7 +4,49 @@ exports.ResponseRulesConfigSchema = void 0;
 const zod_1 = require("zod");
 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',
+        },
+        {
+            headerName: 'user-agent',
+            operator: constants_1.RESPONSE_RULES_CONDITION_OPERATORS.CONTAINS,
+            value: 'FoxRay',
+        },
+    ],
+    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),
-    rules: zod_1.z.array(response_rule_schema_1.ResponseRuleSchema),
+    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',
+                        },
+                    ],
+                    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".`,
+    })),
 });

package/package.json

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

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

@@ -1,7 +0,0 @@
-export declare const ResponseRulesJsonSchema: import("zod-to-json-schema").JsonSchema7Type & {
-    $schema?: string | undefined;
-    definitions?: {
-        [key: string]: import("zod-to-json-schema").JsonSchema7Type;
-    } | undefined;
-};
-//# sourceMappingURL=response-rules-json-schema.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"response-rules-json-schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rules-json-schema.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,uBAAuB;;;;;CAKlC,CAAC"}

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

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResponseRulesJsonSchema = void 0;
-const zod_to_json_schema_1 = require("zod-to-json-schema");
-const _1 = require(".");
-exports.ResponseRulesJsonSchema = (0, zod_to_json_schema_1.zodToJsonSchema)(_1.ResponseRulesConfigSchema, {
-    name: 'Response Rules Config Schema',
-    $refStrategy: 'none',
-    errorMessages: true,
-    markdownDescription: true,
-});

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

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResponseRulesJsonSchema = void 0;
-const zod_to_json_schema_1 = require("zod-to-json-schema");
-const _1 = require(".");
-exports.ResponseRulesJsonSchema = (0, zod_to_json_schema_1.zodToJsonSchema)(_1.ResponseRulesConfigSchema, {
-    name: 'Response Rules Config Schema',
-    $refStrategy: 'none',
-    errorMessages: true,
-    markdownDescription: true,
-});