@remnawave/backend-contract 3.3.2 → 3.4.0

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

@@ -243,116 +243,10 @@ export declare const ProxyEntryMetadataSchema: z.ZodObject<{
     vlessRouteId: z.ZodNullable<z.ZodInt>;
     rawInbound: z.ZodNullable<z.ZodUnknown>;
 }, z.core.$strip>;
-export declare const ResolvedProxyConfigSchema: z.ZodObject<{
+export declare const ResolvedProxyConfigBaseSchema: z.ZodObject<{
     finalRemark: z.ZodString;
     address: z.ZodString;
     port: z.ZodInt;
-    protocol: z.ZodEnum<{
-        vless: "vless";
-        trojan: "trojan";
-        shadowsocks: "shadowsocks";
-        hysteria: "hysteria";
-    }>;
-    protocolOptions: z.ZodUnion<readonly [z.ZodObject<{
-        encryption: z.ZodString;
-        id: z.ZodString;
-        flow: z.ZodEnum<{
-            "": "";
-            "xtls-rprx-vision": "xtls-rprx-vision";
-            "xtls-rprx-vision-udp443": "xtls-rprx-vision-udp443";
-        }>;
-    }, z.core.$strip>, z.ZodObject<{
-        password: z.ZodString;
-    }, z.core.$strip>, z.ZodObject<{
-        method: z.ZodString;
-        password: z.ZodString;
-        uot: z.ZodBoolean;
-        uotVersion: z.ZodInt;
-    }, z.core.$strip>, z.ZodObject<{
-        version: z.ZodInt;
-    }, z.core.$strip>]>;
-    transport: z.ZodEnum<{
-        hysteria: "hysteria";
-        tcp: "tcp";
-        xhttp: "xhttp";
-        ws: "ws";
-        httpupgrade: "httpupgrade";
-        grpc: "grpc";
-        kcp: "kcp";
-    }>;
-    transportOptions: z.ZodUnion<readonly [z.ZodObject<{
-        header: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
-            type: z.ZodLiteral<"none">;
-        }, z.core.$strip>, z.ZodObject<{
-            type: z.ZodLiteral<"http">;
-            request: z.ZodOptional<z.ZodObject<{
-                version: z.ZodOptional<z.ZodString>;
-                method: z.ZodOptional<z.ZodString>;
-                path: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-            }, z.core.$strip>>;
-            response: z.ZodOptional<z.ZodObject<{
-                version: z.ZodOptional<z.ZodString>;
-                status: z.ZodOptional<z.ZodString>;
-                reason: z.ZodOptional<z.ZodString>;
-                headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-            }, z.core.$strip>>;
-        }, z.core.$strip>], "type">>;
-    }, z.core.$strip>, z.ZodObject<{
-        path: z.ZodNullable<z.ZodString>;
-        host: z.ZodNullable<z.ZodString>;
-        mode: z.ZodEnum<{
-            auto: "auto";
-            "packet-up": "packet-up";
-            "stream-up": "stream-up";
-            "stream-one": "stream-one";
-        }>;
-        extra: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    }, z.core.$strip>, z.ZodObject<{
-        path: z.ZodNullable<z.ZodString>;
-        host: z.ZodNullable<z.ZodString>;
-        headers: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
-        heartbeatPeriod: z.ZodNullable<z.ZodNumber>;
-    }, z.core.$strip>, z.ZodObject<{
-        path: z.ZodNullable<z.ZodString>;
-        host: z.ZodNullable<z.ZodString>;
-        headers: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
-    }, z.core.$strip>, z.ZodObject<{
-        authority: z.ZodNullable<z.ZodString>;
-        serviceName: z.ZodNullable<z.ZodString>;
-        multiMode: z.ZodBoolean;
-    }, z.core.$strip>, z.ZodObject<{
-        clientMtu: z.ZodInt;
-        clientTti: z.ZodInt;
-        congestion: z.ZodBoolean;
-    }, z.core.$strip>, z.ZodObject<{
-        version: z.ZodInt;
-        auth: z.ZodString;
-    }, z.core.$strip>]>;
-    security: z.ZodEnum<{
-        none: "none";
-        tls: "tls";
-        reality: "reality";
-    }>;
-    securityOptions: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
-        pinnedPeerCertSha256: z.ZodNullable<z.ZodString>;
-        verifyPeerCertByName: z.ZodNullable<z.ZodString>;
-        alpn: z.ZodNullable<z.ZodString>;
-        enableSessionResumption: z.ZodBoolean;
-        fingerprint: z.ZodNullable<z.ZodString>;
-        serverName: z.ZodNullable<z.ZodString>;
-        echConfigList: z.ZodNullable<z.ZodString>;
-        echForceQuery: z.ZodNullable<z.ZodString>;
-        echSockopt: z.ZodNullable<z.ZodUnknown>;
-        cipherSuites: z.ZodNullable<z.ZodString>;
-    }, z.core.$strip>, z.ZodObject<{
-        fingerprint: z.ZodString;
-        publicKey: z.ZodString;
-        shortId: z.ZodNullable<z.ZodString>;
-        serverName: z.ZodString;
-        spiderX: z.ZodNullable<z.ZodString>;
-        mldsa65Verify: z.ZodNullable<z.ZodString>;
-    }, z.core.$strip>]>>;
     streamOverrides: z.ZodObject<{
         finalMask: z.ZodNullable<z.ZodUnknown>;
         sockopt: z.ZodNullable<z.ZodUnknown>;
@@ -431,4 +325,210 @@ export declare const ResolvedProxyConfigSchema: z.ZodObject<{
         rawInbound: z.ZodNullable<z.ZodUnknown>;
     }, z.core.$strip>;
 }, z.core.$strip>;
+export declare const ResolvedProxyConfigSchema: z.ZodIntersection<z.ZodIntersection<z.ZodIntersection<z.ZodObject<{
+    finalRemark: z.ZodString;
+    address: z.ZodString;
+    port: z.ZodInt;
+    streamOverrides: z.ZodObject<{
+        finalMask: z.ZodNullable<z.ZodUnknown>;
+        sockopt: z.ZodNullable<z.ZodUnknown>;
+    }, z.core.$strip>;
+    mux: z.ZodNullable<z.ZodUnknown>;
+    clientOverrides: z.ZodObject<{
+        shuffleHost: z.ZodBoolean;
+        mihomoX25519: z.ZodBoolean;
+        mihomoIpVersion: z.ZodNullable<z.ZodEnum<{
+            readonly DUAL: "dual";
+            readonly IPV4: "ipv4";
+            readonly IPV6: "ipv6";
+            readonly IPV4_PREFER: "ipv4-prefer";
+            readonly IPV6_PREFER: "ipv6-prefer";
+        }>>;
+        serverDescription: z.ZodNullable<z.ZodString>;
+        xrayJsonTemplate: z.ZodNullable<z.ZodUnknown>;
+        mapper: z.ZodObject<{
+            xrayJson: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                op: z.ZodLiteral<"copy">;
+                from: z.ZodString;
+                to: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"set">;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodJSONSchema>, z.ZodRecord<z.ZodString, z.ZodJSONSchema>]>;
+                to: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"unset">;
+                to: z.ZodString;
+            }, z.core.$strip>], "op">>>;
+            mihomo: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                op: z.ZodLiteral<"copy">;
+                from: z.ZodString;
+                to: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"set">;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodJSONSchema>, z.ZodRecord<z.ZodString, z.ZodJSONSchema>]>;
+                to: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"unset">;
+                to: z.ZodString;
+            }, z.core.$strip>], "op">>>;
+            base64: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                op: z.ZodLiteral<"copy">;
+                from: z.ZodString;
+                to: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"set">;
+                value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodJSONSchema>, z.ZodRecord<z.ZodString, z.ZodJSONSchema>]>;
+                to: z.ZodString;
+            }, z.core.$strip>, z.ZodObject<{
+                op: z.ZodLiteral<"unset">;
+                to: z.ZodString;
+            }, z.core.$strip>], "op">>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+    metadata: z.ZodObject<{
+        uuid: z.ZodUUID;
+        tags: z.ZodArray<z.ZodString>;
+        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";
+        }>>;
+        inboundTag: z.ZodString;
+        configProfileUuid: z.ZodNullable<z.ZodUUID>;
+        configProfileInboundUuid: z.ZodNullable<z.ZodUUID>;
+        isDisabled: z.ZodBoolean;
+        isHidden: z.ZodBoolean;
+        viewPosition: z.ZodInt;
+        remark: z.ZodString;
+        vlessRouteId: z.ZodNullable<z.ZodInt>;
+        rawInbound: z.ZodNullable<z.ZodUnknown>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    protocol: z.ZodLiteral<"vless">;
+    protocolOptions: z.ZodObject<{
+        encryption: z.ZodString;
+        id: z.ZodString;
+        flow: z.ZodEnum<{
+            "": "";
+            "xtls-rprx-vision": "xtls-rprx-vision";
+            "xtls-rprx-vision-udp443": "xtls-rprx-vision-udp443";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    protocol: z.ZodLiteral<"trojan">;
+    protocolOptions: z.ZodObject<{
+        password: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    protocol: z.ZodLiteral<"shadowsocks">;
+    protocolOptions: z.ZodObject<{
+        method: z.ZodString;
+        password: z.ZodString;
+        uot: z.ZodBoolean;
+        uotVersion: z.ZodInt;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    protocol: z.ZodLiteral<"hysteria">;
+    protocolOptions: z.ZodObject<{
+        version: z.ZodInt;
+    }, z.core.$strip>;
+}, z.core.$strip>], "protocol">>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    transport: z.ZodLiteral<"tcp">;
+    transportOptions: z.ZodObject<{
+        header: z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"none">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"http">;
+            request: z.ZodOptional<z.ZodObject<{
+                version: z.ZodOptional<z.ZodString>;
+                method: z.ZodOptional<z.ZodString>;
+                path: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
+            response: z.ZodOptional<z.ZodObject<{
+                version: z.ZodOptional<z.ZodString>;
+                status: z.ZodOptional<z.ZodString>;
+                reason: z.ZodOptional<z.ZodString>;
+                headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>], "type">>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    transport: z.ZodLiteral<"xhttp">;
+    transportOptions: z.ZodObject<{
+        path: z.ZodNullable<z.ZodString>;
+        host: z.ZodNullable<z.ZodString>;
+        mode: z.ZodEnum<{
+            auto: "auto";
+            "packet-up": "packet-up";
+            "stream-up": "stream-up";
+            "stream-one": "stream-one";
+        }>;
+        extra: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    transport: z.ZodLiteral<"ws">;
+    transportOptions: z.ZodObject<{
+        path: z.ZodNullable<z.ZodString>;
+        host: z.ZodNullable<z.ZodString>;
+        headers: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
+        heartbeatPeriod: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    transport: z.ZodLiteral<"httpupgrade">;
+    transportOptions: z.ZodObject<{
+        path: z.ZodNullable<z.ZodString>;
+        host: z.ZodNullable<z.ZodString>;
+        headers: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    transport: z.ZodLiteral<"grpc">;
+    transportOptions: z.ZodObject<{
+        authority: z.ZodNullable<z.ZodString>;
+        serviceName: z.ZodNullable<z.ZodString>;
+        multiMode: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    transport: z.ZodLiteral<"kcp">;
+    transportOptions: z.ZodObject<{
+        clientMtu: z.ZodInt;
+        clientTti: z.ZodInt;
+        congestion: z.ZodBoolean;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    transport: z.ZodLiteral<"hysteria">;
+    transportOptions: z.ZodObject<{
+        version: z.ZodInt;
+        auth: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>], "transport">>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    security: z.ZodLiteral<"tls">;
+    securityOptions: z.ZodObject<{
+        pinnedPeerCertSha256: z.ZodNullable<z.ZodString>;
+        verifyPeerCertByName: z.ZodNullable<z.ZodString>;
+        alpn: z.ZodNullable<z.ZodString>;
+        enableSessionResumption: z.ZodBoolean;
+        fingerprint: z.ZodNullable<z.ZodString>;
+        serverName: z.ZodNullable<z.ZodString>;
+        echConfigList: z.ZodNullable<z.ZodString>;
+        echForceQuery: z.ZodNullable<z.ZodString>;
+        echSockopt: z.ZodNullable<z.ZodUnknown>;
+        cipherSuites: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    security: z.ZodLiteral<"reality">;
+    securityOptions: z.ZodObject<{
+        fingerprint: z.ZodString;
+        publicKey: z.ZodString;
+        shortId: z.ZodNullable<z.ZodString>;
+        serverName: z.ZodString;
+        spiderX: z.ZodNullable<z.ZodString>;
+        mldsa65Verify: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    security: z.ZodLiteral<"none">;
+}, z.core.$strip>], "security">>;
 //# sourceMappingURL=resolved-proxy-config.schema.d.ts.map

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":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,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;;;;;;;;;;;iBAWnC,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4CpC,CAAC"}
+{"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;AAKxB,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;;;;;;;;;;;iBAWnC,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,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsBxC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAEP,CAAC"}

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResolvedProxyConfigSchema = exports.ProxyEntryMetadataSchema = exports.SecurityVariantSchema = exports.TransportVariantSchema = exports.ProtocolVariantSchema = exports.RealitySecurityOptionsSchema = exports.TlsSecurityOptionsSchema = exports.HysteriaTransportOptionsSchema = exports.HysteriaProtocolOptionsSchema = exports.KcpTransportOptionsSchema = exports.GrpcTransportOptionsSchema = exports.HttpUpgradeTransportOptionsSchema = exports.WsTransportOptionsSchema = exports.XhttpTransportOptionsSchema = exports.TcpTransportOptionsSchema = exports.ShadowsocksProtocolOptionsSchema = exports.TrojanProtocolOptionsSchema = exports.VlessProtocolOptionsSchema = void 0;
+exports.ResolvedProxyConfigSchema = exports.ResolvedProxyConfigBaseSchema = exports.ProxyEntryMetadataSchema = exports.SecurityVariantSchema = exports.TransportVariantSchema = exports.ProtocolVariantSchema = exports.RealitySecurityOptionsSchema = exports.TlsSecurityOptionsSchema = exports.HysteriaTransportOptionsSchema = exports.HysteriaProtocolOptionsSchema = exports.KcpTransportOptionsSchema = exports.GrpcTransportOptionsSchema = exports.HttpUpgradeTransportOptionsSchema = exports.WsTransportOptionsSchema = exports.XhttpTransportOptionsSchema = exports.TcpTransportOptionsSchema = exports.ShadowsocksProtocolOptionsSchema = exports.TrojanProtocolOptionsSchema = exports.VlessProtocolOptionsSchema = void 0;
 const zod_1 = require("zod");
 const constants_1 = require("../constants");
 const host_mapper_1 = require("./host-mapper");
@@ -113,10 +113,10 @@ const HysteriaProtocolSchema = zod_1.z.object({
     protocolOptions: exports.HysteriaProtocolOptionsSchema,
 });
 exports.ProtocolVariantSchema = zod_1.z.discriminatedUnion('protocol', [
-    VlessProtocolSchema,
-    TrojanProtocolSchema,
-    ShadowsocksProtocolSchema,
-    HysteriaProtocolSchema,
+    VlessProtocolSchema.meta({ title: 'vless' }),
+    TrojanProtocolSchema.meta({ title: 'trojan' }),
+    ShadowsocksProtocolSchema.meta({ title: 'shadowsocks' }),
+    HysteriaProtocolSchema.meta({ title: 'hysteria' }),
 ]);
 const TcpTransportSchema = zod_1.z.object({
     transport: zod_1.z.literal('tcp'),
@@ -147,13 +147,13 @@ const HysteriaTransportSchema = zod_1.z.object({
     transportOptions: exports.HysteriaTransportOptionsSchema,
 });
 exports.TransportVariantSchema = zod_1.z.discriminatedUnion('transport', [
-    TcpTransportSchema,
-    XHttpTransportSchema,
-    WsTransportSchema,
-    HttpUpgradeTransportSchema,
-    GrpcTransportSchema,
-    KcpTransportSchema,
-    HysteriaTransportSchema,
+    TcpTransportSchema.meta({ title: 'tcp' }),
+    XHttpTransportSchema.meta({ title: 'xhttp' }),
+    WsTransportSchema.meta({ title: 'ws' }),
+    HttpUpgradeTransportSchema.meta({ title: 'httpupgrade' }),
+    GrpcTransportSchema.meta({ title: 'grpc' }),
+    KcpTransportSchema.meta({ title: 'kcp' }),
+    HysteriaTransportSchema.meta({ title: 'hysteria' }),
 ]);
 const TlsSecuritySchema = zod_1.z.object({
     security: zod_1.z.literal('tls'),
@@ -167,9 +167,9 @@ const NoneSecuritySchema = zod_1.z.object({
     security: zod_1.z.literal('none'),
 });
 exports.SecurityVariantSchema = zod_1.z.discriminatedUnion('security', [
-    TlsSecuritySchema,
-    RealitySecuritySchema,
-    NoneSecuritySchema,
+    TlsSecuritySchema.meta({ title: 'tls' }),
+    RealitySecuritySchema.meta({ title: 'reality' }),
+    NoneSecuritySchema.meta({ title: 'none' }),
 ]);
 exports.ProxyEntryMetadataSchema = zod_1.z.object({
     uuid: zod_1.z.uuid(),
@@ -185,29 +185,10 @@ exports.ProxyEntryMetadataSchema = zod_1.z.object({
     vlessRouteId: zod_1.z.int().nullable(),
     rawInbound: zod_1.z.nullable(zod_1.z.unknown()),
 });
-exports.ResolvedProxyConfigSchema = zod_1.z.object({
+exports.ResolvedProxyConfigBaseSchema = zod_1.z.object({
     finalRemark: zod_1.z.string(),
     address: zod_1.z.string(),
     port: zod_1.z.int().positive(),
-    protocol: zod_1.z.enum(['vless', 'trojan', 'shadowsocks', 'hysteria']),
-    protocolOptions: zod_1.z.union([
-        exports.VlessProtocolOptionsSchema,
-        exports.TrojanProtocolOptionsSchema,
-        exports.ShadowsocksProtocolOptionsSchema,
-        exports.HysteriaProtocolOptionsSchema,
-    ]),
-    transport: zod_1.z.enum(['tcp', 'xhttp', 'ws', 'httpupgrade', 'grpc', 'kcp', 'hysteria']),
-    transportOptions: zod_1.z.union([
-        exports.TcpTransportOptionsSchema,
-        exports.XhttpTransportOptionsSchema,
-        exports.WsTransportOptionsSchema,
-        exports.HttpUpgradeTransportOptionsSchema,
-        exports.GrpcTransportOptionsSchema,
-        exports.KcpTransportOptionsSchema,
-        exports.HysteriaTransportOptionsSchema,
-    ]),
-    security: zod_1.z.enum(['tls', 'reality', 'none']),
-    securityOptions: zod_1.z.union([exports.TlsSecurityOptionsSchema, exports.RealitySecurityOptionsSchema]).optional(),
     streamOverrides: zod_1.z.object({
         finalMask: zod_1.z.nullable(zod_1.z.unknown()),
         sockopt: zod_1.z.nullable(zod_1.z.unknown()),
@@ -223,3 +204,6 @@ exports.ResolvedProxyConfigSchema = zod_1.z.object({
     }),
     metadata: exports.ProxyEntryMetadataSchema,
 });
+exports.ResolvedProxyConfigSchema = exports.ResolvedProxyConfigBaseSchema.and(exports.ProtocolVariantSchema)
+    .and(exports.TransportVariantSchema)
+    .and(exports.SecurityVariantSchema);

package/build/backend/models/shared-list.schema.d.ts

@@ -0,0 +1,12 @@
+import z from 'zod';
+export declare const SharedListNameSchema: z.ZodString;
+export declare const SharedListsSchema: z.ZodObject<{
+    name: z.ZodString;
+    config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export declare const SharedListPreviewSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodString;
+    itemsCount: z.ZodNumber;
+}, z.core.$strip>;
+//# sourceMappingURL=shared-list.schema.d.ts.map

package/build/backend/models/shared-list.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared-list.schema.d.ts","sourceRoot":"","sources":["../../../models/shared-list.schema.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,eAAO,MAAM,oBAAoB,aAO5B,CAAC;AAEN,eAAO,MAAM,iBAAiB;;;iBAG5B,CAAC;AAEH,eAAO,MAAM,uBAAuB;;;;iBAIlC,CAAC"}

package/build/backend/models/shared-list.schema.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharedListPreviewSchema = exports.SharedListsSchema = exports.SharedListNameSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+exports.SharedListNameSchema = zod_1.default
+    .string()
+    .min(2, 'Name must be at least 2 characters')
+    .max(255, 'Name must be less than 255 characters')
+    .regex(/^[A-Za-z0-9_-]+$/, 'Name can only contain letters, numbers, underscores and dashes. The "ext:" prefix is added automatically');
+exports.SharedListsSchema = zod_1.default.object({
+    name: exports.SharedListNameSchema,
+    config: zod_1.default.record(zod_1.default.string(), zod_1.default.unknown()),
+});
+exports.SharedListPreviewSchema = zod_1.default.object({
+    name: exports.SharedListNameSchema,
+    type: zod_1.default.string(),
+    itemsCount: zod_1.default.number(),
+});

package/build/frontend/api/controllers/node-plugins.js

@@ -4,6 +4,7 @@ exports.NODE_PLUGINS_ROUTES = exports.NODE_PLUGINS_CONTROLLER = void 0;
 exports.NODE_PLUGINS_CONTROLLER = 'node-plugins';
 const ACTIONS_ROUTE = 'actions';
 const TORRENT_BLOCKER_ROUTE = 'torrent-blocker';
+const SHARED_LISTS_ROUTE = 'shared-lists';
 exports.NODE_PLUGINS_ROUTES = {
     GET_ALL: '', // get
     GET: (uuid) => `${uuid}`, // get
@@ -13,6 +14,7 @@ exports.NODE_PLUGINS_ROUTES = {
     ACTIONS: {
         REORDER: `${ACTIONS_ROUTE}/reorder`,
         CLONE: `${ACTIONS_ROUTE}/clone`,
+        SYNC: `${ACTIONS_ROUTE}/sync`,
     },
     EXECUTOR: 'executor',
     TORRENT_BLOCKER: {
@@ -20,4 +22,14 @@ exports.NODE_PLUGINS_ROUTES = {
         GET_REPORTS_STATS: `${TORRENT_BLOCKER_ROUTE}/stats`,
         TRUNCATE_REPORTS: `${TORRENT_BLOCKER_ROUTE}/truncate`,
     },
+    SHARED_LISTS: {
+        GET_ALL: `${SHARED_LISTS_ROUTE}`, // get
+        GET: (name) => `${SHARED_LISTS_ROUTE}/${name}`, // get
+        CREATE: `${SHARED_LISTS_ROUTE}`, // post
+        UPDATE: `${SHARED_LISTS_ROUTE}`, // patch
+        DELETE: (name) => `${SHARED_LISTS_ROUTE}/${name}`, // delete
+        ACTIONS: {
+            SYNC: `${SHARED_LISTS_ROUTE}/${ACTIONS_ROUTE}/sync`, // post
+        },
+    },
 };

package/build/frontend/api/routes.js

@@ -317,8 +317,19 @@ exports.REST_API = {
         ACTIONS: {
             REORDER: `${exports.ROOT}/${CONTROLLERS.NODE_PLUGINS_CONTROLLER}/${CONTROLLERS.NODE_PLUGINS_ROUTES.ACTIONS.REORDER}`,
             CLONE: `${exports.ROOT}/${CONTROLLERS.NODE_PLUGINS_CONTROLLER}/${CONTROLLERS.NODE_PLUGINS_ROUTES.ACTIONS.CLONE}`,
+            SYNC: `${exports.ROOT}/${CONTROLLERS.NODE_PLUGINS_CONTROLLER}/${CONTROLLERS.NODE_PLUGINS_ROUTES.ACTIONS.SYNC}`,
         },
         EXECUTOR: `${exports.ROOT}/${CONTROLLERS.NODE_PLUGINS_CONTROLLER}/${CONTROLLERS.NODE_PLUGINS_ROUTES.EXECUTOR}`,
+        SHARED_LISTS: {
+            GET_ALL: `${exports.ROOT}/${CONTROLLERS.NODE_PLUGINS_CONTROLLER}/${CONTROLLERS.NODE_PLUGINS_ROUTES.SHARED_LISTS.GET_ALL}`,
+            GET: (name) => `${exports.ROOT}/${CONTROLLERS.NODE_PLUGINS_CONTROLLER}/${CONTROLLERS.NODE_PLUGINS_ROUTES.SHARED_LISTS.GET(name)}`,
+            CREATE: `${exports.ROOT}/${CONTROLLERS.NODE_PLUGINS_CONTROLLER}/${CONTROLLERS.NODE_PLUGINS_ROUTES.SHARED_LISTS.CREATE}`,
+            UPDATE: `${exports.ROOT}/${CONTROLLERS.NODE_PLUGINS_CONTROLLER}/${CONTROLLERS.NODE_PLUGINS_ROUTES.SHARED_LISTS.UPDATE}`,
+            DELETE: (name) => `${exports.ROOT}/${CONTROLLERS.NODE_PLUGINS_CONTROLLER}/${CONTROLLERS.NODE_PLUGINS_ROUTES.SHARED_LISTS.DELETE(name)}`,
+            ACTIONS: {
+                SYNC: `${exports.ROOT}/${CONTROLLERS.NODE_PLUGINS_CONTROLLER}/${CONTROLLERS.NODE_PLUGINS_ROUTES.SHARED_LISTS.ACTIONS.SYNC}`,
+            },
+        },
         TORRENT_BLOCKER: {
             GET_REPORTS: `${exports.ROOT}/${CONTROLLERS.NODE_PLUGINS_CONTROLLER}/${CONTROLLERS.NODE_PLUGINS_ROUTES.TORRENT_BLOCKER.GET_REPORTS}`,
             GET_REPORTS_STATS: `${exports.ROOT}/${CONTROLLERS.NODE_PLUGINS_CONTROLLER}/${CONTROLLERS.NODE_PLUGINS_ROUTES.TORRENT_BLOCKER.GET_REPORTS_STATS}`,

package/build/frontend/commands/node-plugins/actions/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./clone-node-plugin.command"), exports);
 __exportStar(require("./reorder.command"), exports);
+__exportStar(require("./sync-node-plugin.command"), exports);

package/build/frontend/commands/node-plugins/actions/sync-node-plugin.command.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncNodePluginCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../../api");
+const constants_1 = require("../../../constants");
+var SyncNodePluginCommand;
+(function (SyncNodePluginCommand) {
+    SyncNodePluginCommand.url = api_1.REST_API.NODE_PLUGINS.ACTIONS.SYNC;
+    SyncNodePluginCommand.TSQ_url = SyncNodePluginCommand.url;
+    SyncNodePluginCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.NODE_PLUGINS_ROUTES.ACTIONS.SYNC, 'post', 'Sync Node Plugin to nodes', { scope: 'sync', kind: 'write' }, 'Push the current plugin config, including referenced shared lists, to every connected node this plugin is active on.');
+    SyncNodePluginCommand.RequestBodySchema = zod_1.z.object({
+        uuid: zod_1.z.uuid(),
+    });
+})(SyncNodePluginCommand || (exports.SyncNodePluginCommand = SyncNodePluginCommand = {}));

package/build/frontend/commands/node-plugins/index.js

@@ -20,5 +20,6 @@ __exportStar(require("./delete-node-plugin.command"), exports);
 __exportStar(require("./executor.command"), exports);
 __exportStar(require("./get-node-plugin.command"), exports);
 __exportStar(require("./get-node-plugins.command"), exports);
+__exportStar(require("./shared-lists"), exports);
 __exportStar(require("./torrent-blocker"), exports);
 __exportStar(require("./update-node-plugin.command"), exports);

package/build/frontend/commands/node-plugins/shared-lists/create-shared-list.command.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateSharedListCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../../api");
+const constants_1 = require("../../../constants");
+const models_1 = require("../../../models");
+var CreateSharedListCommand;
+(function (CreateSharedListCommand) {
+    CreateSharedListCommand.url = api_1.REST_API.NODE_PLUGINS.SHARED_LISTS.CREATE;
+    CreateSharedListCommand.TSQ_url = CreateSharedListCommand.url;
+    CreateSharedListCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.NODE_PLUGINS_ROUTES.SHARED_LISTS.CREATE, 'post', 'Create Shared List', { scope: 'shared-lists-create', kind: 'write' });
+    CreateSharedListCommand.RequestBodySchema = zod_1.z.object({
+        name: models_1.SharedListNameSchema,
+        config: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()),
+    });
+    CreateSharedListCommand.ResponseSchema = zod_1.z.object({
+        response: models_1.SharedListsSchema,
+    });
+})(CreateSharedListCommand || (exports.CreateSharedListCommand = CreateSharedListCommand = {}));

package/build/frontend/commands/node-plugins/shared-lists/delete-shared-list.command.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteSharedListCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../../api");
+const constants_1 = require("../../../constants");
+const models_1 = require("../../../models");
+var DeleteSharedListCommand;
+(function (DeleteSharedListCommand) {
+    DeleteSharedListCommand.url = api_1.REST_API.NODE_PLUGINS.SHARED_LISTS.DELETE;
+    DeleteSharedListCommand.TSQ_url = DeleteSharedListCommand.url(':name');
+    DeleteSharedListCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.NODE_PLUGINS_ROUTES.SHARED_LISTS.DELETE(':name'), 'delete', 'Delete Shared List by name', { scope: 'shared-lists-delete', kind: 'write' });
+    DeleteSharedListCommand.RequestParamSchema = zod_1.z.object({
+        name: models_1.SharedListNameSchema,
+    });
+})(DeleteSharedListCommand || (exports.DeleteSharedListCommand = DeleteSharedListCommand = {}));

package/build/frontend/commands/node-plugins/shared-lists/get-shared-list.command.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetSharedListCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../../api");
+const constants_1 = require("../../../constants");
+const models_1 = require("../../../models");
+var GetSharedListCommand;
+(function (GetSharedListCommand) {
+    GetSharedListCommand.url = api_1.REST_API.NODE_PLUGINS.SHARED_LISTS.GET;
+    GetSharedListCommand.TSQ_url = GetSharedListCommand.url(':name');
+    GetSharedListCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.NODE_PLUGINS_ROUTES.SHARED_LISTS.GET(':name'), 'get', 'Get Shared List by name', { scope: 'shared-lists-get', kind: 'read' });
+    GetSharedListCommand.RequestParamSchema = zod_1.z.object({
+        name: models_1.SharedListNameSchema,
+    });
+    GetSharedListCommand.ResponseSchema = zod_1.z.object({
+        response: models_1.SharedListsSchema,
+    });
+})(GetSharedListCommand || (exports.GetSharedListCommand = GetSharedListCommand = {}));

package/build/frontend/commands/node-plugins/shared-lists/get-shared-lists.command.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetSharedListsCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../../api");
+const constants_1 = require("../../../constants");
+const models_1 = require("../../../models");
+var GetSharedListsCommand;
+(function (GetSharedListsCommand) {
+    GetSharedListsCommand.url = api_1.REST_API.NODE_PLUGINS.SHARED_LISTS.GET_ALL;
+    GetSharedListsCommand.TSQ_url = GetSharedListsCommand.url;
+    GetSharedListsCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.NODE_PLUGINS_ROUTES.SHARED_LISTS.GET_ALL, 'get', 'Get Shared Lists (Preview)', { scope: 'shared-lists-list', kind: 'read' }, 'Returns only the name, type and item count of every shared list. Use "Get Shared List by name" to fetch the items themselves.');
+    GetSharedListsCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.object({
+            total: zod_1.z.number(),
+            sharedLists: zod_1.z.array(models_1.SharedListPreviewSchema),
+        }),
+    });
+})(GetSharedListsCommand || (exports.GetSharedListsCommand = GetSharedListsCommand = {}));

package/build/frontend/commands/node-plugins/shared-lists/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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("./create-shared-list.command"), exports);
+__exportStar(require("./delete-shared-list.command"), exports);
+__exportStar(require("./get-shared-list.command"), exports);
+__exportStar(require("./get-shared-lists.command"), exports);
+__exportStar(require("./sync-shared-list.command"), exports);
+__exportStar(require("./update-shared-list.command"), exports);