@remnawave/backend-contract 2.9.2 → 2.9.4

package/build/backend/models/resolved-proxy-config.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolved-proxy-config.schema.d.ts","sourceRoot":"","sources":["../../../models/resolved-proxy-config.schema.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"resolved-proxy-config.schema.d.ts","sourceRoot":"","sources":["../../../models/resolved-proxy-config.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,0BAA0B;;;;;;;;iBAIrC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;iBAEtC,CAAC;AAEH,eAAO,MAAM,gCAAgC;;;;;iBAK3C,CAAC;AA4BH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;iBAEpC,CAAC;AAEH,eAAO,MAAM,2BAA2B;;;;;;;;;;iBAKtC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;iBAKnC,CAAC;AAEH,eAAO,MAAM,iCAAiC;;;;iBAI5C,CAAC;AAEH,eAAO,MAAM,0BAA0B;;;;iBAIrC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;iBAIpC,CAAC;AAEH,eAAO,MAAM,6BAA6B;;iBAExC,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;iBAGzC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;iBASnC,CAAC;AAEH,eAAO,MAAM,4BAA4B;;;;;;;iBAOvC,CAAC;AAsBH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+BAKhC,CAAC;AAqCH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAQjC,CAAC;AAgBH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;+BAIhC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;iBAanC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2CpC,CAAC"}

package/build/backend/models/resolved-proxy-config.schema.js

@@ -15,7 +15,7 @@ exports.ShadowsocksProtocolOptionsSchema = zod_1.z.object({
     method: zod_1.z.string(),
     password: zod_1.z.string(),
     uot: zod_1.z.boolean(),
-    uotVersion: zod_1.z.number().int(),
+    uotVersion: zod_1.z.int(),
 });
 const TcpHeaderNoneSchema = zod_1.z.object({
     type: zod_1.z.literal('none'),
@@ -24,13 +24,13 @@ const TcpHeaderHttpRequestSchema = zod_1.z.object({
     version: zod_1.z.string().optional(),
     method: zod_1.z.string().optional(),
     path: zod_1.z.array(zod_1.z.string()).optional(),
-    headers: zod_1.z.record(zod_1.z.unknown()).optional(),
+    headers: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
 });
 const TcpHeaderHttpResponseSchema = zod_1.z.object({
     version: zod_1.z.string().optional(),
     status: zod_1.z.string().optional(),
     reason: zod_1.z.string().optional(),
-    headers: zod_1.z.record(zod_1.z.unknown()).optional(),
+    headers: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
 });
 const TcpHeaderHttpSchema = zod_1.z.object({
     type: zod_1.z.literal('http'),
@@ -45,18 +45,18 @@ exports.XhttpTransportOptionsSchema = zod_1.z.object({
     path: zod_1.z.string().nullable(),
     host: zod_1.z.string().nullable(),
     mode: zod_1.z.enum(['auto', 'packet-up', 'stream-up', 'stream-one']),
-    extra: zod_1.z.record(zod_1.z.unknown()).nullable(),
+    extra: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).nullable(),
 });
 exports.WsTransportOptionsSchema = zod_1.z.object({
     path: zod_1.z.string().nullable(),
     host: zod_1.z.string().nullable(),
-    headers: zod_1.z.record(zod_1.z.string()).nullable(),
+    headers: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).nullable(),
     heartbeatPeriod: zod_1.z.number().nullable(),
 });
 exports.HttpUpgradeTransportOptionsSchema = zod_1.z.object({
     path: zod_1.z.string().nullable(),
     host: zod_1.z.string().nullable(),
-    headers: zod_1.z.record(zod_1.z.string()).nullable(),
+    headers: zod_1.z.record(zod_1.z.string(), zod_1.z.string()).nullable(),
 });
 exports.GrpcTransportOptionsSchema = zod_1.z.object({
     authority: zod_1.z.string().nullable(),
@@ -64,15 +64,15 @@ exports.GrpcTransportOptionsSchema = zod_1.z.object({
     multiMode: zod_1.z.boolean(),
 });
 exports.KcpTransportOptionsSchema = zod_1.z.object({
-    clientMtu: zod_1.z.number().int(),
-    clientTti: zod_1.z.number().int(),
+    clientMtu: zod_1.z.int(),
+    clientTti: zod_1.z.int(),
     congestion: zod_1.z.boolean(),
 });
 exports.HysteriaProtocolOptionsSchema = zod_1.z.object({
-    version: zod_1.z.number().int(),
+    version: zod_1.z.int(),
 });
 exports.HysteriaTransportOptionsSchema = zod_1.z.object({
-    version: zod_1.z.number().int(),
+    version: zod_1.z.int(),
     auth: zod_1.z.string(),
 });
 exports.TlsSecurityOptionsSchema = zod_1.z.object({
@@ -169,23 +169,23 @@ exports.SecurityVariantSchema = zod_1.z.discriminatedUnion('security', [
     NoneSecuritySchema,
 ]);
 exports.ProxyEntryMetadataSchema = zod_1.z.object({
-    uuid: zod_1.z.string().uuid(),
+    uuid: zod_1.z.uuid(),
     tags: zod_1.z.array(zod_1.z.string()),
-    excludeFromSubscriptionTypes: zod_1.z.array(zod_1.z.nativeEnum(constants_1.SUBSCRIPTION_TEMPLATE_TYPE)),
+    excludeFromSubscriptionTypes: zod_1.z.array(zod_1.z.enum(constants_1.SUBSCRIPTION_TEMPLATE_TYPE)),
     inboundTag: zod_1.z.string(),
-    configProfileUuid: zod_1.z.string().uuid().nullable(),
-    configProfileInboundUuid: zod_1.z.string().uuid().nullable(),
+    configProfileUuid: zod_1.z.uuid().nullable(),
+    configProfileInboundUuid: zod_1.z.uuid().nullable(),
     isDisabled: zod_1.z.boolean(),
     isHidden: zod_1.z.boolean(),
-    viewPosition: zod_1.z.number().int(),
+    viewPosition: zod_1.z.int(),
     remark: zod_1.z.string(),
-    vlessRouteId: zod_1.z.number().int().nullable(),
+    vlessRouteId: zod_1.z.int().nullable(),
     rawInbound: zod_1.z.nullable(zod_1.z.unknown()),
 });
 exports.ResolvedProxyConfigSchema = zod_1.z.object({
     finalRemark: zod_1.z.string(),
     address: zod_1.z.string(),
-    port: zod_1.z.number().int().positive(),
+    port: zod_1.z.int().positive(),
     protocol: zod_1.z.enum(['vless', 'trojan', 'shadowsocks', 'hysteria']),
     protocolOptions: zod_1.z.union([
         exports.VlessProtocolOptionsSchema,
@@ -213,7 +213,7 @@ exports.ResolvedProxyConfigSchema = zod_1.z.object({
     clientOverrides: zod_1.z.object({
         shuffleHost: zod_1.z.boolean(),
         mihomoX25519: zod_1.z.boolean(),
-        mihomoIpVersion: zod_1.z.nativeEnum(constants_1.MIHOMO_IP_VERSION).nullable(),
+        mihomoIpVersion: zod_1.z.enum(constants_1.MIHOMO_IP_VERSION).nullable(),
         serverDescription: zod_1.z.string().nullable(),
         xrayJsonTemplate: zod_1.z.nullable(zod_1.z.unknown()),
     }),

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

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const ResponseRuleConditionSchema: z.ZodObject<{
     headerName: z.ZodString;
-    operator: z.ZodNativeEnum<{
+    operator: z.ZodEnum<{
         readonly EQUALS: "EQUALS";
         readonly NOT_EQUALS: "NOT_EQUALS";
         readonly CONTAINS: "CONTAINS";
@@ -15,15 +15,5 @@ export declare const ResponseRuleConditionSchema: z.ZodObject<{
     }>;
     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;
-}>;
+}, z.core.$strip>;
 //# sourceMappingURL=response-rule-condition.schema.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"response-rule-condition.schema.d.ts","sourceRoot":"","sources":["../../../../models/response-rules/response-rule-condition.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;EAyDnC,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;;;;;;;;;;;;;;;;iBAyDnC,CAAC"}

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

@@ -11,7 +11,7 @@ exports.ResponseRuleConditionSchema = zod_1.z
         .describe(JSON.stringify({
         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({
+    operator: zod_1.z.enum(constants_1.RESPONSE_RULES_CONDITION_OPERATORS).describe(JSON.stringify({
         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),

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

@@ -1,73 +1,29 @@
 import z from 'zod';
 export declare const ResponseRuleEncryptionSchema: z.ZodObject<{
-    method: z.ZodEnum<["age1", "age1pq1"]>;
+    method: z.ZodEnum<{
+        age1: "age1";
+        age1pq1: "age1pq1";
+    }>;
     key: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    key: string;
-    method: "age1" | "age1pq1";
-}, {
-    key: string;
-    method: "age1" | "age1pq1";
-}>;
+}, z.core.$strip>;
 export declare const ResponseRuleModificationsSchema: z.ZodOptional<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">>;
+    }, z.core.$strip>>>;
     applyHeadersToEnd: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
     subscriptionTemplate: z.ZodOptional<z.ZodString>;
     ignoreHostXrayJsonTemplate: z.ZodOptional<z.ZodBoolean>;
     ignoreServeJsonAtBaseSubscription: z.ZodOptional<z.ZodBoolean>;
-    additionalExtendedClientsRegex: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    additionalExtendedClientsRegex: z.ZodOptional<z.ZodArray<z.ZodString>>;
     disableHwidCheck: z.ZodOptional<z.ZodBoolean>;
     encryption: z.ZodOptional<z.ZodObject<{
-        method: z.ZodEnum<["age1", "age1pq1"]>;
+        method: z.ZodEnum<{
+            age1: "age1";
+            age1pq1: "age1pq1";
+        }>;
         key: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        key: string;
-        method: "age1" | "age1pq1";
-    }, {
-        key: string;
-        method: "age1" | "age1pq1";
-    }>>;
-    excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-}, "strip", z.ZodTypeAny, {
-    headers?: {
-        value: string;
-        key: string;
-    }[] | undefined;
-    applyHeadersToEnd?: boolean | undefined;
-    subscriptionTemplate?: string | undefined;
-    ignoreHostXrayJsonTemplate?: boolean | undefined;
-    ignoreServeJsonAtBaseSubscription?: boolean | undefined;
-    additionalExtendedClientsRegex?: string[] | undefined;
-    disableHwidCheck?: boolean | undefined;
-    encryption?: {
-        key: string;
-        method: "age1" | "age1pq1";
-    } | undefined;
-    excludeHostsByTags?: string[] | undefined;
-}, {
-    headers?: {
-        value: string;
-        key: string;
-    }[] | undefined;
-    applyHeadersToEnd?: boolean | undefined;
-    subscriptionTemplate?: string | undefined;
-    ignoreHostXrayJsonTemplate?: boolean | undefined;
-    ignoreServeJsonAtBaseSubscription?: boolean | undefined;
-    additionalExtendedClientsRegex?: string[] | undefined;
-    disableHwidCheck?: boolean | undefined;
-    encryption?: {
-        key: string;
-        method: "age1" | "age1pq1";
-    } | undefined;
-    excludeHostsByTags?: string[] | undefined;
-}>>;
+    }, z.core.$strip>>;
+    excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>>;
 //# sourceMappingURL=response-rule-modifications.schema.d.ts.map

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

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

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

@@ -1,9 +1,5 @@
 import z from 'zod';
 export declare const ResponseRuleSettingsSchema: z.ZodOptional<z.ZodObject<{
     disableSubscriptionAccessByPath: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    disableSubscriptionAccessByPath?: boolean | undefined;
-}, {
-    disableSubscriptionAccessByPath?: boolean | undefined;
-}>>;
+}, z.core.$strip>>;
 //# sourceMappingURL=response-rule-settings.schema.d.ts.map

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

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

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

@@ -3,13 +3,13 @@ export declare const ResponseRuleSchemaBase: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
     enabled: z.ZodBoolean;
-    operator: z.ZodNativeEnum<{
+    operator: z.ZodEnum<{
         readonly AND: "AND";
         readonly OR: "OR";
     }>;
     conditions: z.ZodArray<z.ZodObject<{
         headerName: z.ZodString;
-        operator: z.ZodNativeEnum<{
+        operator: z.ZodEnum<{
             readonly EQUALS: "EQUALS";
             readonly NOT_EQUALS: "NOT_EQUALS";
             readonly CONTAINS: "CONTAINS";
@@ -23,18 +23,8 @@ export declare const ResponseRuleSchemaBase: z.ZodObject<{
         }>;
         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<{
+    }, z.core.$strip>>;
+    responseType: z.ZodEnum<{
         readonly BROWSER: "BROWSER";
         readonly BLOCK: "BLOCK";
         readonly STATUS_CODE_404: "STATUS_CODE_404";
@@ -51,133 +41,34 @@ export declare const ResponseRuleSchemaBase: 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">>;
+        }, z.core.$strip>>>;
         applyHeadersToEnd: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
         subscriptionTemplate: z.ZodOptional<z.ZodString>;
         ignoreHostXrayJsonTemplate: z.ZodOptional<z.ZodBoolean>;
         ignoreServeJsonAtBaseSubscription: z.ZodOptional<z.ZodBoolean>;
-        additionalExtendedClientsRegex: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        additionalExtendedClientsRegex: z.ZodOptional<z.ZodArray<z.ZodString>>;
         disableHwidCheck: z.ZodOptional<z.ZodBoolean>;
         encryption: z.ZodOptional<z.ZodObject<{
-            method: z.ZodEnum<["age1", "age1pq1"]>;
+            method: z.ZodEnum<{
+                age1: "age1";
+                age1pq1: "age1pq1";
+            }>;
             key: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            key: string;
-            method: "age1" | "age1pq1";
-        }, {
-            key: string;
-            method: "age1" | "age1pq1";
-        }>>;
-        excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        headers?: {
-            value: string;
-            key: string;
-        }[] | undefined;
-        applyHeadersToEnd?: boolean | undefined;
-        subscriptionTemplate?: string | undefined;
-        ignoreHostXrayJsonTemplate?: boolean | undefined;
-        ignoreServeJsonAtBaseSubscription?: boolean | undefined;
-        additionalExtendedClientsRegex?: string[] | undefined;
-        disableHwidCheck?: boolean | undefined;
-        encryption?: {
-            key: string;
-            method: "age1" | "age1pq1";
-        } | undefined;
-        excludeHostsByTags?: string[] | undefined;
-    }, {
-        headers?: {
-            value: string;
-            key: string;
-        }[] | undefined;
-        applyHeadersToEnd?: boolean | undefined;
-        subscriptionTemplate?: string | undefined;
-        ignoreHostXrayJsonTemplate?: boolean | undefined;
-        ignoreServeJsonAtBaseSubscription?: boolean | undefined;
-        additionalExtendedClientsRegex?: string[] | undefined;
-        disableHwidCheck?: boolean | undefined;
-        encryption?: {
-            key: string;
-            method: "age1" | "age1pq1";
-        } | undefined;
-        excludeHostsByTags?: string[] | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    enabled: boolean;
-    operator: "AND" | "OR";
-    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;
-        applyHeadersToEnd?: boolean | undefined;
-        subscriptionTemplate?: string | undefined;
-        ignoreHostXrayJsonTemplate?: boolean | undefined;
-        ignoreServeJsonAtBaseSubscription?: boolean | undefined;
-        additionalExtendedClientsRegex?: string[] | undefined;
-        disableHwidCheck?: boolean | undefined;
-        encryption?: {
-            key: string;
-            method: "age1" | "age1pq1";
-        } | undefined;
-        excludeHostsByTags?: string[] | undefined;
-    } | undefined;
-}, {
-    name: string;
-    enabled: boolean;
-    operator: "AND" | "OR";
-    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;
-        applyHeadersToEnd?: boolean | undefined;
-        subscriptionTemplate?: string | undefined;
-        ignoreHostXrayJsonTemplate?: boolean | undefined;
-        ignoreServeJsonAtBaseSubscription?: boolean | undefined;
-        additionalExtendedClientsRegex?: string[] | undefined;
-        disableHwidCheck?: boolean | undefined;
-        encryption?: {
-            key: string;
-            method: "age1" | "age1pq1";
-        } | undefined;
-        excludeHostsByTags?: string[] | undefined;
-    } | undefined;
-}>;
+        }, z.core.$strip>>;
+        excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export declare const ResponseRuleSchema: z.ZodObject<{
     name: z.ZodString;
     description: z.ZodOptional<z.ZodString>;
     enabled: z.ZodBoolean;
-    operator: z.ZodNativeEnum<{
+    operator: z.ZodEnum<{
         readonly AND: "AND";
         readonly OR: "OR";
     }>;
     conditions: z.ZodArray<z.ZodObject<{
         headerName: z.ZodString;
-        operator: z.ZodNativeEnum<{
+        operator: z.ZodEnum<{
             readonly EQUALS: "EQUALS";
             readonly NOT_EQUALS: "NOT_EQUALS";
             readonly CONTAINS: "CONTAINS";
@@ -191,18 +82,8 @@ export declare const ResponseRuleSchema: z.ZodObject<{
         }>;
         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<{
+    }, z.core.$strip>>;
+    responseType: z.ZodEnum<{
         readonly BROWSER: "BROWSER";
         readonly BLOCK: "BLOCK";
         readonly STATUS_CODE_404: "STATUS_CODE_404";
@@ -219,120 +100,21 @@ export declare const ResponseRuleSchema: 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">>;
+        }, z.core.$strip>>>;
         applyHeadersToEnd: z.ZodOptional<z.ZodOptional<z.ZodBoolean>>;
         subscriptionTemplate: z.ZodOptional<z.ZodString>;
         ignoreHostXrayJsonTemplate: z.ZodOptional<z.ZodBoolean>;
         ignoreServeJsonAtBaseSubscription: z.ZodOptional<z.ZodBoolean>;
-        additionalExtendedClientsRegex: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        additionalExtendedClientsRegex: z.ZodOptional<z.ZodArray<z.ZodString>>;
         disableHwidCheck: z.ZodOptional<z.ZodBoolean>;
         encryption: z.ZodOptional<z.ZodObject<{
-            method: z.ZodEnum<["age1", "age1pq1"]>;
+            method: z.ZodEnum<{
+                age1: "age1";
+                age1pq1: "age1pq1";
+            }>;
             key: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            key: string;
-            method: "age1" | "age1pq1";
-        }, {
-            key: string;
-            method: "age1" | "age1pq1";
-        }>>;
-        excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    }, "strip", z.ZodTypeAny, {
-        headers?: {
-            value: string;
-            key: string;
-        }[] | undefined;
-        applyHeadersToEnd?: boolean | undefined;
-        subscriptionTemplate?: string | undefined;
-        ignoreHostXrayJsonTemplate?: boolean | undefined;
-        ignoreServeJsonAtBaseSubscription?: boolean | undefined;
-        additionalExtendedClientsRegex?: string[] | undefined;
-        disableHwidCheck?: boolean | undefined;
-        encryption?: {
-            key: string;
-            method: "age1" | "age1pq1";
-        } | undefined;
-        excludeHostsByTags?: string[] | undefined;
-    }, {
-        headers?: {
-            value: string;
-            key: string;
-        }[] | undefined;
-        applyHeadersToEnd?: boolean | undefined;
-        subscriptionTemplate?: string | undefined;
-        ignoreHostXrayJsonTemplate?: boolean | undefined;
-        ignoreServeJsonAtBaseSubscription?: boolean | undefined;
-        additionalExtendedClientsRegex?: string[] | undefined;
-        disableHwidCheck?: boolean | undefined;
-        encryption?: {
-            key: string;
-            method: "age1" | "age1pq1";
-        } | undefined;
-        excludeHostsByTags?: string[] | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    name: string;
-    enabled: boolean;
-    operator: "AND" | "OR";
-    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;
-        applyHeadersToEnd?: boolean | undefined;
-        subscriptionTemplate?: string | undefined;
-        ignoreHostXrayJsonTemplate?: boolean | undefined;
-        ignoreServeJsonAtBaseSubscription?: boolean | undefined;
-        additionalExtendedClientsRegex?: string[] | undefined;
-        disableHwidCheck?: boolean | undefined;
-        encryption?: {
-            key: string;
-            method: "age1" | "age1pq1";
-        } | undefined;
-        excludeHostsByTags?: string[] | undefined;
-    } | undefined;
-}, {
-    name: string;
-    enabled: boolean;
-    operator: "AND" | "OR";
-    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;
-        applyHeadersToEnd?: boolean | undefined;
-        subscriptionTemplate?: string | undefined;
-        ignoreHostXrayJsonTemplate?: boolean | undefined;
-        ignoreServeJsonAtBaseSubscription?: boolean | undefined;
-        additionalExtendedClientsRegex?: string[] | undefined;
-        disableHwidCheck?: boolean | undefined;
-        encryption?: {
-            key: string;
-            method: "age1" | "age1pq1";
-        } | undefined;
-        excludeHostsByTags?: string[] | undefined;
-    } | undefined;
-}>;
+        }, z.core.$strip>>;
+        excludeHostsByTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 //# 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;AAexB,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgDjC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqB9B,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgDjC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqB9B,CAAC"}

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

@@ -25,13 +25,13 @@ exports.ResponseRuleSchemaBase = zod_1.z.object({
     enabled: zod_1.z.boolean().describe(JSON.stringify({
         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({
+    operator: zod_1.z.enum(constants_1.RESPONSE_RULES_OPERATORS).describe(JSON.stringify({
         markdownDescription: 'Operator to use for combining conditions in the rule.',
     })),
     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({
+    responseType: zod_1.z.enum(constants_1.RESPONSE_RULES_RESPONSE_TYPES).describe(JSON.stringify({
         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),