@remnawave/backend-contract 2.1.76 → 2.1.77

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

@@ -5,21 +5,21 @@ export declare namespace UpdateSubscriptionTemplateCommand {
     const endpointDetails: import("../../constants").EndpointDetails;
     const RequestSchema: z.ZodObject<{
         templateType: z.ZodNativeEnum<{
-            readonly STASH: "STASH";
-            readonly SINGBOX: "SINGBOX";
-            readonly SINGBOX_LEGACY: "SINGBOX_LEGACY";
-            readonly MIHOMO: "MIHOMO";
             readonly XRAY_JSON: "XRAY_JSON";
+            readonly XRAY_BASE64: "XRAY_BASE64";
+            readonly MIHOMO: "MIHOMO";
+            readonly STASH: "STASH";
             readonly CLASH: "CLASH";
+            readonly SINGBOX: "SINGBOX";
         }>;
         templateJson: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
         encodedTemplateYaml: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
-        templateType: "STASH" | "SINGBOX" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH";
+        templateType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64";
         templateJson?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
         encodedTemplateYaml?: string | undefined;
     }, {
-        templateType: "STASH" | "SINGBOX" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH";
+        templateType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64";
         templateJson?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
         encodedTemplateYaml?: string | undefined;
     }>;
@@ -28,37 +28,37 @@ export declare namespace UpdateSubscriptionTemplateCommand {
         response: z.ZodObject<{
             uuid: z.ZodString;
             templateType: z.ZodNativeEnum<{
-                readonly STASH: "STASH";
-                readonly SINGBOX: "SINGBOX";
-                readonly SINGBOX_LEGACY: "SINGBOX_LEGACY";
-                readonly MIHOMO: "MIHOMO";
                 readonly XRAY_JSON: "XRAY_JSON";
+                readonly XRAY_BASE64: "XRAY_BASE64";
+                readonly MIHOMO: "MIHOMO";
+                readonly STASH: "STASH";
                 readonly CLASH: "CLASH";
+                readonly SINGBOX: "SINGBOX";
             }>;
             templateJson: z.ZodNullable<z.ZodUnknown>;
             encodedTemplateYaml: z.ZodNullable<z.ZodString>;
         }, "strip", z.ZodTypeAny, {
             uuid: string;
-            templateType: "STASH" | "SINGBOX" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH";
+            templateType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64";
             encodedTemplateYaml: string | null;
             templateJson?: unknown;
         }, {
             uuid: string;
-            templateType: "STASH" | "SINGBOX" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH";
+            templateType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64";
             encodedTemplateYaml: string | null;
             templateJson?: unknown;
         }>;
     }, "strip", z.ZodTypeAny, {
         response: {
             uuid: string;
-            templateType: "STASH" | "SINGBOX" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH";
+            templateType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64";
             encodedTemplateYaml: string | null;
             templateJson?: unknown;
         };
     }, {
         response: {
             uuid: string;
-            templateType: "STASH" | "SINGBOX" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH";
+            templateType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64";
             encodedTemplateYaml: string | null;
             templateJson?: unknown;
         };

package/build/backend/commands/subscriptions/get-by/get-raw-subscription-by-short-uuid.command.d.ts

@@ -402,6 +402,7 @@ export declare namespace GetRawSubscriptionByShortUuidCommand {
                 } | undefined;
             }>, "many">;
         }, "strip", z.ZodTypeAny, {
+            headers: Record<string, string | undefined>;
             user: {
                 status: "DISABLED" | "LIMITED" | "EXPIRED" | "ACTIVE";
                 uuid: string;
@@ -450,7 +451,6 @@ export declare namespace GetRawSubscriptionByShortUuidCommand {
                 lifetimeTrafficUsed: string;
                 isHwidLimited: boolean;
             };
-            headers: Record<string, string | undefined>;
             rawHosts: {
                 password: {
                     trojanPassword: string;
@@ -506,6 +506,7 @@ export declare namespace GetRawSubscriptionByShortUuidCommand {
                 } | undefined;
             }[];
         }, {
+            headers: Record<string, string | undefined>;
             user: {
                 uuid: string;
                 createdAt: string;
@@ -554,7 +555,6 @@ export declare namespace GetRawSubscriptionByShortUuidCommand {
                 lifetimeTrafficUsed: string;
                 isHwidLimited: boolean;
             };
-            headers: Record<string, string | undefined>;
             rawHosts: {
                 password: {
                     trojanPassword: string;
@@ -612,6 +612,7 @@ export declare namespace GetRawSubscriptionByShortUuidCommand {
         }>;
     }, "strip", z.ZodTypeAny, {
         response: {
+            headers: Record<string, string | undefined>;
             user: {
                 status: "DISABLED" | "LIMITED" | "EXPIRED" | "ACTIVE";
                 uuid: string;
@@ -660,7 +661,6 @@ export declare namespace GetRawSubscriptionByShortUuidCommand {
                 lifetimeTrafficUsed: string;
                 isHwidLimited: boolean;
             };
-            headers: Record<string, string | undefined>;
             rawHosts: {
                 password: {
                     trojanPassword: string;
@@ -718,6 +718,7 @@ export declare namespace GetRawSubscriptionByShortUuidCommand {
         };
     }, {
         response: {
+            headers: Record<string, string | undefined>;
             user: {
                 uuid: string;
                 createdAt: string;
@@ -766,7 +767,6 @@ export declare namespace GetRawSubscriptionByShortUuidCommand {
                 lifetimeTrafficUsed: string;
                 isHwidLimited: boolean;
             };
-            headers: Record<string, string | undefined>;
             rawHosts: {
                 password: {
                     trojanPassword: string;

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

@@ -20,32 +20,27 @@ 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 BROWSER: "BROWSER";
     readonly BLOCK: "BLOCK";
-    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";
     readonly SOCKET_DROP: "SOCKET_DROP";
-    readonly STASH: "STASH";
-    readonly SINGBOX: "SINGBOX";
-    readonly SINGBOX_LEGACY: "SINGBOX_LEGACY";
-    readonly MIHOMO: "MIHOMO";
     readonly XRAY_JSON: "XRAY_JSON";
+    readonly XRAY_BASE64: "XRAY_BASE64";
+    readonly MIHOMO: "MIHOMO";
+    readonly STASH: "STASH";
     readonly CLASH: "CLASH";
+    readonly SINGBOX: "SINGBOX";
 };
+export type TResponseRulesResponseType = [keyof typeof RESPONSE_RULES_RESPONSE_TYPES][number];
+export declare const RESPONSE_RULES_RESPONSE_TYPES_VALUES: ("STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP")[];
+export type TResponseRulesResponseTypeKeys = (typeof RESPONSE_RULES_RESPONSE_TYPES)[keyof typeof RESPONSE_RULES_RESPONSE_TYPES];
+export type TResponseRulesConditionOperator = [
+    keyof typeof RESPONSE_RULES_CONDITION_OPERATORS
+][number];
+export declare const RESPONSE_RULES_CONDITION_OPERATORS_VALUES: ("EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX")[];
+export 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.";
@@ -55,8 +50,20 @@ export declare const RESPONSE_RULES_RESPONSE_TYPES_DESCRIPTION: {
     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.";
+    readonly BROWSER: "Return subscription as browser format.";
+};
+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().";
 };
 //# 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,8CAA8C;;;;;;;;;;;CAqBjD,CAAC;AAEX,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;CAQhC,CAAC;AAEX,eAAO,MAAM,yCAAyC;;;;;;;;;;;;CAmB5C,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;;;;;;;;;;;;CAkB5C,CAAC;AAEX,eAAO,MAAM,8CAA8C;;;;;;;;;;;CAqBjD,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_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;
+exports.RESPONSE_RULES_CONDITION_OPERATORS_DESCRIPTION = exports.RESPONSE_RULES_RESPONSE_TYPES_DESCRIPTION = exports.RESPONSE_RULES_CONDITION_OPERATORS_VALUES = exports.RESPONSE_RULES_RESPONSE_TYPES_VALUES = exports.RESPONSE_RULES_RESPONSE_TYPES = exports.RESPONSE_RULES_CONDITION_OPERATORS = exports.RESPONSE_RULE_CONDITION_TYPES = exports.RESPONSE_RULES_OPERATORS = exports.RESPONSE_RULES_CONFIG_VERSION = void 0;
 const subscription_template_1 = require("../subscription-template");
 exports.RESPONSE_RULES_CONFIG_VERSION = {
     1: '1',
@@ -24,27 +24,16 @@ 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,
+    BROWSER: 'BROWSER',
     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_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.',
@@ -54,7 +43,19 @@ exports.RESPONSE_RULES_RESPONSE_TYPES_DESCRIPTION = {
     [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.',
+    [exports.RESPONSE_RULES_RESPONSE_TYPES.BROWSER]: 'Return subscription as browser format.',
+};
+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().',
 };

package/build/backend/constants/subscription-template/template-type/request-template-type.constant.d.ts

@@ -1,13 +1,12 @@
 export declare const REQUEST_TEMPLATE_TYPE: {
     readonly STASH: "stash";
     readonly SINGBOX: "singbox";
-    readonly SINGBOX_LEGACY: "singbox-legacy";
     readonly MIHOMO: "mihomo";
     readonly XRAY_JSON: "json";
     readonly V2RAY_JSON: "v2ray-json";
     readonly CLASH: "clash";
 };
 export type TRequestTemplateType = [keyof typeof REQUEST_TEMPLATE_TYPE][number];
-export declare const REQUEST_TEMPLATE_TYPE_VALUES: ("stash" | "singbox" | "singbox-legacy" | "mihomo" | "json" | "v2ray-json" | "clash")[];
+export declare const REQUEST_TEMPLATE_TYPE_VALUES: ("stash" | "singbox" | "mihomo" | "json" | "v2ray-json" | "clash")[];
 export type TRequestTemplateTypeKeys = (typeof REQUEST_TEMPLATE_TYPE)[keyof typeof REQUEST_TEMPLATE_TYPE];
 //# sourceMappingURL=request-template-type.constant.d.ts.map

package/build/backend/constants/subscription-template/template-type/request-template-type.constant.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"request-template-type.constant.d.ts","sourceRoot":"","sources":["../../../../../constants/subscription-template/template-type/request-template-type.constant.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB;;;;;;;;CAQxB,CAAC;AAEX,MAAM,MAAM,oBAAoB,GAAG,CAAC,MAAM,OAAO,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAC;AAChF,eAAO,MAAM,4BAA4B,yFAAuC,CAAC;AACjF,MAAM,MAAM,wBAAwB,GAChC,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,OAAO,qBAAqB,CAAC,CAAC"}
+{"version":3,"file":"request-template-type.constant.d.ts","sourceRoot":"","sources":["../../../../../constants/subscription-template/template-type/request-template-type.constant.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB;;;;;;;CAOxB,CAAC;AAEX,MAAM,MAAM,oBAAoB,GAAG,CAAC,MAAM,OAAO,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAC;AAChF,eAAO,MAAM,4BAA4B,sEAAuC,CAAC;AACjF,MAAM,MAAM,wBAAwB,GAChC,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,OAAO,qBAAqB,CAAC,CAAC"}

package/build/backend/constants/subscription-template/template-type/request-template-type.constant.js

@@ -4,7 +4,6 @@ exports.REQUEST_TEMPLATE_TYPE_VALUES = exports.REQUEST_TEMPLATE_TYPE = void 0;
 exports.REQUEST_TEMPLATE_TYPE = {
     STASH: 'stash',
     SINGBOX: 'singbox',
-    SINGBOX_LEGACY: 'singbox-legacy',
     MIHOMO: 'mihomo',
     XRAY_JSON: 'json',
     V2RAY_JSON: 'v2ray-json',

package/build/backend/constants/subscription-template/template-type/template-type.constant.d.ts

@@ -1,11 +1,11 @@
 export declare const SUBSCRIPTION_TEMPLATE_TYPE: {
-    readonly STASH: "STASH";
-    readonly SINGBOX: "SINGBOX";
-    readonly SINGBOX_LEGACY: "SINGBOX_LEGACY";
-    readonly MIHOMO: "MIHOMO";
     readonly XRAY_JSON: "XRAY_JSON";
+    readonly XRAY_BASE64: "XRAY_BASE64";
+    readonly MIHOMO: "MIHOMO";
+    readonly STASH: "STASH";
     readonly CLASH: "CLASH";
+    readonly SINGBOX: "SINGBOX";
 };
 export type TSubscriptionTemplateType = [keyof typeof SUBSCRIPTION_TEMPLATE_TYPE][number];
-export declare const SUBSCRIPTION_TEMPLATE_TYPE_VALUES: ("STASH" | "SINGBOX" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH")[];
+export declare const SUBSCRIPTION_TEMPLATE_TYPE_VALUES: ("STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64")[];
 //# sourceMappingURL=template-type.constant.d.ts.map

package/build/backend/constants/subscription-template/template-type/template-type.constant.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"template-type.constant.d.ts","sourceRoot":"","sources":["../../../../../constants/subscription-template/template-type/template-type.constant.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,0BAA0B;;;;;;;CAO7B,CAAC;AAEX,MAAM,MAAM,yBAAyB,GAAG,CAAC,MAAM,OAAO,0BAA0B,CAAC,CAAC,MAAM,CAAC,CAAC;AAC1F,eAAO,MAAM,iCAAiC,+EAA4C,CAAC"}
+{"version":3,"file":"template-type.constant.d.ts","sourceRoot":"","sources":["../../../../../constants/subscription-template/template-type/template-type.constant.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,0BAA0B;;;;;;;CAS7B,CAAC;AAEX,MAAM,MAAM,yBAAyB,GAAG,CAAC,MAAM,OAAO,0BAA0B,CAAC,CAAC,MAAM,CAAC,CAAC;AAC1F,eAAO,MAAM,iCAAiC,4EAA4C,CAAC"}

package/build/backend/constants/subscription-template/template-type/template-type.constant.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SUBSCRIPTION_TEMPLATE_TYPE_VALUES = exports.SUBSCRIPTION_TEMPLATE_TYPE = void 0;
 exports.SUBSCRIPTION_TEMPLATE_TYPE = {
-    STASH: 'STASH',
-    SINGBOX: 'SINGBOX',
-    SINGBOX_LEGACY: 'SINGBOX_LEGACY',
-    MIHOMO: 'MIHOMO',
     XRAY_JSON: 'XRAY_JSON',
+    XRAY_BASE64: 'XRAY_BASE64',
+    MIHOMO: 'MIHOMO',
+    STASH: 'STASH',
     CLASH: 'CLASH',
+    SINGBOX: 'SINGBOX',
 };
 exports.SUBSCRIPTION_TEMPLATE_TYPE_VALUES = Object.values(exports.SUBSCRIPTION_TEMPLATE_TYPE);

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

@@ -1,3 +1,4 @@
+export * from './response-rule-condition.schema';
 export * from './response-rule.schema';
 export * from './response-rules-config.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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,wBAAwB,CAAC;AACvC,cAAc,gCAAgC,CAAC"}

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

@@ -14,5 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./response-rule-condition.schema"), exports);
 __exportStar(require("./response-rule.schema"), exports);
 __exportStar(require("./response-rules-config.schema"), exports);

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

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export declare const ResponseRuleConditionSchema: 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;
+}>;
+//# sourceMappingURL=response-rule-condition.schema.d.ts.map

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

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

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

@@ -0,0 +1,29 @@
+"use strict";
+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({
+    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.',
+    })),
+    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(JSON.stringify({
+        markdownDescription: `Value to check against the header, case sensitive (excluding regex/not_regex operator). Maximum length is 255 characters.`,
+    })),
+    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.',
+    })),
+});

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

@@ -22,50 +22,88 @@ export declare const ResponseRuleSchema: z.ZodObject<{
             readonly NOT_REGEX: "NOT_REGEX";
         }>;
         value: z.ZodString;
+        caseSensitive: z.ZodBoolean;
     }, "strip", z.ZodTypeAny, {
         value: string;
-        operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
         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;
-        operator: "EQUALS" | "NOT_EQUALS" | "CONTAINS" | "NOT_CONTAINS" | "STARTS_WITH" | "NOT_STARTS_WITH" | "ENDS_WITH" | "NOT_ENDS_WITH" | "REGEX" | "NOT_REGEX";
         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 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";
         readonly SOCKET_DROP: "SOCKET_DROP";
-        readonly STASH: "STASH";
-        readonly SINGBOX: "SINGBOX";
-        readonly SINGBOX_LEGACY: "SINGBOX_LEGACY";
-        readonly MIHOMO: "MIHOMO";
         readonly XRAY_JSON: "XRAY_JSON";
+        readonly XRAY_BASE64: "XRAY_BASE64";
+        readonly MIHOMO: "MIHOMO";
+        readonly STASH: "STASH";
         readonly CLASH: "CLASH";
+        readonly SINGBOX: "SINGBOX";
+    }>;
+    responseModifications: z.ZodObject<{
+        headers: z.ZodOptional<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;
+        }[] | undefined;
+    }, {
+        headers?: {
+            value: string;
+            key: string;
+        }[] | undefined;
     }>;
 }, "strip", z.ZodTypeAny, {
     name: string;
-    enabled: boolean;
     operator: "AND" | "OR";
+    enabled: boolean;
     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;
+        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" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "BLOCK" | "XRAY_BASE64" | "STATUS_CODE_404" | "STATUS_CODE_403" | "STATUS_CODE_451" | "SOCKET_DROP";
+    responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
+    responseModifications: {
+        headers?: {
+            value: string;
+            key: string;
+        }[] | undefined;
+    };
     description?: string | undefined;
 }, {
     name: string;
-    enabled: boolean;
     operator: "AND" | "OR";
+    enabled: boolean;
     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;
+        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" | "SINGBOX_LEGACY" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "BLOCK" | "XRAY_BASE64" | "STATUS_CODE_404" | "STATUS_CODE_403" | "STATUS_CODE_451" | "SOCKET_DROP";
+    responseType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64" | "BROWSER" | "BLOCK" | "STATUS_CODE_404" | "STATUS_CODE_451" | "SOCKET_DROP";
+    responseModifications: {
+        headers?: {
+            value: string;
+            key: string;
+        }[] | undefined;
+    };
     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;AAkCxB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6G1B,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;AAoCxB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgH1B,CAAC"}

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResponseRuleSchema = void 0;
 const zod_1 = require("zod");
 const constants_1 = require("../../constants");
+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',
@@ -13,11 +14,13 @@ const RuleExampleJson = JSON.stringify({
             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,
@@ -48,32 +51,35 @@ exports.ResponseRuleSchema = zod_1.z
         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(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(JSON.stringify({
-            markdownDescription: `Value to check against the header, case sensitive (excluding regex/not_regex operator). Maximum length is 255 characters.`,
-        })),
-    })),
+    conditions: zod_1.z.array(response_rule_condition_schema_1.ResponseRuleConditionSchema),
     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')}`,
     })),
+    responseModifications: zod_1.z.object({
+        headers: zod_1.z
+            .array(zod_1.z.object({
+            key: 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: 'Key',
+                markdownDescription: 'Key of the response header. Must comply with RFC 7230.',
+            })),
+            value: zod_1.z
+                .string()
+                .min(1, 'Value is required')
+                .describe(JSON.stringify({
+                title: 'Value',
+                markdownDescription: 'Value of the response header. ',
+            })),
+        }))
+            .optional()
+            .describe(JSON.stringify({
+            markdownDescription: 'Response headers to be added when the rule is matched.',
+        })),
+    }),
 })
     .describe(JSON.stringify({
     title: 'Response Rule',
@@ -89,6 +95,7 @@ exports.ResponseRuleSchema = zod_1.z
                     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,