@remnawave/node-contract 0.5.9 → 0.6.1

package/build/api/controllers/stats.d.ts

@@ -7,5 +7,6 @@ export declare const STATS_ROUTES: {
     readonly GET_OUTBOUND_STATS: "get-outbound-stats";
     readonly GET_ALL_OUTBOUNDS_STATS: "get-all-outbounds-stats";
     readonly GET_ALL_INBOUNDS_STATS: "get-all-inbounds-stats";
+    readonly GET_COMBINED_STATS: "get-combined-stats";
 };
 //# sourceMappingURL=stats.d.ts.map

package/build/api/controllers/stats.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stats.d.ts","sourceRoot":"","sources":["../../../api/controllers/stats.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,EAAG,OAAgB,CAAC;AAEjD,eAAO,MAAM,YAAY;;;;;;;;CAUf,CAAC"}
+{"version":3,"file":"stats.d.ts","sourceRoot":"","sources":["../../../api/controllers/stats.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gBAAgB,EAAG,OAAgB,CAAC;AAEjD,eAAO,MAAM,YAAY;;;;;;;;;CAYf,CAAC"}

package/build/api/controllers/stats.js

@@ -10,4 +10,5 @@ exports.STATS_ROUTES = {
     GET_OUTBOUND_STATS: 'get-outbound-stats',
     GET_ALL_OUTBOUNDS_STATS: 'get-all-outbounds-stats',
     GET_ALL_INBOUNDS_STATS: 'get-all-inbounds-stats',
+    GET_COMBINED_STATS: 'get-combined-stats',
 };

package/build/api/routes.d.ts

@@ -14,6 +14,7 @@ export declare const REST_API: {
         readonly GET_OUTBOUND_STATS: "/node/stats/get-outbound-stats";
         readonly GET_ALL_OUTBOUNDS_STATS: "/node/stats/get-all-outbounds-stats";
         readonly GET_ALL_INBOUNDS_STATS: "/node/stats/get-all-inbounds-stats";
+        readonly GET_COMBINED_STATS: "/node/stats/get-combined-stats";
     };
     readonly HANDLER: {
         readonly ADD_USER: "/node/handler/add-user";

package/build/api/routes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../api/routes.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,IAAI,EAAG,OAAgB,CAAC;AAErC,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BX,CAAC"}
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../api/routes.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,IAAI,EAAG,OAAgB,CAAC;AAErC,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BX,CAAC"}

package/build/api/routes.js

@@ -51,6 +51,7 @@ exports.REST_API = {
         GET_OUTBOUND_STATS: `${exports.ROOT}/${CONTROLLERS.STATS_CONTROLLER}/${CONTROLLERS.STATS_ROUTES.GET_OUTBOUND_STATS}`,
         GET_ALL_OUTBOUNDS_STATS: `${exports.ROOT}/${CONTROLLERS.STATS_CONTROLLER}/${CONTROLLERS.STATS_ROUTES.GET_ALL_OUTBOUNDS_STATS}`,
         GET_ALL_INBOUNDS_STATS: `${exports.ROOT}/${CONTROLLERS.STATS_CONTROLLER}/${CONTROLLERS.STATS_ROUTES.GET_ALL_INBOUNDS_STATS}`,
+        GET_COMBINED_STATS: `${exports.ROOT}/${CONTROLLERS.STATS_CONTROLLER}/${CONTROLLERS.STATS_ROUTES.GET_COMBINED_STATS}`,
     },
     HANDLER: {
         ADD_USER: `${exports.ROOT}/${CONTROLLERS.HANDLER_CONTROLLER}/${CONTROLLERS.HANDLER_ROUTES.ADD_USER}`,

package/build/commands/handler/add-user.command.d.ts

@@ -16,31 +16,26 @@ export declare namespace AddUserCommand {
             tag: z.ZodString;
             username: z.ZodString;
             password: z.ZodString;
-            level: z.ZodDefault<z.ZodNumber>;
         }, "strip", z.ZodTypeAny, {
             type: "trojan";
             tag: string;
             username: string;
             password: string;
-            level: number;
         }, {
             type: "trojan";
             tag: string;
             username: string;
             password: string;
-            level?: number | undefined;
         }>, z.ZodObject<{
             type: z.ZodLiteral<"vless">;
             tag: z.ZodString;
             username: z.ZodString;
             uuid: z.ZodString;
             flow: z.ZodEnum<["xtls-rprx-vision", ""]>;
-            level: z.ZodDefault<z.ZodNumber>;
         }, "strip", z.ZodTypeAny, {
             type: "vless";
             tag: string;
             username: string;
-            level: number;
             uuid: string;
             flow: "" | "xtls-rprx-vision";
         }, {
@@ -49,7 +44,6 @@ export declare namespace AddUserCommand {
             username: string;
             uuid: string;
             flow: "" | "xtls-rprx-vision";
-            level?: number | undefined;
         }>, z.ZodObject<{
             type: z.ZodLiteral<"shadowsocks">;
             tag: z.ZodString;
@@ -57,13 +51,11 @@ export declare namespace AddUserCommand {
             password: z.ZodString;
             cipherType: z.ZodNativeEnum<typeof CipherType>;
             ivCheck: z.ZodBoolean;
-            level: z.ZodDefault<z.ZodNumber>;
         }, "strip", z.ZodTypeAny, {
             type: "shadowsocks";
             tag: string;
             username: string;
             password: string;
-            level: number;
             cipherType: CipherType;
             ivCheck: boolean;
         }, {
@@ -73,67 +65,21 @@ export declare namespace AddUserCommand {
             password: string;
             cipherType: CipherType;
             ivCheck: boolean;
-            level?: number | undefined;
         }>, z.ZodObject<{
             type: z.ZodLiteral<"shadowsocks2022">;
             tag: z.ZodString;
             username: z.ZodString;
             key: z.ZodString;
-            level: z.ZodDefault<z.ZodNumber>;
         }, "strip", z.ZodTypeAny, {
             type: "shadowsocks2022";
             tag: string;
             username: string;
-            level: number;
             key: string;
         }, {
             type: "shadowsocks2022";
             tag: string;
             username: string;
             key: string;
-            level?: number | undefined;
-        }>, z.ZodObject<{
-            type: z.ZodLiteral<"socks">;
-            tag: z.ZodString;
-            username: z.ZodString;
-            socks_username: z.ZodString;
-            socks_password: z.ZodString;
-            level: z.ZodDefault<z.ZodNumber>;
-        }, "strip", z.ZodTypeAny, {
-            type: "socks";
-            tag: string;
-            username: string;
-            level: number;
-            socks_username: string;
-            socks_password: string;
-        }, {
-            type: "socks";
-            tag: string;
-            username: string;
-            socks_username: string;
-            socks_password: string;
-            level?: number | undefined;
-        }>, z.ZodObject<{
-            type: z.ZodLiteral<"http">;
-            tag: z.ZodString;
-            username: z.ZodString;
-            http_username: z.ZodString;
-            http_password: z.ZodString;
-            level: z.ZodDefault<z.ZodNumber>;
-        }, "strip", z.ZodTypeAny, {
-            type: "http";
-            tag: string;
-            username: string;
-            level: number;
-            http_username: string;
-            http_password: string;
-        }, {
-            type: "http";
-            tag: string;
-            username: string;
-            http_username: string;
-            http_password: string;
-            level?: number | undefined;
         }>]>, "many">;
         hashData: z.ZodObject<{
             vlessUuid: z.ZodString;
@@ -151,12 +97,10 @@ export declare namespace AddUserCommand {
             tag: string;
             username: string;
             password: string;
-            level: number;
         } | {
             type: "vless";
             tag: string;
             username: string;
-            level: number;
             uuid: string;
             flow: "" | "xtls-rprx-vision";
         } | {
@@ -164,29 +108,13 @@ export declare namespace AddUserCommand {
             tag: string;
             username: string;
             password: string;
-            level: number;
             cipherType: CipherType;
             ivCheck: boolean;
         } | {
             type: "shadowsocks2022";
             tag: string;
             username: string;
-            level: number;
             key: string;
-        } | {
-            type: "socks";
-            tag: string;
-            username: string;
-            level: number;
-            socks_username: string;
-            socks_password: string;
-        } | {
-            type: "http";
-            tag: string;
-            username: string;
-            level: number;
-            http_username: string;
-            http_password: string;
         })[];
         hashData: {
             vlessUuid: string;
@@ -198,14 +126,12 @@ export declare namespace AddUserCommand {
             tag: string;
             username: string;
             password: string;
-            level?: number | undefined;
         } | {
             type: "vless";
             tag: string;
             username: string;
             uuid: string;
             flow: "" | "xtls-rprx-vision";
-            level?: number | undefined;
         } | {
             type: "shadowsocks";
             tag: string;
@@ -213,27 +139,11 @@ export declare namespace AddUserCommand {
             password: string;
             cipherType: CipherType;
             ivCheck: boolean;
-            level?: number | undefined;
         } | {
             type: "shadowsocks2022";
             tag: string;
             username: string;
             key: string;
-            level?: number | undefined;
-        } | {
-            type: "socks";
-            tag: string;
-            username: string;
-            socks_username: string;
-            socks_password: string;
-            level?: number | undefined;
-        } | {
-            type: "http";
-            tag: string;
-            username: string;
-            http_username: string;
-            http_password: string;
-            level?: number | undefined;
         })[];
         hashData: {
             vlessUuid: string;

package/build/commands/handler/add-user.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"add-user.command.d.ts","sourceRoot":"","sources":["../../../commands/handler/add-user.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,oBAAY,UAAU;IAClB,WAAW,IAAI;IACf,WAAW,IAAI;IACf,iBAAiB,IAAI;IACrB,IAAI,IAAI;IACR,OAAO,IAAI;IACX,YAAY,KAAK;IACjB,kBAAkB,IAAI;CACzB;AAED,yBAAiB,cAAc,CAAC;IACrB,MAAM,GAAG,0BAA4B,CAAC;IAuDtC,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAexB,CAAC;IAEH,KAAY,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IAE7C,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;MAKzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}
+{"version":3,"file":"add-user.command.d.ts","sourceRoot":"","sources":["../../../commands/handler/add-user.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,oBAAY,UAAU;IAClB,WAAW,IAAI;IACf,WAAW,IAAI;IACf,iBAAiB,IAAI;IACrB,IAAI,IAAI;IACR,OAAO,IAAI;IACX,YAAY,KAAK;IACjB,kBAAkB,IAAI;CACzB;AAED,yBAAiB,cAAc,CAAC;IACrB,MAAM,GAAG,0BAA4B,CAAC;IAiCtC,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAaxB,CAAC;IAEH,KAAY,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IAE7C,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;MAKzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/commands/handler/add-user.command.js

@@ -21,7 +21,6 @@ var AddUserCommand;
         tag: zod_1.z.string(),
         username: zod_1.z.string(),
         password: zod_1.z.string(),
-        level: zod_1.z.number().default(0),
     });
     const BaseVlessUser = zod_1.z.object({
         type: zod_1.z.literal('vless'),
@@ -29,7 +28,6 @@ var AddUserCommand;
         username: zod_1.z.string(),
         uuid: zod_1.z.string(),
         flow: zod_1.z.enum(['xtls-rprx-vision', '']),
-        level: zod_1.z.number().default(0),
     });
     const BaseShadowsocksUser = zod_1.z.object({
         type: zod_1.z.literal('shadowsocks'),
@@ -38,30 +36,12 @@ var AddUserCommand;
         password: zod_1.z.string(),
         cipherType: zod_1.z.nativeEnum(CipherType),
         ivCheck: zod_1.z.boolean(),
-        level: zod_1.z.number().default(0),
     });
     const BaseShadowsocks2022User = zod_1.z.object({
         type: zod_1.z.literal('shadowsocks2022'),
         tag: zod_1.z.string(),
         username: zod_1.z.string(),
         key: zod_1.z.string(),
-        level: zod_1.z.number().default(0),
-    });
-    const BaseSocksUser = zod_1.z.object({
-        type: zod_1.z.literal('socks'),
-        tag: zod_1.z.string(),
-        username: zod_1.z.string(),
-        socks_username: zod_1.z.string(),
-        socks_password: zod_1.z.string(),
-        level: zod_1.z.number().default(0),
-    });
-    const BaseHttpUser = zod_1.z.object({
-        type: zod_1.z.literal('http'),
-        tag: zod_1.z.string(),
-        username: zod_1.z.string(),
-        http_username: zod_1.z.string(),
-        http_password: zod_1.z.string(),
-        level: zod_1.z.number().default(0),
     });
     AddUserCommand.RequestSchema = zod_1.z.object({
         data: zod_1.z.array(zod_1.z.discriminatedUnion('type', [
@@ -69,8 +49,6 @@ var AddUserCommand;
             BaseVlessUser,
             BaseShadowsocksUser,
             BaseShadowsocks2022User,
-            BaseSocksUser,
-            BaseHttpUser,
         ])),
         hashData: zod_1.z.object({
             vlessUuid: zod_1.z.string().uuid(),

package/build/commands/handler/get-inbound-users.command.d.ts

@@ -17,40 +17,40 @@ export declare namespace GetInboundUsersCommand {
                 level: z.ZodOptional<z.ZodNumber>;
             }, "strip", z.ZodTypeAny, {
                 username: string;
-                level?: number | undefined;
                 email?: string | undefined;
+                level?: number | undefined;
             }, {
                 username: string;
-                level?: number | undefined;
                 email?: string | undefined;
+                level?: number | undefined;
             }>, "many">;
         }, "strip", z.ZodTypeAny, {
             users: {
                 username: string;
-                level?: number | undefined;
                 email?: string | undefined;
+                level?: number | undefined;
             }[];
         }, {
             users: {
                 username: string;
-                level?: number | undefined;
                 email?: string | undefined;
+                level?: number | undefined;
             }[];
         }>;
     }, "strip", z.ZodTypeAny, {
         response: {
             users: {
                 username: string;
-                level?: number | undefined;
                 email?: string | undefined;
+                level?: number | undefined;
             }[];
         };
     }, {
         response: {
             users: {
                 username: string;
-                level?: number | undefined;
                 email?: string | undefined;
+                level?: number | undefined;
             }[];
         };
     }>;

package/build/commands/stats/get-combined-stats.command.d.ts

@@ -0,0 +1,92 @@
+import { z } from 'zod';
+export declare namespace GetCombinedStatsCommand {
+    const url: "/node/stats/get-combined-stats";
+    const RequestSchema: z.ZodObject<{
+        reset: z.ZodBoolean;
+    }, "strip", z.ZodTypeAny, {
+        reset: boolean;
+    }, {
+        reset: boolean;
+    }>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        response: z.ZodObject<{
+            inbounds: z.ZodArray<z.ZodObject<{
+                inbound: z.ZodString;
+                downlink: z.ZodNumber;
+                uplink: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                inbound: string;
+                downlink: number;
+                uplink: number;
+            }, {
+                inbound: string;
+                downlink: number;
+                uplink: number;
+            }>, "many">;
+            outbounds: z.ZodArray<z.ZodObject<{
+                outbound: z.ZodString;
+                downlink: z.ZodNumber;
+                uplink: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                downlink: number;
+                uplink: number;
+                outbound: string;
+            }, {
+                downlink: number;
+                uplink: number;
+                outbound: string;
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            inbounds: {
+                inbound: string;
+                downlink: number;
+                uplink: number;
+            }[];
+            outbounds: {
+                downlink: number;
+                uplink: number;
+                outbound: string;
+            }[];
+        }, {
+            inbounds: {
+                inbound: string;
+                downlink: number;
+                uplink: number;
+            }[];
+            outbounds: {
+                downlink: number;
+                uplink: number;
+                outbound: string;
+            }[];
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        response: {
+            inbounds: {
+                inbound: string;
+                downlink: number;
+                uplink: number;
+            }[];
+            outbounds: {
+                downlink: number;
+                uplink: number;
+                outbound: string;
+            }[];
+        };
+    }, {
+        response: {
+            inbounds: {
+                inbound: string;
+                downlink: number;
+                uplink: number;
+            }[];
+            outbounds: {
+                downlink: number;
+                uplink: number;
+                outbound: string;
+            }[];
+        };
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+//# sourceMappingURL=get-combined-stats.command.d.ts.map

package/build/commands/stats/get-combined-stats.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-combined-stats.command.d.ts","sourceRoot":"","sources":["../../../commands/stats/get-combined-stats.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,yBAAiB,uBAAuB,CAAC;IAC9B,MAAM,GAAG,kCAAoC,CAAC;IAE9C,MAAM,aAAa;;;;;;MAExB,CAAC;IAEH,KAAY,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IAE7C,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAiBzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/commands/stats/get-combined-stats.command.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetCombinedStatsCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../api");
+var GetCombinedStatsCommand;
+(function (GetCombinedStatsCommand) {
+    GetCombinedStatsCommand.url = api_1.REST_API.STATS.GET_COMBINED_STATS;
+    GetCombinedStatsCommand.RequestSchema = zod_1.z.object({
+        reset: zod_1.z.boolean(),
+    });
+    GetCombinedStatsCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.object({
+            inbounds: zod_1.z.array(zod_1.z.object({
+                inbound: zod_1.z.string(),
+                downlink: zod_1.z.number(),
+                uplink: zod_1.z.number(),
+            })),
+            outbounds: zod_1.z.array(zod_1.z.object({
+                outbound: zod_1.z.string(),
+                downlink: zod_1.z.number(),
+                uplink: zod_1.z.number(),
+            })),
+        }),
+    });
+})(GetCombinedStatsCommand || (exports.GetCombinedStatsCommand = GetCombinedStatsCommand = {}));

package/build/commands/stats/index.d.ts

@@ -1,5 +1,6 @@
 export * from './get-all-inbounds-stats.command';
 export * from './get-all-outbounds-stats.command';
+export * from './get-combined-stats.command';
 export * from './get-inbound-stats.command';
 export * from './get-outbound-stats.command';
 export * from './get-system-stats.command';

package/build/commands/stats/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../commands/stats/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,kCAAkC,CAAC;AACjD,cAAc,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../commands/stats/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,kCAAkC,CAAC;AACjD,cAAc,2BAA2B,CAAC"}

package/build/commands/stats/index.js

@@ -16,6 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./get-all-inbounds-stats.command"), exports);
 __exportStar(require("./get-all-outbounds-stats.command"), exports);
+__exportStar(require("./get-combined-stats.command"), exports);
 __exportStar(require("./get-inbound-stats.command"), exports);
 __exportStar(require("./get-outbound-stats.command"), exports);
 __exportStar(require("./get-system-stats.command"), exports);

package/build/commands/xray/get-node-health-check.command.d.ts

@@ -6,26 +6,31 @@ export declare namespace GetNodeHealthCheckCommand {
             isAlive: z.ZodBoolean;
             xrayInternalStatusCached: z.ZodBoolean;
             xrayVersion: z.ZodNullable<z.ZodString>;
+            nodeVersion: z.ZodString;
         }, "strip", z.ZodTypeAny, {
             isAlive: boolean;
             xrayInternalStatusCached: boolean;
             xrayVersion: string | null;
+            nodeVersion: string;
         }, {
             isAlive: boolean;
             xrayInternalStatusCached: boolean;
             xrayVersion: string | null;
+            nodeVersion: string;
         }>;
     }, "strip", z.ZodTypeAny, {
         response: {
             isAlive: boolean;
             xrayInternalStatusCached: boolean;
             xrayVersion: string | null;
+            nodeVersion: string;
         };
     }, {
         response: {
             isAlive: boolean;
             xrayInternalStatusCached: boolean;
             xrayVersion: string | null;
+            nodeVersion: string;
         };
     }>;
     type Response = z.infer<typeof ResponseSchema>;

package/build/commands/xray/get-node-health-check.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-node-health-check.command.d.ts","sourceRoot":"","sources":["../../../commands/xray/get-node-health-check.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,yBAAiB,yBAAyB,CAAC;IAChC,MAAM,GAAG,0BAAkC,CAAC;IAE5C,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;MAMzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}
+{"version":3,"file":"get-node-health-check.command.d.ts","sourceRoot":"","sources":["../../../commands/xray/get-node-health-check.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,yBAAiB,yBAAyB,CAAC;IAChC,MAAM,GAAG,0BAAkC,CAAC;IAE5C,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAOzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/commands/xray/get-node-health-check.command.js

@@ -11,6 +11,7 @@ var GetNodeHealthCheckCommand;
             isAlive: zod_1.z.boolean(),
             xrayInternalStatusCached: zod_1.z.boolean(),
             xrayVersion: zod_1.z.string().nullable(),
+            nodeVersion: zod_1.z.string(),
         }),
     });
 })(GetNodeHealthCheckCommand || (exports.GetNodeHealthCheckCommand = GetNodeHealthCheckCommand = {}));

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

@@ -1,7 +1,88 @@
 import { z } from 'zod';
 export declare namespace StartXrayCommand {
     const url: "/node/xray/start";
-    const RequestSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    const RequestSchema: z.ZodObject<{
+        internals: z.ZodObject<{
+            forceRestart: z.ZodDefault<z.ZodBoolean>;
+            hashes: z.ZodObject<{
+                emptyConfig: z.ZodString;
+                inbounds: z.ZodArray<z.ZodObject<{
+                    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;
+        }>;
+        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>;
+    }>;
     type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{
         response: z.ZodObject<{

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;AAGxB,yBAAiB,gBAAgB,CAAC;IACvB,MAAM,GAAG,oBAAsB,CAAC;IAChC,MAAM,aAAa,wCAAwB,CAAC;IAEnD,KAAY,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IAE7C,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAgBzB,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;AAGxB,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAgBzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

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

@@ -6,7 +6,20 @@ const api_1 = require("../../api");
 var StartXrayCommand;
 (function (StartXrayCommand) {
     StartXrayCommand.url = api_1.REST_API.XRAY.START;
-    StartXrayCommand.RequestSchema = zod_1.z.record(zod_1.z.unknown());
+    StartXrayCommand.RequestSchema = zod_1.z.object({
+        internals: zod_1.z.object({
+            forceRestart: zod_1.z.boolean().default(false),
+            hashes: zod_1.z.object({
+                emptyConfig: zod_1.z.string(),
+                inbounds: zod_1.z.array(zod_1.z.object({
+                    usersCount: zod_1.z.number(),
+                    hash: zod_1.z.string(),
+                    tag: zod_1.z.string(),
+                })),
+            }),
+        }),
+        xrayConfig: zod_1.z.record(zod_1.z.unknown()),
+    });
     StartXrayCommand.ResponseSchema = zod_1.z.object({
         response: zod_1.z.object({
             isStarted: zod_1.z.boolean(),

package/build/constants/errors/errors.d.ts

@@ -69,5 +69,10 @@ export declare const ERRORS: {
         readonly message: "Failed to get outbounds stats";
         readonly httpCode: 500;
     };
+    readonly FAILED_TO_GET_COMBINED_STATS: {
+        readonly code: "A017";
+        readonly message: "Failed to get combined stats";
+        readonly httpCode: 500;
+    };
 };
 //# sourceMappingURL=errors.d.ts.map

package/build/constants/errors/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../constants/errors/errors.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+CT,CAAC"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../constants/errors/errors.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDT,CAAC"}

package/build/constants/errors/errors.js

@@ -48,4 +48,9 @@ exports.ERRORS = {
         message: 'Failed to get outbounds stats',
         httpCode: 500,
     },
+    FAILED_TO_GET_COMBINED_STATS: {
+        code: 'A017',
+        message: 'Failed to get combined stats',
+        httpCode: 500,
+    },
 };

package/build/constants/errors/known-errors.js

@@ -6,6 +6,6 @@ exports.KNOWN_ERRORS = {
     XRAY_FAILED_TO_START: {
         code: 'RN-001',
         message: 'Xray core failed to start',
-        documentationUrl: 'https://remna.st/docs/guides/common-errors#xml-rpc-fault-spawn-error-xray',
+        documentationUrl: 'https://docs.rw/docs/guides/common-errors#xml-rpc-fault-spawn-error-xray',
     },
 };

package/build/constants/index.d.ts

@@ -1,6 +1,4 @@
 export * from './errors';
-export * from './hashes';
-export * from './headers';
 export * from './internal';
 export * from './roles';
 export * from './xray';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../constants/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../constants/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC"}

package/build/constants/index.js

@@ -15,8 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./errors"), exports);
-__exportStar(require("./hashes"), exports);
-__exportStar(require("./headers"), exports);
 __exportStar(require("./internal"), exports);
 __exportStar(require("./roles"), exports);
 __exportStar(require("./xray"), exports);

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

@@ -4,6 +4,7 @@ export declare const XRAY_DEFAULT_POLICY_MODEL: {
             readonly '0': {
                 readonly statsUserUplink: true;
                 readonly statsUserDownlink: true;
+                readonly statsUserOnline: false;
             };
         };
         readonly system: {

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;;;;;;;;;;;;;;;CAe5B,CAAC;AAEX,eAAO,MAAM,wBAAwB;;CAE3B,CAAC;AAEX,eAAO,MAAM,sBAAsB;;;;;;CAMzB,CAAC;AAEX,eAAO,MAAM,sBAAsB;;;;;;;;CAQzB,CAAC;AAEX,eAAO,MAAM,wBAAwB;;;;CAI3B,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;;;;;;CAMzB,CAAC;AAEX,eAAO,MAAM,sBAAsB;;;;;;;;CAQzB,CAAC;AAEX,eAAO,MAAM,wBAAwB;;;;CAI3B,CAAC"}

package/build/constants/xray/stats.js

@@ -7,6 +7,7 @@ exports.XRAY_DEFAULT_POLICY_MODEL = {
             '0': {
                 statsUserUplink: true,
                 statsUserDownlink: true,
+                statsUserOnline: false,
             },
         },
         system: {

package/build/index.d.ts

@@ -1,5 +1,4 @@
 export * from './api';
 export * from './commands';
 export * from './constants';
-export * from './models';
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC;AACtB,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC;AACtB,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC"}

package/build/index.js

@@ -17,4 +17,3 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./api"), exports);
 __exportStar(require("./commands"), exports);
 __exportStar(require("./constants"), exports);
-__exportStar(require("./models"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnawave/node-contract",
-  "version": "0.5.9",
+  "version": "0.6.1",
   "description": "A node-contract library for Remnawave Panel",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -23,6 +23,6 @@
   },
   "license": "AGPL-3.0-only",
   "dependencies": {
-    "zod": "^3.22.4"
+    "zod": "^3.25.76"
   }
 }

package/build/constants/hashes/hash-payload.d.ts

@@ -1,9 +0,0 @@
-export interface IHashPayload {
-    emptyConfig: string;
-    inbounds: {
-        usersCount: number;
-        hash: string;
-        tag: string;
-    }[];
-}
-//# sourceMappingURL=hash-payload.d.ts.map

package/build/constants/hashes/hash-payload.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"hash-payload.d.ts","sourceRoot":"","sources":["../../../constants/hashes/hash-payload.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE;QACN,UAAU,EAAE,MAAM,CAAC;QACnB,IAAI,EAAE,MAAM,CAAC;QACb,GAAG,EAAE,MAAM,CAAC;KACf,EAAE,CAAC;CACP"}

package/build/constants/hashes/hash-payload.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/build/constants/hashes/index.d.ts

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

package/build/constants/hashes/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../constants/hashes/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC"}

package/build/constants/hashes/index.js

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

package/build/constants/headers/headers.contants.d.ts

@@ -1,3 +0,0 @@
-export declare const X_HASH_PAYLOAD = "X-Hash-Payload";
-export declare const X_FORCE_RESTART = "X-Force-Restart";
-//# sourceMappingURL=headers.contants.d.ts.map

package/build/constants/headers/headers.contants.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"headers.contants.d.ts","sourceRoot":"","sources":["../../../constants/headers/headers.contants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,mBAAmB,CAAC;AAC/C,eAAO,MAAM,eAAe,oBAAoB,CAAC"}

package/build/constants/headers/headers.contants.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.X_FORCE_RESTART = exports.X_HASH_PAYLOAD = void 0;
-exports.X_HASH_PAYLOAD = 'X-Hash-Payload';
-exports.X_FORCE_RESTART = 'X-Force-Restart';

package/build/constants/headers/index.d.ts

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

package/build/constants/headers/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../constants/headers/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/build/constants/headers/index.js

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

package/build/models/auth.schema.d.ts

@@ -1,9 +0,0 @@
-import { z } from 'zod';
-export declare const AuthSchema: z.ZodObject<{
-    hash: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    hash: string;
-}, {
-    hash: string;
-}>;
-//# sourceMappingURL=auth.schema.d.ts.map

package/build/models/auth.schema.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"auth.schema.d.ts","sourceRoot":"","sources":["../../models/auth.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,UAAU;;;;;;EAErB,CAAC"}

package/build/models/auth.schema.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AuthSchema = void 0;
-const zod_1 = require("zod");
-exports.AuthSchema = zod_1.z.object({
-    hash: zod_1.z.string(),
-});

package/build/models/index.d.ts

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

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

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

package/build/models/index.js

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