@remnawave/node-contract 2.7.0 → 2.9.1

package/build/commands/xray/start.command.d.ts

@@ -3,6 +3,13 @@ export declare namespace StartXrayCommand {
     const url: "/node/xray/start";
     const RequestSchema: z.ZodObject<{
         internals: z.ZodObject<{
+            metadata: z.ZodOptional<z.ZodObject<{
+                name: z.ZodString;
+                uuid: z.ZodString;
+                id: z.ZodNumber;
+                tags: z.ZodArray<z.ZodString>;
+                countryCode: z.ZodString;
+            }, z.core.$strip>>;
             forceRestart: z.ZodDefault<z.ZodBoolean>;
             hashes: z.ZodObject<{
                 emptyConfig: z.ZodString;
@@ -10,79 +17,11 @@ export declare namespace StartXrayCommand {
                     usersCount: z.ZodNumber;
                     hash: z.ZodString;
                     tag: z.ZodString;
-                }, "strip", z.ZodTypeAny, {
-                    tag: string;
-                    usersCount: number;
-                    hash: string;
-                }, {
-                    tag: string;
-                    usersCount: number;
-                    hash: string;
-                }>, "many">;
-            }, "strip", z.ZodTypeAny, {
-                inbounds: {
-                    tag: string;
-                    usersCount: number;
-                    hash: string;
-                }[];
-                emptyConfig: string;
-            }, {
-                inbounds: {
-                    tag: string;
-                    usersCount: number;
-                    hash: string;
-                }[];
-                emptyConfig: string;
-            }>;
-        }, "strip", z.ZodTypeAny, {
-            forceRestart: boolean;
-            hashes: {
-                inbounds: {
-                    tag: string;
-                    usersCount: number;
-                    hash: string;
-                }[];
-                emptyConfig: string;
-            };
-        }, {
-            hashes: {
-                inbounds: {
-                    tag: string;
-                    usersCount: number;
-                    hash: string;
-                }[];
-                emptyConfig: string;
-            };
-            forceRestart?: boolean | undefined;
-        }>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
         xrayConfig: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    }, "strip", z.ZodTypeAny, {
-        internals: {
-            forceRestart: boolean;
-            hashes: {
-                inbounds: {
-                    tag: string;
-                    usersCount: number;
-                    hash: string;
-                }[];
-                emptyConfig: string;
-            };
-        };
-        xrayConfig: Record<string, unknown>;
-    }, {
-        internals: {
-            hashes: {
-                inbounds: {
-                    tag: string;
-                    usersCount: number;
-                    hash: string;
-                }[];
-                emptyConfig: string;
-            };
-            forceRestart?: boolean | undefined;
-        };
-        xrayConfig: Record<string, unknown>;
-    }>;
+    }, z.core.$strip>;
     type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{
         response: z.ZodObject<{
@@ -91,15 +30,11 @@ export declare namespace StartXrayCommand {
             error: z.ZodNullable<z.ZodString>;
             nodeInformation: z.ZodObject<{
                 version: z.ZodNullable<z.ZodString>;
-            }, "strip", z.ZodTypeAny, {
-                version: string | null;
-            }, {
-                version: string | null;
-            }>;
+            }, z.core.$strip>;
             system: z.ZodObject<{
                 info: z.ZodObject<{
                     arch: z.ZodString;
-                    cpus: z.ZodNumber;
+                    cpus: z.ZodInt;
                     cpuModel: z.ZodString;
                     memoryTotal: z.ZodNumber;
                     hostname: z.ZodString;
@@ -107,274 +42,24 @@ export declare namespace StartXrayCommand {
                     release: z.ZodString;
                     type: z.ZodString;
                     version: z.ZodString;
-                    networkInterfaces: z.ZodArray<z.ZodString, "many">;
-                }, "strip", z.ZodTypeAny, {
-                    type: string;
-                    arch: string;
-                    cpus: number;
-                    cpuModel: string;
-                    memoryTotal: number;
-                    hostname: string;
-                    platform: string;
-                    release: string;
-                    version: string;
-                    networkInterfaces: string[];
-                }, {
-                    type: string;
-                    arch: string;
-                    cpus: number;
-                    cpuModel: string;
-                    memoryTotal: number;
-                    hostname: string;
-                    platform: string;
-                    release: string;
-                    version: string;
-                    networkInterfaces: string[];
-                }>;
+                    networkInterfaces: z.ZodArray<z.ZodString>;
+                }, z.core.$strip>;
                 stats: z.ZodObject<{
                     memoryFree: z.ZodNumber;
                     memoryUsed: z.ZodNumber;
                     uptime: z.ZodNumber;
-                    loadAvg: z.ZodArray<z.ZodNumber, "many">;
+                    loadAvg: z.ZodArray<z.ZodNumber>;
                     interface: z.ZodNullable<z.ZodObject<{
                         interface: z.ZodString;
                         rxBytesPerSec: z.ZodNumber;
                         txBytesPerSec: z.ZodNumber;
                         rxTotal: z.ZodNumber;
                         txTotal: z.ZodNumber;
-                    }, "strip", z.ZodTypeAny, {
-                        interface: string;
-                        rxBytesPerSec: number;
-                        txBytesPerSec: number;
-                        rxTotal: number;
-                        txTotal: number;
-                    }, {
-                        interface: string;
-                        rxBytesPerSec: number;
-                        txBytesPerSec: number;
-                        rxTotal: number;
-                        txTotal: number;
-                    }>>;
-                }, "strip", z.ZodTypeAny, {
-                    interface: {
-                        interface: string;
-                        rxBytesPerSec: number;
-                        txBytesPerSec: number;
-                        rxTotal: number;
-                        txTotal: number;
-                    } | null;
-                    memoryFree: number;
-                    memoryUsed: number;
-                    uptime: number;
-                    loadAvg: number[];
-                }, {
-                    interface: {
-                        interface: string;
-                        rxBytesPerSec: number;
-                        txBytesPerSec: number;
-                        rxTotal: number;
-                        txTotal: number;
-                    } | null;
-                    memoryFree: number;
-                    memoryUsed: number;
-                    uptime: number;
-                    loadAvg: number[];
-                }>;
-            }, "strip", z.ZodTypeAny, {
-                stats: {
-                    interface: {
-                        interface: string;
-                        rxBytesPerSec: number;
-                        txBytesPerSec: number;
-                        rxTotal: number;
-                        txTotal: number;
-                    } | null;
-                    memoryFree: number;
-                    memoryUsed: number;
-                    uptime: number;
-                    loadAvg: number[];
-                };
-                info: {
-                    type: string;
-                    arch: string;
-                    cpus: number;
-                    cpuModel: string;
-                    memoryTotal: number;
-                    hostname: string;
-                    platform: string;
-                    release: string;
-                    version: string;
-                    networkInterfaces: string[];
-                };
-            }, {
-                stats: {
-                    interface: {
-                        interface: string;
-                        rxBytesPerSec: number;
-                        txBytesPerSec: number;
-                        rxTotal: number;
-                        txTotal: number;
-                    } | null;
-                    memoryFree: number;
-                    memoryUsed: number;
-                    uptime: number;
-                    loadAvg: number[];
-                };
-                info: {
-                    type: string;
-                    arch: string;
-                    cpus: number;
-                    cpuModel: string;
-                    memoryTotal: number;
-                    hostname: string;
-                    platform: string;
-                    release: string;
-                    version: string;
-                    networkInterfaces: string[];
-                };
-            }>;
-        }, "strip", z.ZodTypeAny, {
-            error: string | null;
-            version: string | null;
-            system: {
-                stats: {
-                    interface: {
-                        interface: string;
-                        rxBytesPerSec: number;
-                        txBytesPerSec: number;
-                        rxTotal: number;
-                        txTotal: number;
-                    } | null;
-                    memoryFree: number;
-                    memoryUsed: number;
-                    uptime: number;
-                    loadAvg: number[];
-                };
-                info: {
-                    type: string;
-                    arch: string;
-                    cpus: number;
-                    cpuModel: string;
-                    memoryTotal: number;
-                    hostname: string;
-                    platform: string;
-                    release: string;
-                    version: string;
-                    networkInterfaces: string[];
-                };
-            };
-            isStarted: boolean;
-            nodeInformation: {
-                version: string | null;
-            };
-        }, {
-            error: string | null;
-            version: string | null;
-            system: {
-                stats: {
-                    interface: {
-                        interface: string;
-                        rxBytesPerSec: number;
-                        txBytesPerSec: number;
-                        rxTotal: number;
-                        txTotal: number;
-                    } | null;
-                    memoryFree: number;
-                    memoryUsed: number;
-                    uptime: number;
-                    loadAvg: number[];
-                };
-                info: {
-                    type: string;
-                    arch: string;
-                    cpus: number;
-                    cpuModel: string;
-                    memoryTotal: number;
-                    hostname: string;
-                    platform: string;
-                    release: string;
-                    version: string;
-                    networkInterfaces: string[];
-                };
-            };
-            isStarted: boolean;
-            nodeInformation: {
-                version: string | null;
-            };
-        }>;
-    }, "strip", z.ZodTypeAny, {
-        response: {
-            error: string | null;
-            version: string | null;
-            system: {
-                stats: {
-                    interface: {
-                        interface: string;
-                        rxBytesPerSec: number;
-                        txBytesPerSec: number;
-                        rxTotal: number;
-                        txTotal: number;
-                    } | null;
-                    memoryFree: number;
-                    memoryUsed: number;
-                    uptime: number;
-                    loadAvg: number[];
-                };
-                info: {
-                    type: string;
-                    arch: string;
-                    cpus: number;
-                    cpuModel: string;
-                    memoryTotal: number;
-                    hostname: string;
-                    platform: string;
-                    release: string;
-                    version: string;
-                    networkInterfaces: string[];
-                };
-            };
-            isStarted: boolean;
-            nodeInformation: {
-                version: string | null;
-            };
-        };
-    }, {
-        response: {
-            error: string | null;
-            version: string | null;
-            system: {
-                stats: {
-                    interface: {
-                        interface: string;
-                        rxBytesPerSec: number;
-                        txBytesPerSec: number;
-                        rxTotal: number;
-                        txTotal: number;
-                    } | null;
-                    memoryFree: number;
-                    memoryUsed: number;
-                    uptime: number;
-                    loadAvg: number[];
-                };
-                info: {
-                    type: string;
-                    arch: string;
-                    cpus: number;
-                    cpuModel: string;
-                    memoryTotal: number;
-                    hostname: string;
-                    platform: string;
-                    release: string;
-                    version: string;
-                    networkInterfaces: string[];
-                };
-            };
-            isStarted: boolean;
-            nodeInformation: {
-                version: string | null;
-            };
-        };
-    }>;
+                    }, z.core.$strip>>;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
     type Response = z.infer<typeof ResponseSchema>;
 }
 //# sourceMappingURL=start.command.d.ts.map

package/build/commands/xray/start.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"start.command.d.ts","sourceRoot":"","sources":["../../../commands/xray/start.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,yBAAiB,gBAAgB,CAAC;IACvB,MAAM,GAAG,oBAAsB,CAAC;IAChC,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAexB,CAAC;IAEH,KAAY,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IAE7C,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAUzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}
+{"version":3,"file":"start.command.d.ts","sourceRoot":"","sources":["../../../commands/xray/start.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,yBAAiB,gBAAgB,CAAC;IACvB,MAAM,GAAG,oBAAsB,CAAC;IAChC,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;qBAgBxB,CAAC;IAEH,KAAY,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IAE7C,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAUzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/commands/xray/start.command.js

@@ -2,13 +2,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StartXrayCommand = void 0;
 const zod_1 = require("zod");
-const models_1 = require("../../models");
 const api_1 = require("../../api");
+const models_1 = require("../../models");
 var StartXrayCommand;
 (function (StartXrayCommand) {
     StartXrayCommand.url = api_1.REST_API.XRAY.START;
     StartXrayCommand.RequestSchema = zod_1.z.object({
         internals: zod_1.z.object({
+            metadata: models_1.NodeMetadataSchema.optional(),
             forceRestart: zod_1.z.boolean().default(false),
             hashes: zod_1.z.object({
                 emptyConfig: zod_1.z.string(),
@@ -19,7 +20,7 @@ var StartXrayCommand;
                 })),
             }),
         }),
-        xrayConfig: zod_1.z.record(zod_1.z.unknown()),
+        xrayConfig: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()),
     });
     StartXrayCommand.ResponseSchema = zod_1.z.object({
         response: zod_1.z.object({

package/build/commands/xray/stop.command.d.ts

@@ -4,20 +4,8 @@ export declare namespace StopXrayCommand {
     const ResponseSchema: z.ZodObject<{
         response: z.ZodObject<{
             isStopped: z.ZodBoolean;
-        }, "strip", z.ZodTypeAny, {
-            isStopped: boolean;
-        }, {
-            isStopped: boolean;
-        }>;
-    }, "strip", z.ZodTypeAny, {
-        response: {
-            isStopped: boolean;
-        };
-    }, {
-        response: {
-            isStopped: boolean;
-        };
-    }>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
     type Response = z.infer<typeof ResponseSchema>;
 }
 //# sourceMappingURL=stop.command.d.ts.map

package/build/commands/xray/stop.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stop.command.d.ts","sourceRoot":"","sources":["../../../commands/xray/stop.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,yBAAiB,eAAe,CAAC;IACtB,MAAM,GAAG,mBAAqB,CAAC;IAE/B,MAAM,cAAc;;;;;;;;;;;;;;;;MAIzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}
+{"version":3,"file":"stop.command.d.ts","sourceRoot":"","sources":["../../../commands/xray/stop.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,yBAAiB,eAAe,CAAC;IACtB,MAAM,GAAG,mBAAqB,CAAC;IAE/B,MAAM,cAAc;;;;qBAIzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/constants/xray/stats.d.ts

@@ -24,35 +24,12 @@ export declare const XRAY_DEFAULT_API_MODEL: {
         readonly tag: "REMNAWAVE_API";
     };
 };
-export declare const XRAY_API_INBOUND_MODEL: ({ port, caCertPem, serverCertPem, serverKeyPem, }: {
-    port: number;
-    caCertPem: string;
-    serverCertPem: string;
-    serverKeyPem: string;
+export declare const XRAY_API_INBOUND_MODEL: ({ xtlsApiSocketPath }: {
+    xtlsApiSocketPath: string;
 }) => {
     readonly tag: "REMNAWAVE_API_INBOUND";
-    readonly port: number;
-    readonly listen: "127.0.0.1";
-    readonly protocol: "dokodemo-door";
-    readonly settings: {
-        readonly address: "127.0.0.1";
-    };
-    readonly streamSettings: {
-        readonly security: "tls";
-        readonly tlsSettings: {
-            readonly alpn: readonly ["h2"];
-            readonly serverName: "internal.remnawave.local";
-            readonly disableSystemRoot: true;
-            readonly rejectUnknownSni: true;
-            readonly certificates: readonly [{
-                readonly certificate: string[];
-                readonly key: string[];
-            }, {
-                readonly usage: "verify";
-                readonly certificate: string[];
-            }];
-        };
-    };
+    readonly listen: `@${string}`;
+    readonly protocol: "tunnel";
 };
 export declare const XRAY_ROUTING_RULES_MODEL: {
     readonly inboundTag: readonly ["REMNAWAVE_API_INBOUND"];

package/build/constants/xray/stats.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stats.d.ts","sourceRoot":"","sources":["../../../constants/xray/stats.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;CAgB5B,CAAC;AAEX,eAAO,MAAM,wBAAwB;;CAE3B,CAAC;AAEX,eAAO,MAAM,sBAAsB;;;;;CAKzB,CAAC;AAEX,eAAO,MAAM,sBAAsB,GAAI,mDAKpC;IACC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;CACxB;;;;;;;;;;;;;;;;;;;;;;;;CAqCc,CAAC;AAEhB,eAAO,MAAM,wBAAwB;;;CAG3B,CAAC;AAEX,eAAO,MAAM,wCAAwC,GAAI,iBAEtD;IACC,UAAU,EAAE,MAAM,CAAC;CACtB;;;;;;;CAOC,CAAC;AAEH,eAAO,MAAM,mCAAmC;;;CAGtC,CAAC;AAEX,eAAO,MAAM,iCAAiC,yBAAyB,CAAC"}
+{"version":3,"file":"stats.d.ts","sourceRoot":"","sources":["../../../constants/xray/stats.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;CAgB5B,CAAC;AAEX,eAAO,MAAM,wBAAwB;;CAE3B,CAAC;AAEX,eAAO,MAAM,sBAAsB;;;;;CAKzB,CAAC;AAEX,eAAO,MAAM,sBAAsB,GAAI,uBAAuB;IAAE,iBAAiB,EAAE,MAAM,CAAA;CAAE;;;;CAK5E,CAAC;AAEhB,eAAO,MAAM,wBAAwB;;;CAG3B,CAAC;AAEX,eAAO,MAAM,wCAAwC,GAAI,iBAEtD;IACC,UAAU,EAAE,MAAM,CAAC;CACtB;;;;;;;CAOC,CAAC;AAEH,eAAO,MAAM,mCAAmC;;;CAGtC,CAAC;AAEX,eAAO,MAAM,iCAAiC,yBAAyB,CAAC"}

package/build/constants/xray/stats.js

@@ -27,42 +27,10 @@ exports.XRAY_DEFAULT_API_MODEL = {
         tag: 'REMNAWAVE_API',
     },
 };
-const XRAY_API_INBOUND_MODEL = ({ port, caCertPem, serverCertPem, serverKeyPem, }) => ({
+const XRAY_API_INBOUND_MODEL = ({ xtlsApiSocketPath }) => ({
     tag: 'REMNAWAVE_API_INBOUND',
-    port: port,
-    listen: '127.0.0.1',
-    protocol: 'dokodemo-door',
-    settings: {
-        address: '127.0.0.1',
-    },
-    streamSettings: {
-        security: 'tls',
-        tlsSettings: {
-            alpn: ['h2'],
-            serverName: 'internal.remnawave.local',
-            disableSystemRoot: true,
-            rejectUnknownSni: true,
-            certificates: [
-                {
-                    certificate: serverCertPem
-                        .replace(/\r\n/g, '\n')
-                        .split('\n')
-                        .filter((line) => line),
-                    key: serverKeyPem
-                        .replace(/\r\n/g, '\n')
-                        .split('\n')
-                        .filter((line) => line),
-                },
-                {
-                    usage: 'verify',
-                    certificate: caCertPem
-                        .replace(/\r\n/g, '\n')
-                        .split('\n')
-                        .filter((line) => line),
-                },
-            ],
-        },
-    },
+    listen: `@${xtlsApiSocketPath}`,
+    protocol: 'tunnel',
 });
 exports.XRAY_API_INBOUND_MODEL = XRAY_API_INBOUND_MODEL;
 exports.XRAY_ROUTING_RULES_MODEL = {

package/build/models/index.d.ts

@@ -1,4 +1,5 @@
 export * from './node-system.schema';
 export * from './torrent-blocker.report.schema';
 export * from './xray-webhook.schema';
+export * from './node-metadata.schema';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../models/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,iCAAiC,CAAC;AAChD,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../models/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,iCAAiC,CAAC;AAChD,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC"}

package/build/models/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./node-system.schema"), exports);
 __exportStar(require("./torrent-blocker.report.schema"), exports);
 __exportStar(require("./xray-webhook.schema"), exports);
+__exportStar(require("./node-metadata.schema"), exports);

package/build/models/node-metadata.schema.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const NodeMetadataSchema: z.ZodObject<{
+    name: z.ZodString;
+    uuid: z.ZodString;
+    id: z.ZodNumber;
+    tags: z.ZodArray<z.ZodString>;
+    countryCode: z.ZodString;
+}, z.core.$strip>;
+export type TNodeMetadata = z.infer<typeof NodeMetadataSchema>;
+//# sourceMappingURL=node-metadata.schema.d.ts.map

package/build/models/node-metadata.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-metadata.schema.d.ts","sourceRoot":"","sources":["../../models/node-metadata.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;;;;iBAM7B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC"}

package/build/models/node-metadata.schema.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeMetadataSchema = void 0;
+const zod_1 = require("zod");
+exports.NodeMetadataSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    uuid: zod_1.z.string(),
+    id: zod_1.z.number(),
+    tags: zod_1.z.array(zod_1.z.string()),
+    countryCode: zod_1.z.string(),
+});