@remnawave/backend-contract 3.2.3 → 3.3.0

package/build/backend/models/host-mapper/host-mapper.schema.js

@@ -0,0 +1,262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostMapperSchema = exports.HostMapperOperationsSchema = exports.Base64HostMapperOperationsSchema = exports.MihomoHostMapperOperationsSchema = exports.XrayJsonHostMapperOperationsSchema = void 0;
+const zod_1 = require("zod");
+const buildFromSchema = () => zod_1.z
+    .string()
+    .min(1)
+    .max(512)
+    .meta({
+    title: 'Source path',
+    markdownDescription: [
+        'Dot-separated path inside the **raw inbound** of the config profile this host belongs to. Array items are addressed by index.',
+        '',
+        '> If the path resolves to nothing, the operation is skipped and the target key is **not** created.',
+    ].join('\n'),
+    examples: [
+        'streamSettings.tlsSettings.cipherSuites',
+        'streamSettings.tlsSettings.alpn',
+        'streamSettings.realitySettings.serverNames.0',
+    ],
+});
+const buildToSchema = (client) => zod_1.z
+    .string()
+    .min(1)
+    .max(512)
+    .meta({
+    title: 'Target path',
+    markdownDescription: [
+        `Dot-separated path inside ${client.target}, counted from its root.`,
+        '',
+        'Missing objects along the path are created. Array items are addressed by index, and keys with dashes are written as is (`ip-version`).',
+        '',
+        '> A path running through a value that is not an object – for example `path.foo`, where `path` holds a string – is refused, so an existing value is never destroyed.',
+    ].join('\n'),
+    examples: client.examples,
+});
+const buildOperationsSchema = (client) => zod_1.z
+    .discriminatedUnion('op', [
+    zod_1.z
+        .object({
+        op: zod_1.z.literal('copy').meta({
+            title: 'Copy',
+            markdownDescription: 'Take a value from the raw inbound.',
+        }),
+        from: buildFromSchema(),
+        to: buildToSchema(client),
+    })
+        .meta({
+        title: 'Copy from the inbound',
+        markdownDescription: [
+            'Reads a value from the raw inbound and writes it into the generated config.',
+            '',
+            '```json',
+            JSON.stringify({ op: 'copy', ...client.copySnippet }, null, 2),
+            '```',
+        ].join('\n'),
+        defaultSnippets: [
+            {
+                label: 'copy',
+                description: 'Copy a value from the raw inbound',
+                body: { op: 'copy', from: '$1', to: '$2' },
+            },
+        ],
+    }),
+    zod_1.z
+        .object({
+        op: zod_1.z.literal('set').meta({
+            title: 'Set',
+            markdownDescription: 'Write a fixed value.',
+        }),
+        value: zod_1.z
+            .union([
+            zod_1.z.string(),
+            zod_1.z.number(),
+            zod_1.z.boolean(),
+            zod_1.z.array(zod_1.z.json()),
+            zod_1.z.record(zod_1.z.string(), zod_1.z.json()),
+        ])
+            .meta({
+            title: 'Value',
+            markdownDescription: 'The value to write. Strings, numbers, booleans, arrays and objects are allowed.',
+        }),
+        to: buildToSchema(client),
+    })
+        .meta({
+        title: 'Set a fixed value',
+        markdownDescription: [
+            'Writes a literal value into the generated config, creating the key if it is missing.',
+            '',
+            '```json',
+            JSON.stringify({ op: 'set', ...client.setSnippet }, null, 2),
+            '```',
+        ].join('\n'),
+        defaultSnippets: [
+            {
+                label: 'set',
+                description: 'Write a fixed value',
+                body: { op: 'set', to: '$1', value: '$2' },
+            },
+        ],
+    }),
+    zod_1.z
+        .object({
+        op: zod_1.z.literal('unset').meta({
+            title: 'Unset',
+            markdownDescription: 'Remove a field.',
+        }),
+        to: buildToSchema(client),
+    })
+        .meta({
+        title: 'Remove a field',
+        markdownDescription: [
+            'Removes a field the generator produced by itself.',
+            '',
+            '```json',
+            JSON.stringify({ op: 'unset', ...client.unsetSnippet }, null, 2),
+            '```',
+            '',
+            '> Only the field itself is removed. A parent object left empty stays in the config as `{}`.',
+        ].join('\n'),
+        defaultSnippets: [
+            {
+                label: 'unset',
+                description: 'Remove a field',
+                body: { op: 'unset', to: '$1' },
+            },
+        ],
+    }),
+])
+    .meta({
+    title: 'Operation',
+    markdownDescription: [
+        'Operations run one after another, in the order they are listed.',
+        '',
+        'A later operation sees what the previous ones wrote, so an `unset` can remove a key an earlier `set` added.',
+    ].join('\n'),
+});
+exports.XrayJsonHostMapperOperationsSchema = buildOperationsSchema({
+    target: 'the generated **outbound**',
+    examples: [
+        'streamSettings.tlsSettings.enableSessionResumption',
+        'streamSettings.tlsSettings.cipherSuites',
+    ],
+    copySnippet: {
+        from: 'streamSettings.tlsSettings.cipherSuites',
+        to: 'streamSettings.tlsSettings.cipherSuites',
+    },
+    setSnippet: { to: 'streamSettings.tlsSettings.enableSessionResumption', value: true },
+    unsetSnippet: { to: 'mux' },
+});
+exports.MihomoHostMapperOperationsSchema = buildOperationsSchema({
+    target: 'the generated **proxy node**',
+    examples: ['ip-version', 'client-fingerprint', 'tfo', 'reality-opts.support-x25519mlkem768'],
+    copySnippet: { from: 'streamSettings.realitySettings.serverNames.0', to: 'servername' },
+    setSnippet: { to: 'reality-opts.support-x25519mlkem768', value: true },
+    unsetSnippet: { to: 'smux' },
+});
+exports.Base64HostMapperOperationsSchema = buildOperationsSchema({
+    target: 'the query string of the generated **share link**',
+    examples: [
+        'alpn',
+        'authority',
+        'cs',
+        'encryption',
+        'extra',
+        'flow',
+        'fm',
+        'fp',
+        'headerType',
+        'heartbeatPeriod',
+        'host',
+        'mode',
+        'mtu',
+        'obfs',
+        'obfs-password',
+        'path',
+        'pbk',
+        'pcs',
+        'pinSHA256',
+        'pqv',
+        'security',
+        'serviceName',
+        'sid',
+        'sni',
+        'spx',
+        'tti',
+        'type',
+        'vcn',
+    ],
+    copySnippet: { from: 'streamSettings.realitySettings.serverNames.0', to: 'sni' },
+    setSnippet: { to: 'fp', value: 'chrome' },
+    unsetSnippet: { to: 'fm' },
+});
+exports.HostMapperOperationsSchema = exports.XrayJsonHostMapperOperationsSchema;
+exports.HostMapperSchema = zod_1.z
+    .object({
+    xrayJson: zod_1.z
+        .array(exports.XrayJsonHostMapperOperationsSchema)
+        .optional()
+        .meta({
+        title: 'Xray JSON',
+        markdownDescription: [
+            'Operations applied to the **outbound** generated for this host in the Xray JSON subscription. Paths are counted from the root of the outbound.',
+            '',
+            '```json',
+            JSON.stringify([
+                {
+                    op: 'copy',
+                    from: 'streamSettings.tlsSettings.cipherSuites',
+                    to: 'streamSettings.tlsSettings.cipherSuites',
+                },
+                { op: 'unset', to: 'mux' },
+            ], null, 2),
+            '```',
+        ].join('\n'),
+    }),
+    mihomo: zod_1.z
+        .array(exports.MihomoHostMapperOperationsSchema)
+        .optional()
+        .meta({
+        title: 'Mihomo',
+        markdownDescription: [
+            'Operations applied to the **proxy node** generated for this host in the Mihomo subscription.',
+            '',
+            'Paths are counted from the root of the node, where Mihomo keys are written in kebab-case.',
+            '',
+            '```json',
+            JSON.stringify([{ op: 'set', to: 'ip-version', value: 'ipv4' }], null, 2),
+            '```',
+        ].join('\n'),
+    }),
+    base64: zod_1.z
+        .array(exports.Base64HostMapperOperationsSchema)
+        .optional()
+        .meta({
+        title: 'Base64',
+        markdownDescription: [
+            'Operations applied to the **query string** of the share link generated for this host in the Base64 subscription.',
+            '',
+            '`to` is a plain query parameter name, not a path – dots carry no meaning here.',
+            '',
+            '```json',
+            JSON.stringify([
+                { op: 'set', to: 'fp', value: 'chrome' },
+                { op: 'unset', to: 'fm' },
+            ], null, 2),
+            '```',
+        ].join('\n'),
+    }),
+})
+    .meta({
+    title: 'Host Mapper',
+    markdownDescription: [
+        'Rewrites the config generated for this host, per client type.',
+        '',
+        'Operations run **after** the generator has finished, so they can change or remove anything it produced.',
+        '',
+        'The source for `copy` is always the raw inbound of the config profile this host belongs to.',
+        '',
+        '> `to` is never checked against the target client. A misspelled key is written exactly like a real one.',
+    ].join('\n'),
+});

package/build/backend/models/host-mapper/index.d.ts

@@ -0,0 +1,2 @@
+export * from './host-mapper.schema';
+//# sourceMappingURL=index.d.ts.map

package/build/backend/models/host-mapper/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../models/host-mapper/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC"}

package/build/backend/models/host-mapper/index.js

@@ -0,0 +1,17 @@
+"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("./host-mapper.schema"), exports);

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

@@ -59,5 +59,43 @@ export declare const HostsSchema: z.ZodObject<{
         readonly CLASH: "CLASH";
         readonly SINGBOX: "SINGBOX";
     }>>;
+    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>;
 //# 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuCtB,CAAC"}
+{"version":3,"file":"hosts.schema.d.ts","sourceRoot":"","sources":["../../../models/hosts.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwCtB,CAAC"}

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

@@ -4,6 +4,7 @@ exports.HostsSchema = void 0;
 const zod_1 = require("zod");
 const constants_1 = require("../constants");
 const hosts_1 = require("../constants/hosts");
+const host_mapper_1 = require("./host-mapper");
 exports.HostsSchema = zod_1.z.object({
     uuid: zod_1.z.uuid(),
     viewPosition: zod_1.z.int(),
@@ -40,4 +41,5 @@ exports.HostsSchema = zod_1.z.object({
     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)),
+    mapper: host_mapper_1.HostMapperSchema,
 });

package/build/backend/models/index.d.ts

@@ -36,4 +36,5 @@ export * from './users.schema';
 export * from './webhook';
 export * from './xray-json-advanced';
 export * from './path-params.schema';
+export * from './host-mapper';
 //# sourceMappingURL=index.d.ts.map

package/build/backend/models/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../models/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oBAAoB,CAAC;AACnC,cAAc,kCAAkC,CAAC;AACjD,cAAc,yBAAyB,CAAC;AACxC,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uCAAuC,CAAC;AACtD,cAAc,uCAAuC,CAAC;AACtD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kCAAkC,CAAC;AACjD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uCAAuC,CAAC;AACtD,cAAc,yBAAyB,CAAC;AACxC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kBAAkB,CAAC;AACjC,cAAc,iCAAiC,CAAC;AAChD,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../models/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,eAAe,CAAC;AAC9B,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oBAAoB,CAAC;AACnC,cAAc,kCAAkC,CAAC;AACjD,cAAc,yBAAyB,CAAC;AACxC,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uCAAuC,CAAC;AACtD,cAAc,uCAAuC,CAAC;AACtD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,sBAAsB,CAAC;AACrC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kCAAkC,CAAC;AACjD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uCAAuC,CAAC;AACtD,cAAc,yBAAyB,CAAC;AACxC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kBAAkB,CAAC;AACjC,cAAc,iCAAiC,CAAC;AAChD,cAAc,gBAAgB,CAAC;AAC/B,cAAc,WAAW,CAAC;AAC1B,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC"}

package/build/backend/models/index.js

@@ -52,3 +52,4 @@ __exportStar(require("./users.schema"), exports);
 __exportStar(require("./webhook"), exports);
 __exportStar(require("./xray-json-advanced"), exports);
 __exportStar(require("./path-params.schema"), exports);
+__exportStar(require("./host-mapper"), exports);

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

@@ -370,6 +370,44 @@ export declare const ResolvedProxyConfigSchema: z.ZodObject<{
         }>>;
         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;

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;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;;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2CpC,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,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4CpC,CAAC"}

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

@@ -3,6 +3,7 @@ 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;
 const zod_1 = require("zod");
 const constants_1 = require("../constants");
+const host_mapper_1 = require("./host-mapper");
 exports.VlessProtocolOptionsSchema = zod_1.z.object({
     encryption: zod_1.z.string(),
     id: zod_1.z.string(),
@@ -218,6 +219,7 @@ exports.ResolvedProxyConfigSchema = zod_1.z.object({
         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()),
+        mapper: host_mapper_1.HostMapperSchema,
     }),
     metadata: exports.ProxyEntryMetadataSchema,
 });

package/build/frontend/commands/hosts/create.command.js

@@ -4,6 +4,7 @@ exports.CreateHostCommand = void 0;
 const zod_1 = require("zod");
 const api_1 = require("../../api");
 const constants_1 = require("../../constants");
+const models_1 = require("../../models");
 const host_response_1 = require("./host.response");
 var CreateHostCommand;
 (function (CreateHostCommand) {
@@ -53,6 +54,7 @@ var CreateHostCommand;
         excludeFromSubscriptionTypes: zod_1.z
             .optional(zod_1.z.array(zod_1.z.enum(constants_1.SUBSCRIPTION_TEMPLATE_TYPE)))
             .describe('Optional. Subscription types from which the host will be excluded from.'),
+        mapper: models_1.HostMapperSchema.optional(),
     });
     CreateHostCommand.ResponseSchema = host_response_1.HostResponseSchema;
 })(CreateHostCommand || (exports.CreateHostCommand = CreateHostCommand = {}));

package/build/frontend/commands/hosts/update.command.js

@@ -58,6 +58,7 @@ var UpdateHostCommand;
         excludeFromSubscriptionTypes: zod_1.z
             .optional(zod_1.z.array(zod_1.z.enum(constants_1.SUBSCRIPTION_TEMPLATE_TYPE)))
             .describe('Optional. Subscription types from which the host will be excluded from.'),
+        mapper: models_1.HostMapperSchema.optional(),
     });
     UpdateHostCommand.ResponseSchema = host_response_1.HostResponseSchema;
 })(UpdateHostCommand || (exports.UpdateHostCommand = UpdateHostCommand = {}));