@remnawave/backend-contract 2.9.3 → 2.9.5

package/build/backend/models/external-squad.schema.d.ts

@@ -1,18 +1,14 @@
 import { z } from 'zod';
 export declare const ExternalSquadSchema: z.ZodObject<{
-    uuid: z.ZodString;
-    viewPosition: z.ZodNumber;
+    uuid: z.ZodUUID;
+    viewPosition: z.ZodInt;
     name: z.ZodString;
     info: z.ZodObject<{
         membersCount: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        membersCount: number;
-    }, {
-        membersCount: number;
-    }>;
+    }, z.core.$strip>;
     templates: z.ZodArray<z.ZodObject<{
-        templateUuid: z.ZodString;
-        templateType: z.ZodNativeEnum<{
+        templateUuid: z.ZodUUID;
+        templateType: z.ZodEnum<{
             readonly XRAY_JSON: "XRAY_JSON";
             readonly XRAY_BASE64: "XRAY_BASE64";
             readonly MIHOMO: "MIHOMO";
@@ -20,178 +16,38 @@ export declare const ExternalSquadSchema: z.ZodObject<{
             readonly CLASH: "CLASH";
             readonly SINGBOX: "SINGBOX";
         }>;
-    }, "strip", z.ZodTypeAny, {
-        templateUuid: string;
-        templateType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64";
-    }, {
-        templateUuid: string;
-        templateType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64";
-    }>, "many">;
+    }, z.core.$strip>>;
     subscriptionSettings: z.ZodNullable<z.ZodObject<{
         profileTitle: z.ZodOptional<z.ZodString>;
         supportLink: z.ZodOptional<z.ZodString>;
-        profileUpdateInterval: z.ZodOptional<z.ZodNumber>;
+        profileUpdateInterval: z.ZodOptional<z.ZodInt>;
         isProfileWebpageUrlEnabled: z.ZodOptional<z.ZodBoolean>;
         serveJsonAtBaseSubscription: z.ZodOptional<z.ZodBoolean>;
         isShowCustomRemarks: z.ZodOptional<z.ZodBoolean>;
         happAnnounce: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         happRouting: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         randomizeHosts: z.ZodOptional<z.ZodBoolean>;
-    }, "strip", z.ZodTypeAny, {
-        profileTitle?: string | undefined;
-        supportLink?: string | undefined;
-        profileUpdateInterval?: number | undefined;
-        isProfileWebpageUrlEnabled?: boolean | undefined;
-        serveJsonAtBaseSubscription?: boolean | undefined;
-        isShowCustomRemarks?: boolean | undefined;
-        happAnnounce?: string | null | undefined;
-        happRouting?: string | null | undefined;
-        randomizeHosts?: boolean | undefined;
-    }, {
-        profileTitle?: string | undefined;
-        supportLink?: string | undefined;
-        profileUpdateInterval?: number | undefined;
-        isProfileWebpageUrlEnabled?: boolean | undefined;
-        serveJsonAtBaseSubscription?: boolean | undefined;
-        isShowCustomRemarks?: boolean | undefined;
-        happAnnounce?: string | null | undefined;
-        happRouting?: string | null | undefined;
-        randomizeHosts?: boolean | undefined;
-    }>>;
+    }, z.core.$strip>>;
     hostOverrides: z.ZodNullable<z.ZodObject<{
         serverDescription: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        vlessRouteId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-    }, "strip", z.ZodTypeAny, {
-        serverDescription?: string | null | undefined;
-        vlessRouteId?: number | null | undefined;
-    }, {
-        serverDescription?: string | null | undefined;
-        vlessRouteId?: number | null | undefined;
-    }>>;
+        vlessRouteId: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    }, z.core.$strip>>;
     responseHeaders: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
     hwidSettings: z.ZodNullable<z.ZodObject<{
         enabled: z.ZodBoolean;
         fallbackDeviceLimit: z.ZodNumber;
         maxDevicesAnnounce: z.ZodNullable<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        enabled: boolean;
-        fallbackDeviceLimit: number;
-        maxDevicesAnnounce: string | null;
-    }, {
-        enabled: boolean;
-        fallbackDeviceLimit: number;
-        maxDevicesAnnounce: string | null;
-    }>>;
+    }, z.core.$strip>>;
     customRemarks: z.ZodNullable<z.ZodObject<{
-        expiredUsers: z.ZodArray<z.ZodString, "many">;
-        limitedUsers: z.ZodArray<z.ZodString, "many">;
-        disabledUsers: z.ZodArray<z.ZodString, "many">;
-        emptyHosts: z.ZodArray<z.ZodString, "many">;
-        HWIDMaxDevicesExceeded: z.ZodArray<z.ZodString, "many">;
-        HWIDNotSupported: z.ZodArray<z.ZodString, "many">;
-    }, "strip", z.ZodTypeAny, {
-        expiredUsers: string[];
-        limitedUsers: string[];
-        disabledUsers: string[];
-        emptyHosts: string[];
-        HWIDMaxDevicesExceeded: string[];
-        HWIDNotSupported: string[];
-    }, {
-        expiredUsers: string[];
-        limitedUsers: string[];
-        disabledUsers: string[];
-        emptyHosts: string[];
-        HWIDMaxDevicesExceeded: string[];
-        HWIDNotSupported: string[];
-    }>>;
-    subpageConfigUuid: z.ZodNullable<z.ZodString>;
-    createdAt: z.ZodEffects<z.ZodString, Date, string>;
-    updatedAt: z.ZodEffects<z.ZodString, Date, string>;
-}, "strip", z.ZodTypeAny, {
-    uuid: string;
-    name: string;
-    createdAt: Date;
-    updatedAt: Date;
-    viewPosition: number;
-    customRemarks: {
-        expiredUsers: string[];
-        limitedUsers: string[];
-        disabledUsers: string[];
-        emptyHosts: string[];
-        HWIDMaxDevicesExceeded: string[];
-        HWIDNotSupported: string[];
-    } | null;
-    hwidSettings: {
-        enabled: boolean;
-        fallbackDeviceLimit: number;
-        maxDevicesAnnounce: string | null;
-    } | null;
-    info: {
-        membersCount: number;
-    };
-    templates: {
-        templateUuid: string;
-        templateType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64";
-    }[];
-    subscriptionSettings: {
-        profileTitle?: string | undefined;
-        supportLink?: string | undefined;
-        profileUpdateInterval?: number | undefined;
-        isProfileWebpageUrlEnabled?: boolean | undefined;
-        serveJsonAtBaseSubscription?: boolean | undefined;
-        isShowCustomRemarks?: boolean | undefined;
-        happAnnounce?: string | null | undefined;
-        happRouting?: string | null | undefined;
-        randomizeHosts?: boolean | undefined;
-    } | null;
-    hostOverrides: {
-        serverDescription?: string | null | undefined;
-        vlessRouteId?: number | null | undefined;
-    } | null;
-    responseHeaders: Record<string, string> | null;
-    subpageConfigUuid: string | null;
-}, {
-    uuid: string;
-    name: string;
-    createdAt: string;
-    updatedAt: string;
-    viewPosition: number;
-    customRemarks: {
-        expiredUsers: string[];
-        limitedUsers: string[];
-        disabledUsers: string[];
-        emptyHosts: string[];
-        HWIDMaxDevicesExceeded: string[];
-        HWIDNotSupported: string[];
-    } | null;
-    hwidSettings: {
-        enabled: boolean;
-        fallbackDeviceLimit: number;
-        maxDevicesAnnounce: string | null;
-    } | null;
-    info: {
-        membersCount: number;
-    };
-    templates: {
-        templateUuid: string;
-        templateType: "STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64";
-    }[];
-    subscriptionSettings: {
-        profileTitle?: string | undefined;
-        supportLink?: string | undefined;
-        profileUpdateInterval?: number | undefined;
-        isProfileWebpageUrlEnabled?: boolean | undefined;
-        serveJsonAtBaseSubscription?: boolean | undefined;
-        isShowCustomRemarks?: boolean | undefined;
-        happAnnounce?: string | null | undefined;
-        happRouting?: string | null | undefined;
-        randomizeHosts?: boolean | undefined;
-    } | null;
-    hostOverrides: {
-        serverDescription?: string | null | undefined;
-        vlessRouteId?: number | null | undefined;
-    } | null;
-    responseHeaders: Record<string, string> | null;
-    subpageConfigUuid: string | null;
-}>;
+        expiredUsers: z.ZodArray<z.ZodString>;
+        limitedUsers: z.ZodArray<z.ZodString>;
+        disabledUsers: z.ZodArray<z.ZodString>;
+        emptyHosts: z.ZodArray<z.ZodString>;
+        HWIDMaxDevicesExceeded: z.ZodArray<z.ZodString>;
+        HWIDNotSupported: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    subpageConfigUuid: z.ZodNullable<z.ZodUUID>;
+    createdAt: z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>;
+    updatedAt: z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>;
+}, z.core.$strip>;
 //# sourceMappingURL=external-squad.schema.d.ts.map

package/build/backend/models/external-squad.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"external-squad.schema.d.ts","sourceRoot":"","sources":["../../../models/external-squad.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8B9B,CAAC"}
+{"version":3,"file":"external-squad.schema.d.ts","sourceRoot":"","sources":["../../../models/external-squad.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0B9B,CAAC"}

package/build/backend/models/external-squad.schema.js

@@ -6,28 +6,24 @@ const constants_1 = require("../constants");
 const external_squads_1 = require("./external-squads");
 const subscription_settings_1 = require("./subscription-settings");
 exports.ExternalSquadSchema = zod_1.z.object({
-    uuid: zod_1.z.string().uuid(),
-    viewPosition: zod_1.z.number().int(),
+    uuid: zod_1.z.uuid(),
+    viewPosition: zod_1.z.int(),
     name: zod_1.z.string(),
     info: zod_1.z.object({
         membersCount: zod_1.z.number(),
     }),
     templates: zod_1.z.array(zod_1.z.object({
-        templateUuid: zod_1.z.string().uuid(),
-        templateType: zod_1.z.nativeEnum(constants_1.SUBSCRIPTION_TEMPLATE_TYPE),
+        templateUuid: zod_1.z.uuid(),
+        templateType: zod_1.z.enum(constants_1.SUBSCRIPTION_TEMPLATE_TYPE),
     })),
     subscriptionSettings: zod_1.z.nullable(external_squads_1.ExternalSquadSubscriptionSettingsSchema),
     hostOverrides: zod_1.z.nullable(external_squads_1.ExternalSquadHostOverridesSchema),
     responseHeaders: external_squads_1.ExternalSquadResponseHeadersSchema,
     hwidSettings: zod_1.z.nullable(subscription_settings_1.HwidSettingsSchema),
     customRemarks: zod_1.z.nullable(subscription_settings_1.CustomRemarksSchema),
-    subpageConfigUuid: zod_1.z.nullable(zod_1.z.string().uuid()),
-    createdAt: zod_1.z
-        .string()
-        .datetime()
+    subpageConfigUuid: zod_1.z.nullable(zod_1.z.uuid()),
+    createdAt: zod_1.z.iso.datetime()
         .transform((str) => new Date(str)),
-    updatedAt: zod_1.z
-        .string()
-        .datetime()
+    updatedAt: zod_1.z.iso.datetime()
         .transform((str) => new Date(str)),
 });

package/build/backend/models/external-squads/external-squad-host-overrides.schema.d.ts

@@ -1,11 +1,5 @@
 export declare const ExternalSquadHostOverridesSchema: import("zod").ZodObject<{
     serverDescription: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
-    vlessRouteId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodNumber>>;
-}, "strip", import("zod").ZodTypeAny, {
-    serverDescription?: string | null | undefined;
-    vlessRouteId?: number | null | undefined;
-}, {
-    serverDescription?: string | null | undefined;
-    vlessRouteId?: number | null | undefined;
-}>;
+    vlessRouteId: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodInt>>;
+}, import("zod/v4/core").$strip>;
 //# sourceMappingURL=external-squad-host-overrides.schema.d.ts.map

package/build/backend/models/external-squads/external-squad-host-overrides.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"external-squad-host-overrides.schema.d.ts","sourceRoot":"","sources":["../../../../models/external-squads/external-squad-host-overrides.schema.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,gCAAgC;;;;;;;;;EAGjC,CAAC"}
+{"version":3,"file":"external-squad-host-overrides.schema.d.ts","sourceRoot":"","sources":["../../../../models/external-squads/external-squad-host-overrides.schema.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,gCAAgC;;;gCAGjC,CAAC"}

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

@@ -1,32 +1,12 @@
 export declare const ExternalSquadSubscriptionSettingsSchema: import("zod").ZodObject<{
     profileTitle: import("zod").ZodOptional<import("zod").ZodString>;
     supportLink: import("zod").ZodOptional<import("zod").ZodString>;
-    profileUpdateInterval: import("zod").ZodOptional<import("zod").ZodNumber>;
+    profileUpdateInterval: import("zod").ZodOptional<import("zod").ZodInt>;
     isProfileWebpageUrlEnabled: import("zod").ZodOptional<import("zod").ZodBoolean>;
     serveJsonAtBaseSubscription: import("zod").ZodOptional<import("zod").ZodBoolean>;
     isShowCustomRemarks: import("zod").ZodOptional<import("zod").ZodBoolean>;
     happAnnounce: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
     happRouting: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
     randomizeHosts: import("zod").ZodOptional<import("zod").ZodBoolean>;
-}, "strip", import("zod").ZodTypeAny, {
-    profileTitle?: string | undefined;
-    supportLink?: string | undefined;
-    profileUpdateInterval?: number | undefined;
-    isProfileWebpageUrlEnabled?: boolean | undefined;
-    serveJsonAtBaseSubscription?: boolean | undefined;
-    isShowCustomRemarks?: boolean | undefined;
-    happAnnounce?: string | null | undefined;
-    happRouting?: string | null | undefined;
-    randomizeHosts?: boolean | undefined;
-}, {
-    profileTitle?: string | undefined;
-    supportLink?: string | undefined;
-    profileUpdateInterval?: number | undefined;
-    isProfileWebpageUrlEnabled?: boolean | undefined;
-    serveJsonAtBaseSubscription?: boolean | undefined;
-    isShowCustomRemarks?: boolean | undefined;
-    happAnnounce?: string | null | undefined;
-    happRouting?: string | null | undefined;
-    randomizeHosts?: boolean | undefined;
-}>;
+}, import("zod/v4/core").$strip>;
 //# sourceMappingURL=external-squad-subscription-settings.schema.d.ts.map

package/build/backend/models/external-squads/external-squad-subscription-settings.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"external-squad-subscription-settings.schema.d.ts","sourceRoot":"","sources":["../../../../models/external-squads/external-squad-subscription-settings.schema.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUxC,CAAC"}
+{"version":3,"file":"external-squad-subscription-settings.schema.d.ts","sourceRoot":"","sources":["../../../../models/external-squads/external-squad-subscription-settings.schema.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,uCAAuC;;;;;;;;;;gCAUxC,CAAC"}

package/build/backend/models/hosts.schema.d.ts

@@ -1,14 +1,14 @@
 import { z } from 'zod';
 export declare const HostsSchema: z.ZodObject<{
-    uuid: z.ZodString;
-    viewPosition: z.ZodNumber;
+    uuid: z.ZodUUID;
+    viewPosition: z.ZodInt;
     remark: z.ZodString;
     address: z.ZodString;
-    port: z.ZodNumber;
+    port: z.ZodInt;
     path: z.ZodNullable<z.ZodString>;
     sni: z.ZodNullable<z.ZodString>;
     host: z.ZodNullable<z.ZodString>;
-    alpn: z.ZodNullable<z.ZodNativeEnum<{
+    alpn: z.ZodNullable<z.ZodEnum<{
         readonly H3: "h3";
         readonly H2: "h2";
         readonly HTTP_1_1: "http/1.1";
@@ -18,7 +18,7 @@ export declare const HostsSchema: z.ZodObject<{
     }>>;
     fingerprint: z.ZodNullable<z.ZodString>;
     isDisabled: z.ZodBoolean;
-    securityLayer: z.ZodDefault<z.ZodNativeEnum<{
+    securityLayer: z.ZodDefault<z.ZodEnum<{
         readonly DEFAULT: "DEFAULT";
         readonly TLS: "TLS";
         readonly NONE: "NONE";
@@ -28,114 +28,36 @@ export declare const HostsSchema: z.ZodObject<{
     sockoptParams: z.ZodNullable<z.ZodUnknown>;
     finalMask: z.ZodNullable<z.ZodUnknown>;
     inbound: z.ZodObject<{
-        configProfileUuid: z.ZodNullable<z.ZodString>;
-        configProfileInboundUuid: z.ZodNullable<z.ZodString>;
-    }, "strip", z.ZodTypeAny, {
-        configProfileUuid: string | null;
-        configProfileInboundUuid: string | null;
-    }, {
-        configProfileUuid: string | null;
-        configProfileInboundUuid: string | null;
-    }>;
+        configProfileUuid: z.ZodNullable<z.ZodUUID>;
+        configProfileInboundUuid: z.ZodNullable<z.ZodUUID>;
+    }, z.core.$strip>;
     serverDescription: z.ZodNullable<z.ZodString>;
-    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
     isHidden: z.ZodDefault<z.ZodBoolean>;
     overrideSniFromAddress: z.ZodDefault<z.ZodBoolean>;
     keepSniBlank: z.ZodDefault<z.ZodBoolean>;
-    vlessRouteId: z.ZodNullable<z.ZodNumber>;
+    vlessRouteId: z.ZodNullable<z.ZodInt>;
     pinnedPeerCertSha256: z.ZodNullable<z.ZodString>;
     verifyPeerCertByName: z.ZodNullable<z.ZodString>;
     shuffleHost: z.ZodBoolean;
     mihomoX25519: z.ZodBoolean;
-    mihomoIpVersion: z.ZodNullable<z.ZodNativeEnum<{
+    mihomoIpVersion: z.ZodNullable<z.ZodEnum<{
         readonly DUAL: "dual";
         readonly IPV4: "ipv4";
         readonly IPV6: "ipv6";
         readonly IPV4_PREFER: "ipv4-prefer";
         readonly IPV6_PREFER: "ipv6-prefer";
     }>>;
-    nodes: z.ZodArray<z.ZodString, "many">;
-    xrayJsonTemplateUuid: z.ZodNullable<z.ZodString>;
-    excludedInternalSquads: z.ZodArray<z.ZodString, "many">;
-    excludeFromSubscriptionTypes: z.ZodArray<z.ZodNativeEnum<{
+    nodes: z.ZodArray<z.ZodUUID>;
+    xrayJsonTemplateUuid: z.ZodNullable<z.ZodUUID>;
+    excludedInternalSquads: z.ZodArray<z.ZodUUID>;
+    excludeFromSubscriptionTypes: z.ZodArray<z.ZodEnum<{
         readonly XRAY_JSON: "XRAY_JSON";
         readonly XRAY_BASE64: "XRAY_BASE64";
         readonly MIHOMO: "MIHOMO";
         readonly STASH: "STASH";
         readonly CLASH: "CLASH";
         readonly SINGBOX: "SINGBOX";
-    }>, "many">;
-}, "strip", z.ZodTypeAny, {
-    nodes: string[];
-    tags: string[];
-    uuid: string;
-    path: string | null;
-    port: number;
-    viewPosition: number;
-    remark: string;
-    address: string;
-    sni: string | null;
-    host: string | null;
-    alpn: "h3" | "h2" | "http/1.1" | "h2,http/1.1" | "h3,h2,http/1.1" | "h3,h2" | null;
-    fingerprint: string | null;
-    isDisabled: boolean;
-    securityLayer: "DEFAULT" | "TLS" | "NONE";
-    inbound: {
-        configProfileUuid: string | null;
-        configProfileInboundUuid: string | null;
-    };
-    serverDescription: string | null;
-    isHidden: boolean;
-    overrideSniFromAddress: boolean;
-    keepSniBlank: boolean;
-    vlessRouteId: number | null;
-    pinnedPeerCertSha256: string | null;
-    verifyPeerCertByName: string | null;
-    shuffleHost: boolean;
-    mihomoX25519: boolean;
-    mihomoIpVersion: "dual" | "ipv4" | "ipv6" | "ipv4-prefer" | "ipv6-prefer" | null;
-    xrayJsonTemplateUuid: string | null;
-    excludedInternalSquads: string[];
-    excludeFromSubscriptionTypes: ("STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64")[];
-    xhttpExtraParams?: unknown;
-    muxParams?: unknown;
-    sockoptParams?: unknown;
-    finalMask?: unknown;
-}, {
-    nodes: string[];
-    uuid: string;
-    path: string | null;
-    port: number;
-    viewPosition: number;
-    remark: string;
-    address: string;
-    sni: string | null;
-    host: string | null;
-    alpn: "h3" | "h2" | "http/1.1" | "h2,http/1.1" | "h3,h2,http/1.1" | "h3,h2" | null;
-    fingerprint: string | null;
-    isDisabled: boolean;
-    inbound: {
-        configProfileUuid: string | null;
-        configProfileInboundUuid: string | null;
-    };
-    serverDescription: string | null;
-    vlessRouteId: number | null;
-    pinnedPeerCertSha256: string | null;
-    verifyPeerCertByName: string | null;
-    shuffleHost: boolean;
-    mihomoX25519: boolean;
-    mihomoIpVersion: "dual" | "ipv4" | "ipv6" | "ipv4-prefer" | "ipv6-prefer" | null;
-    xrayJsonTemplateUuid: string | null;
-    excludedInternalSquads: string[];
-    excludeFromSubscriptionTypes: ("STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64")[];
-    tags?: string[] | undefined;
-    securityLayer?: "DEFAULT" | "TLS" | "NONE" | undefined;
-    xhttpExtraParams?: unknown;
-    muxParams?: unknown;
-    sockoptParams?: unknown;
-    finalMask?: unknown;
-    isHidden?: boolean | undefined;
-    overrideSniFromAddress?: boolean | undefined;
-    keepSniBlank?: boolean | undefined;
-}>;
+    }>>;
+}, z.core.$strip>;
 //# sourceMappingURL=hosts.schema.d.ts.map

package/build/backend/models/hosts.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hosts.schema.d.ts","sourceRoot":"","sources":["../../../models/hosts.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuCtB,CAAC"}
+{"version":3,"file":"hosts.schema.d.ts","sourceRoot":"","sources":["../../../models/hosts.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuCtB,CAAC"}

package/build/backend/models/hosts.schema.js

@@ -5,39 +5,39 @@ const zod_1 = require("zod");
 const constants_1 = require("../constants");
 const hosts_1 = require("../constants/hosts");
 exports.HostsSchema = zod_1.z.object({
-    uuid: zod_1.z.string().uuid(),
-    viewPosition: zod_1.z.number().int(),
+    uuid: zod_1.z.uuid(),
+    viewPosition: zod_1.z.int(),
     remark: zod_1.z.string(),
     address: zod_1.z.string(),
-    port: zod_1.z.number().int(),
+    port: zod_1.z.int(),
     path: zod_1.z.string().nullable(),
     sni: zod_1.z.string().nullable(),
     host: zod_1.z.string().nullable(),
-    alpn: zod_1.z.nativeEnum(hosts_1.ALPN).nullable(),
+    alpn: zod_1.z.enum(hosts_1.ALPN).nullable(),
     fingerprint: zod_1.z.string().nullable(),
     isDisabled: zod_1.z.boolean(),
-    securityLayer: zod_1.z.nativeEnum(hosts_1.SECURITY_LAYERS).default(hosts_1.SECURITY_LAYERS.DEFAULT),
+    securityLayer: zod_1.z.enum(hosts_1.SECURITY_LAYERS).default(hosts_1.SECURITY_LAYERS.DEFAULT),
     xhttpExtraParams: zod_1.z.nullable(zod_1.z.unknown()),
     muxParams: zod_1.z.nullable(zod_1.z.unknown()),
     sockoptParams: zod_1.z.nullable(zod_1.z.unknown()),
     finalMask: zod_1.z.nullable(zod_1.z.unknown()),
     inbound: zod_1.z.object({
-        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(),
     }),
     serverDescription: zod_1.z.string().max(30).nullable(),
     tags: zod_1.z.array(zod_1.z.string()).default([]),
     isHidden: zod_1.z.boolean().default(false),
     overrideSniFromAddress: zod_1.z.boolean().default(false),
     keepSniBlank: zod_1.z.boolean().default(false),
-    vlessRouteId: zod_1.z.number().int().min(0).max(65535).nullable(),
+    vlessRouteId: zod_1.z.int().min(0).max(65535).nullable(),
     pinnedPeerCertSha256: zod_1.z.string().nullable(),
     verifyPeerCertByName: zod_1.z.string().nullable(),
     shuffleHost: zod_1.z.boolean(),
     mihomoX25519: zod_1.z.boolean(),
-    mihomoIpVersion: zod_1.z.nativeEnum(hosts_1.MIHOMO_IP_VERSION).nullable(),
-    nodes: zod_1.z.array(zod_1.z.string().uuid()),
-    xrayJsonTemplateUuid: zod_1.z.string().uuid().nullable(),
-    excludedInternalSquads: zod_1.z.array(zod_1.z.string().uuid()),
-    excludeFromSubscriptionTypes: zod_1.z.array(zod_1.z.nativeEnum(constants_1.SUBSCRIPTION_TEMPLATE_TYPE)),
+    mihomoIpVersion: zod_1.z.enum(hosts_1.MIHOMO_IP_VERSION).nullable(),
+    nodes: zod_1.z.array(zod_1.z.uuid()),
+    xrayJsonTemplateUuid: zod_1.z.uuid().nullable(),
+    excludedInternalSquads: zod_1.z.array(zod_1.z.uuid()),
+    excludeFromSubscriptionTypes: zod_1.z.array(zod_1.z.enum(constants_1.SUBSCRIPTION_TEMPLATE_TYPE)),
 });

package/build/backend/models/hwid-user-device.schema.d.ts

@@ -7,27 +7,7 @@ export declare const HwidUserDeviceSchema: z.ZodObject<{
     deviceModel: z.ZodNullable<z.ZodString>;
     userAgent: z.ZodNullable<z.ZodString>;
     requestIp: z.ZodNullable<z.ZodString>;
-    createdAt: z.ZodEffects<z.ZodString, Date, string>;
-    updatedAt: z.ZodEffects<z.ZodString, Date, string>;
-}, "strip", z.ZodTypeAny, {
-    hwid: string;
-    createdAt: Date;
-    updatedAt: Date;
-    userId: number;
-    platform: string | null;
-    osVersion: string | null;
-    deviceModel: string | null;
-    userAgent: string | null;
-    requestIp: string | null;
-}, {
-    hwid: string;
-    createdAt: string;
-    updatedAt: string;
-    userId: number;
-    platform: string | null;
-    osVersion: string | null;
-    deviceModel: string | null;
-    userAgent: string | null;
-    requestIp: string | null;
-}>;
+    createdAt: z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>;
+    updatedAt: z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>;
+}, z.core.$strip>;
 //# sourceMappingURL=hwid-user-device.schema.d.ts.map

package/build/backend/models/hwid-user-device.schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hwid-user-device.schema.d.ts","sourceRoot":"","sources":["../../../models/hwid-user-device.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiB/B,CAAC"}
+{"version":3,"file":"hwid-user-device.schema.d.ts","sourceRoot":"","sources":["../../../models/hwid-user-device.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,oBAAoB;;;;;;;;;;iBAa/B,CAAC"}

package/build/backend/models/hwid-user-device.schema.js

@@ -10,12 +10,8 @@ exports.HwidUserDeviceSchema = zod_1.z.object({
     deviceModel: zod_1.z.nullable(zod_1.z.string()),
     userAgent: zod_1.z.nullable(zod_1.z.string()),
     requestIp: zod_1.z.nullable(zod_1.z.string()),
-    createdAt: zod_1.z
-        .string()
-        .datetime()
+    createdAt: zod_1.z.iso.datetime()
         .transform((str) => new Date(str)),
-    updatedAt: zod_1.z
-        .string()
-        .datetime()
+    updatedAt: zod_1.z.iso.datetime()
         .transform((str) => new Date(str)),
 });