@remnawave/node-contract 2.6.0 → 2.6.3

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

@@ -6,5 +6,7 @@ export declare const HANDLER_ROUTES: {
     readonly REMOVE_USERS: "remove-users";
     readonly GET_INBOUND_USERS_COUNT: "get-inbound-users-count";
     readonly GET_INBOUND_USERS: "get-inbound-users";
+    readonly DROP_USERS_CONNECTIONS: "drop-users-connections";
+    readonly DROP_IPS: "drop-ips";
 };
 //# sourceMappingURL=handler.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../../../api/controllers/handler.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,EAAG,SAAkB,CAAC;AAErD,eAAO,MAAM,cAAc;;;;;;;CAOjB,CAAC"}
+{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../../../api/controllers/handler.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,EAAG,SAAkB,CAAC;AAErD,eAAO,MAAM,cAAc;;;;;;;;;CAUjB,CAAC"}

package/build/api/controllers/handler.js

@@ -9,4 +9,6 @@ exports.HANDLER_ROUTES = {
     REMOVE_USERS: 'remove-users',
     GET_INBOUND_USERS_COUNT: 'get-inbound-users-count',
     GET_INBOUND_USERS: 'get-inbound-users',
+    DROP_USERS_CONNECTIONS: 'drop-users-connections',
+    DROP_IPS: 'drop-ips',
 };

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

@@ -1,4 +1,5 @@
 export * from './handler';
+export * from './plugin';
 export * from './stats';
 export * from './vision';
 export * from './xray';

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

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

package/build/api/controllers/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./handler"), exports);
+__exportStar(require("./plugin"), exports);
 __exportStar(require("./stats"), exports);
 __exportStar(require("./vision"), exports);
 __exportStar(require("./xray"), exports);

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

@@ -0,0 +1,9 @@
+export declare const PLUGIN_CONTROLLER: "plugin";
+export declare const TORRENT_BLOCKER_ROUTE: "torrent-blocker";
+export declare const PLUGIN_ROUTES: {
+    readonly SYNC: "sync";
+    readonly TORRENT_BLOCKER: {
+        readonly COLLECT: "torrent-blocker/collect";
+    };
+};
+//# sourceMappingURL=plugin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../api/controllers/plugin.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB,EAAG,QAAiB,CAAC;AAEnD,eAAO,MAAM,qBAAqB,EAAG,iBAA0B,CAAC;AAEhE,eAAO,MAAM,aAAa;;;;;CAMhB,CAAC"}

package/build/api/controllers/plugin.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLUGIN_ROUTES = exports.TORRENT_BLOCKER_ROUTE = exports.PLUGIN_CONTROLLER = void 0;
+exports.PLUGIN_CONTROLLER = 'plugin';
+exports.TORRENT_BLOCKER_ROUTE = 'torrent-blocker';
+exports.PLUGIN_ROUTES = {
+    SYNC: 'sync',
+    TORRENT_BLOCKER: {
+        COLLECT: `${exports.TORRENT_BLOCKER_ROUTE}/collect`,
+    },
+};

package/build/api/routes.d.ts

@@ -24,10 +24,18 @@ export declare const REST_API: {
         readonly GET_INBOUND_USERS: "/node/handler/get-inbound-users";
         readonly ADD_USERS: "/node/handler/add-users";
         readonly REMOVE_USERS: "/node/handler/remove-users";
+        readonly DROP_USERS_CONNECTIONS: "/node/handler/drop-users-connections";
+        readonly DROP_IPS: "/node/handler/drop-ips";
     };
     readonly VISION: {
         readonly UNBLOCK_IP: "vision/unblock-ip";
         readonly BLOCK_IP: "vision/block-ip";
     };
+    readonly PLUGIN: {
+        readonly SYNC: "/node/plugin/sync";
+        readonly TORRENT_BLOCKER: {
+            readonly COLLECT: "/node/plugin/torrent-blocker/collect";
+        };
+    };
 };
 //# sourceMappingURL=routes.d.ts.map

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BX,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCX,CAAC"}

package/build/api/routes.js

@@ -61,9 +61,17 @@ exports.REST_API = {
         GET_INBOUND_USERS: `${exports.ROOT}/${CONTROLLERS.HANDLER_CONTROLLER}/${CONTROLLERS.HANDLER_ROUTES.GET_INBOUND_USERS}`,
         ADD_USERS: `${exports.ROOT}/${CONTROLLERS.HANDLER_CONTROLLER}/${CONTROLLERS.HANDLER_ROUTES.ADD_USERS}`,
         REMOVE_USERS: `${exports.ROOT}/${CONTROLLERS.HANDLER_CONTROLLER}/${CONTROLLERS.HANDLER_ROUTES.REMOVE_USERS}`,
+        DROP_USERS_CONNECTIONS: `${exports.ROOT}/${CONTROLLERS.HANDLER_CONTROLLER}/${CONTROLLERS.HANDLER_ROUTES.DROP_USERS_CONNECTIONS}`,
+        DROP_IPS: `${exports.ROOT}/${CONTROLLERS.HANDLER_CONTROLLER}/${CONTROLLERS.HANDLER_ROUTES.DROP_IPS}`,
     },
     VISION: {
         UNBLOCK_IP: `${CONTROLLERS.VISION_CONTROLLER}/${CONTROLLERS.VISION_ROUTES.UNBLOCK_IP}`,
         BLOCK_IP: `${CONTROLLERS.VISION_CONTROLLER}/${CONTROLLERS.VISION_ROUTES.BLOCK_IP}`,
     },
+    PLUGIN: {
+        SYNC: `${exports.ROOT}/${CONTROLLERS.PLUGIN_CONTROLLER}/${CONTROLLERS.PLUGIN_ROUTES.SYNC}`,
+        TORRENT_BLOCKER: {
+            COLLECT: `${exports.ROOT}/${CONTROLLERS.PLUGIN_CONTROLLER}/${CONTROLLERS.PLUGIN_ROUTES.TORRENT_BLOCKER.COLLECT}`,
+        },
+    },
 };

package/build/commands/handler/drop-ips.command.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+export declare namespace DropIpsCommand {
+    const url: "/node/handler/drop-ips";
+    const RequestSchema: z.ZodObject<{
+        ips: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        ips: string[];
+    }, {
+        ips: string[];
+    }>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        response: z.ZodObject<{
+            success: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            success: boolean;
+        }, {
+            success: boolean;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        response: {
+            success: boolean;
+        };
+    }, {
+        response: {
+            success: boolean;
+        };
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+//# sourceMappingURL=drop-ips.command.d.ts.map

package/build/commands/handler/drop-ips.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drop-ips.command.d.ts","sourceRoot":"","sources":["../../../commands/handler/drop-ips.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,yBAAiB,cAAc,CAAC;IACrB,MAAM,GAAG,0BAA4B,CAAC;IAEtC,MAAM,aAAa;;;;;;MAExB,CAAC;IAEH,KAAY,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IAE7C,MAAM,cAAc;;;;;;;;;;;;;;;;MAIzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/commands/handler/drop-ips.command.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropIpsCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../api");
+var DropIpsCommand;
+(function (DropIpsCommand) {
+    DropIpsCommand.url = api_1.REST_API.HANDLER.DROP_IPS;
+    DropIpsCommand.RequestSchema = zod_1.z.object({
+        ips: zod_1.z.array(zod_1.z.string()).min(1),
+    });
+    DropIpsCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.object({
+            success: zod_1.z.boolean(),
+        }),
+    });
+})(DropIpsCommand || (exports.DropIpsCommand = DropIpsCommand = {}));

package/build/commands/handler/drop-users-connections.command.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+export declare namespace DropUsersConnectionsCommand {
+    const url: "/node/handler/drop-users-connections";
+    const RequestSchema: z.ZodObject<{
+        userIds: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        userIds: string[];
+    }, {
+        userIds: string[];
+    }>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        response: z.ZodObject<{
+            success: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            success: boolean;
+        }, {
+            success: boolean;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        response: {
+            success: boolean;
+        };
+    }, {
+        response: {
+            success: boolean;
+        };
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+//# sourceMappingURL=drop-users-connections.command.d.ts.map

package/build/commands/handler/drop-users-connections.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"drop-users-connections.command.d.ts","sourceRoot":"","sources":["../../../commands/handler/drop-users-connections.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,yBAAiB,2BAA2B,CAAC;IAClC,MAAM,GAAG,wCAA0C,CAAC;IAEpD,MAAM,aAAa;;;;;;MAExB,CAAC;IAEH,KAAY,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IAE7C,MAAM,cAAc;;;;;;;;;;;;;;;;MAIzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/commands/handler/drop-users-connections.command.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropUsersConnectionsCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../api");
+var DropUsersConnectionsCommand;
+(function (DropUsersConnectionsCommand) {
+    DropUsersConnectionsCommand.url = api_1.REST_API.HANDLER.DROP_USERS_CONNECTIONS;
+    DropUsersConnectionsCommand.RequestSchema = zod_1.z.object({
+        userIds: zod_1.z.array(zod_1.z.string()).min(1),
+    });
+    DropUsersConnectionsCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.object({
+            success: zod_1.z.boolean(),
+        }),
+    });
+})(DropUsersConnectionsCommand || (exports.DropUsersConnectionsCommand = DropUsersConnectionsCommand = {}));

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

@@ -1,5 +1,7 @@
 export * from './add-user.command';
 export * from './add-users.command';
+export * from './drop-ips.command';
+export * from './drop-users-connections.command';
 export * from './get-inbound-users-count.command';
 export * from './get-inbound-users.command';
 export * from './remove-user.command';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../commands/handler/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mCAAmC,CAAC;AAClD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../commands/handler/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC"}

package/build/commands/handler/index.js

@@ -16,6 +16,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./add-user.command"), exports);
 __exportStar(require("./add-users.command"), exports);
+__exportStar(require("./drop-ips.command"), exports);
+__exportStar(require("./drop-users-connections.command"), exports);
 __exportStar(require("./get-inbound-users-count.command"), exports);
 __exportStar(require("./get-inbound-users.command"), exports);
 __exportStar(require("./remove-user.command"), exports);

package/build/commands/index.d.ts

@@ -1,4 +1,5 @@
 export * from './handler';
+export * from './plugin';
 export * from './stats';
 export * from './vision';
 export * from './xray';

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

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

package/build/commands/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./handler"), exports);
+__exportStar(require("./plugin"), exports);
 __exportStar(require("./stats"), exports);
 __exportStar(require("./vision"), exports);
 __exportStar(require("./xray"), exports);

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

@@ -0,0 +1,3 @@
+export * from './sync.command';
+export * from './torrent-blocker';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../commands/plugin/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC"}

package/build/commands/plugin/index.js

@@ -0,0 +1,18 @@
+"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("./sync.command"), exports);
+__exportStar(require("./torrent-blocker"), exports);

package/build/commands/plugin/sync.command.d.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+export declare namespace SyncCommand {
+    const url: "/node/plugin/sync";
+    const RequestSchema: z.ZodObject<{
+        plugin: z.ZodNullable<z.ZodObject<{
+            config: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            uuid: z.ZodString;
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            uuid: string;
+            config: Record<string, unknown>;
+            name: string;
+        }, {
+            uuid: string;
+            config: Record<string, unknown>;
+            name: string;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        plugin: {
+            uuid: string;
+            config: Record<string, unknown>;
+            name: string;
+        } | null;
+    }, {
+        plugin: {
+            uuid: string;
+            config: Record<string, unknown>;
+            name: string;
+        } | null;
+    }>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        response: z.ZodObject<{
+            accepted: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            accepted: boolean;
+        }, {
+            accepted: boolean;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        response: {
+            accepted: boolean;
+        };
+    }, {
+        response: {
+            accepted: boolean;
+        };
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+//# sourceMappingURL=sync.command.d.ts.map

package/build/commands/plugin/sync.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.command.d.ts","sourceRoot":"","sources":["../../../commands/plugin/sync.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,yBAAiB,WAAW,CAAC;IAClB,MAAM,GAAG,qBAAuB,CAAC;IACjC,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;MAQxB,CAAC;IAEH,KAAY,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IAE7C,MAAM,cAAc;;;;;;;;;;;;;;;;MAIzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/commands/plugin/sync.command.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../api");
+var SyncCommand;
+(function (SyncCommand) {
+    SyncCommand.url = api_1.REST_API.PLUGIN.SYNC;
+    SyncCommand.RequestSchema = zod_1.z.object({
+        plugin: zod_1.z
+            .object({
+            config: zod_1.z.record(zod_1.z.unknown()),
+            uuid: zod_1.z.string().uuid(),
+            name: zod_1.z.string(),
+        })
+            .nullable(),
+    });
+    SyncCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.object({
+            accepted: zod_1.z.boolean(),
+        }),
+    });
+})(SyncCommand || (exports.SyncCommand = SyncCommand = {}));

package/build/commands/plugin/torrent-blocker/collect-reports.schema.d.ts

@@ -0,0 +1,233 @@
+import { z } from 'zod';
+export declare namespace CollectReportsCommand {
+    const url: "/node/plugin/torrent-blocker/collect";
+    const ResponseSchema: z.ZodObject<{
+        response: z.ZodObject<{
+            reports: z.ZodArray<z.ZodObject<{
+                actionReport: z.ZodObject<{
+                    blocked: z.ZodBoolean;
+                    whitelisted: z.ZodBoolean;
+                    ip: z.ZodString;
+                    blockDuration: z.ZodNumber;
+                    userId: z.ZodString;
+                    processedAt: z.ZodEffects<z.ZodString, Date, string>;
+                }, "strip", z.ZodTypeAny, {
+                    userId: string;
+                    blocked: boolean;
+                    whitelisted: boolean;
+                    ip: string;
+                    blockDuration: number;
+                    processedAt: Date;
+                }, {
+                    userId: string;
+                    blocked: boolean;
+                    whitelisted: boolean;
+                    ip: string;
+                    blockDuration: number;
+                    processedAt: string;
+                }>;
+                xrayReport: z.ZodObject<{
+                    email: z.ZodNullable<z.ZodString>;
+                    level: z.ZodNullable<z.ZodNumber>;
+                    protocol: z.ZodNullable<z.ZodString>;
+                    network: z.ZodString;
+                    source: z.ZodNullable<z.ZodString>;
+                    destination: z.ZodString;
+                    routeTarget: z.ZodNullable<z.ZodString>;
+                    originalTarget: z.ZodNullable<z.ZodString>;
+                    inboundTag: z.ZodNullable<z.ZodString>;
+                    inboundName: z.ZodNullable<z.ZodString>;
+                    inboundLocal: z.ZodNullable<z.ZodString>;
+                    outboundTag: z.ZodNullable<z.ZodString>;
+                    ts: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    email: string | null;
+                    level: number | null;
+                    protocol: string | null;
+                    network: string;
+                    source: string | null;
+                    destination: string;
+                    routeTarget: string | null;
+                    originalTarget: string | null;
+                    inboundTag: string | null;
+                    inboundName: string | null;
+                    inboundLocal: string | null;
+                    outboundTag: string | null;
+                    ts: number;
+                }, {
+                    email: string | null;
+                    level: number | null;
+                    protocol: string | null;
+                    network: string;
+                    source: string | null;
+                    destination: string;
+                    routeTarget: string | null;
+                    originalTarget: string | null;
+                    inboundTag: string | null;
+                    inboundName: string | null;
+                    inboundLocal: string | null;
+                    outboundTag: string | null;
+                    ts: number;
+                }>;
+            }, "strip", z.ZodTypeAny, {
+                actionReport: {
+                    userId: string;
+                    blocked: boolean;
+                    whitelisted: boolean;
+                    ip: string;
+                    blockDuration: number;
+                    processedAt: Date;
+                };
+                xrayReport: {
+                    email: string | null;
+                    level: number | null;
+                    protocol: string | null;
+                    network: string;
+                    source: string | null;
+                    destination: string;
+                    routeTarget: string | null;
+                    originalTarget: string | null;
+                    inboundTag: string | null;
+                    inboundName: string | null;
+                    inboundLocal: string | null;
+                    outboundTag: string | null;
+                    ts: number;
+                };
+            }, {
+                actionReport: {
+                    userId: string;
+                    blocked: boolean;
+                    whitelisted: boolean;
+                    ip: string;
+                    blockDuration: number;
+                    processedAt: string;
+                };
+                xrayReport: {
+                    email: string | null;
+                    level: number | null;
+                    protocol: string | null;
+                    network: string;
+                    source: string | null;
+                    destination: string;
+                    routeTarget: string | null;
+                    originalTarget: string | null;
+                    inboundTag: string | null;
+                    inboundName: string | null;
+                    inboundLocal: string | null;
+                    outboundTag: string | null;
+                    ts: number;
+                };
+            }>, "many">;
+        }, "strip", z.ZodTypeAny, {
+            reports: {
+                actionReport: {
+                    userId: string;
+                    blocked: boolean;
+                    whitelisted: boolean;
+                    ip: string;
+                    blockDuration: number;
+                    processedAt: Date;
+                };
+                xrayReport: {
+                    email: string | null;
+                    level: number | null;
+                    protocol: string | null;
+                    network: string;
+                    source: string | null;
+                    destination: string;
+                    routeTarget: string | null;
+                    originalTarget: string | null;
+                    inboundTag: string | null;
+                    inboundName: string | null;
+                    inboundLocal: string | null;
+                    outboundTag: string | null;
+                    ts: number;
+                };
+            }[];
+        }, {
+            reports: {
+                actionReport: {
+                    userId: string;
+                    blocked: boolean;
+                    whitelisted: boolean;
+                    ip: string;
+                    blockDuration: number;
+                    processedAt: string;
+                };
+                xrayReport: {
+                    email: string | null;
+                    level: number | null;
+                    protocol: string | null;
+                    network: string;
+                    source: string | null;
+                    destination: string;
+                    routeTarget: string | null;
+                    originalTarget: string | null;
+                    inboundTag: string | null;
+                    inboundName: string | null;
+                    inboundLocal: string | null;
+                    outboundTag: string | null;
+                    ts: number;
+                };
+            }[];
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        response: {
+            reports: {
+                actionReport: {
+                    userId: string;
+                    blocked: boolean;
+                    whitelisted: boolean;
+                    ip: string;
+                    blockDuration: number;
+                    processedAt: Date;
+                };
+                xrayReport: {
+                    email: string | null;
+                    level: number | null;
+                    protocol: string | null;
+                    network: string;
+                    source: string | null;
+                    destination: string;
+                    routeTarget: string | null;
+                    originalTarget: string | null;
+                    inboundTag: string | null;
+                    inboundName: string | null;
+                    inboundLocal: string | null;
+                    outboundTag: string | null;
+                    ts: number;
+                };
+            }[];
+        };
+    }, {
+        response: {
+            reports: {
+                actionReport: {
+                    userId: string;
+                    blocked: boolean;
+                    whitelisted: boolean;
+                    ip: string;
+                    blockDuration: number;
+                    processedAt: string;
+                };
+                xrayReport: {
+                    email: string | null;
+                    level: number | null;
+                    protocol: string | null;
+                    network: string;
+                    source: string | null;
+                    destination: string;
+                    routeTarget: string | null;
+                    originalTarget: string | null;
+                    inboundTag: string | null;
+                    inboundName: string | null;
+                    inboundLocal: string | null;
+                    outboundTag: string | null;
+                    ts: number;
+                };
+            }[];
+        };
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+//# sourceMappingURL=collect-reports.schema.d.ts.map

package/build/commands/plugin/torrent-blocker/collect-reports.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collect-reports.schema.d.ts","sourceRoot":"","sources":["../../../../commands/plugin/torrent-blocker/collect-reports.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,yBAAiB,qBAAqB,CAAC;IAC5B,MAAM,GAAG,wCAA0C,CAAC;IAEpD,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAIzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/commands/plugin/torrent-blocker/collect-reports.schema.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectReportsCommand = void 0;
+const zod_1 = require("zod");
+const models_1 = require("../../../models");
+const api_1 = require("../../../api");
+var CollectReportsCommand;
+(function (CollectReportsCommand) {
+    CollectReportsCommand.url = api_1.REST_API.PLUGIN.TORRENT_BLOCKER.COLLECT;
+    CollectReportsCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.object({
+            reports: zod_1.z.array(models_1.TorrentBlockerReportSchema),
+        }),
+    });
+})(CollectReportsCommand || (exports.CollectReportsCommand = CollectReportsCommand = {}));

package/build/commands/plugin/torrent-blocker/index.d.ts

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

package/build/commands/plugin/torrent-blocker/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../commands/plugin/torrent-blocker/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC"}

package/build/commands/plugin/torrent-blocker/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("./collect-reports.schema"), exports);

package/build/constants/internal/internal.constants.d.ts

@@ -1,4 +1,6 @@
 export declare const XRAY_INTERNAL_API_CONTROLLER = "internal";
 export declare const XRAY_INTERNAL_API_PATH = "/get-config";
 export declare const XRAY_INTERNAL_FULL_PATH = "/internal/get-config";
+export declare const XRAY_INTERNAL_WEBHOOK_PATH = "/webhook";
+export declare const XRAY_INTERNAL_FULL_WEBHOOK_PATH = "/internal/webhook";
 //# sourceMappingURL=internal.constants.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"internal.constants.d.ts","sourceRoot":"","sources":["../../../constants/internal/internal.constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,4BAA4B,aAAa,CAAC;AACvD,eAAO,MAAM,sBAAsB,gBAAgB,CAAC;AACpD,eAAO,MAAM,uBAAuB,yBAA8D,CAAC"}
+{"version":3,"file":"internal.constants.d.ts","sourceRoot":"","sources":["../../../constants/internal/internal.constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,4BAA4B,aAAa,CAAC;AACvD,eAAO,MAAM,sBAAsB,gBAAgB,CAAC;AACpD,eAAO,MAAM,uBAAuB,yBAA8D,CAAC;AACnG,eAAO,MAAM,0BAA0B,aAAa,CAAC;AACrD,eAAO,MAAM,+BAA+B,sBAAkE,CAAC"}

package/build/constants/internal/internal.constants.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.XRAY_INTERNAL_FULL_PATH = exports.XRAY_INTERNAL_API_PATH = exports.XRAY_INTERNAL_API_CONTROLLER = void 0;
+exports.XRAY_INTERNAL_FULL_WEBHOOK_PATH = exports.XRAY_INTERNAL_WEBHOOK_PATH = exports.XRAY_INTERNAL_FULL_PATH = exports.XRAY_INTERNAL_API_PATH = exports.XRAY_INTERNAL_API_CONTROLLER = void 0;
 exports.XRAY_INTERNAL_API_CONTROLLER = 'internal';
 exports.XRAY_INTERNAL_API_PATH = '/get-config';
 exports.XRAY_INTERNAL_FULL_PATH = `/${exports.XRAY_INTERNAL_API_CONTROLLER}${exports.XRAY_INTERNAL_API_PATH}`;
+exports.XRAY_INTERNAL_WEBHOOK_PATH = '/webhook';
+exports.XRAY_INTERNAL_FULL_WEBHOOK_PATH = `/${exports.XRAY_INTERNAL_API_CONTROLLER}${exports.XRAY_INTERNAL_WEBHOOK_PATH}`;

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

@@ -58,4 +58,18 @@ export declare const XRAY_ROUTING_RULES_MODEL: {
     readonly inboundTag: readonly ["REMNAWAVE_API_INBOUND"];
     readonly outboundTag: "REMNAWAVE_API";
 };
+export declare const XRAY_TORRENT_BLOCKER_ROUTING_RULES_MODEL: ({ webhookUrl, }: {
+    webhookUrl: string;
+}) => {
+    protocol: string[];
+    outboundTag: string;
+    webhook: {
+        url: string;
+        deduplication: number;
+    };
+};
+export declare const XRAY_TORRENT_BLOCKER_OUTBOUND_MODEL: {
+    readonly tag: "RW_TB_OUTBOUND_BLOCK";
+    readonly protocol: "blackhole";
+};
 //# sourceMappingURL=stats.d.ts.map

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"}
+{"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"}

package/build/constants/xray/stats.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.XRAY_ROUTING_RULES_MODEL = exports.XRAY_API_INBOUND_MODEL = exports.XRAY_DEFAULT_API_MODEL = exports.XRAY_DEFAULT_STATS_MODEL = exports.XRAY_DEFAULT_POLICY_MODEL = void 0;
+exports.XRAY_TORRENT_BLOCKER_OUTBOUND_MODEL = exports.XRAY_TORRENT_BLOCKER_ROUTING_RULES_MODEL = exports.XRAY_ROUTING_RULES_MODEL = exports.XRAY_API_INBOUND_MODEL = exports.XRAY_DEFAULT_API_MODEL = exports.XRAY_DEFAULT_STATS_MODEL = exports.XRAY_DEFAULT_POLICY_MODEL = void 0;
 exports.XRAY_DEFAULT_POLICY_MODEL = {
     policy: {
         levels: {
@@ -69,3 +69,16 @@ exports.XRAY_ROUTING_RULES_MODEL = {
     inboundTag: ['REMNAWAVE_API_INBOUND'],
     outboundTag: 'REMNAWAVE_API',
 };
+const XRAY_TORRENT_BLOCKER_ROUTING_RULES_MODEL = ({ webhookUrl, }) => ({
+    protocol: ['bittorrent'],
+    outboundTag: 'RW_TB_OUTBOUND_BLOCK',
+    webhook: {
+        url: webhookUrl,
+        deduplication: 30,
+    },
+});
+exports.XRAY_TORRENT_BLOCKER_ROUTING_RULES_MODEL = XRAY_TORRENT_BLOCKER_ROUTING_RULES_MODEL;
+exports.XRAY_TORRENT_BLOCKER_OUTBOUND_MODEL = {
+    tag: 'RW_TB_OUTBOUND_BLOCK',
+    protocol: 'blackhole',
+};

package/build/index.d.ts

@@ -1,4 +1,5 @@
 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"}
+{"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"}

package/build/index.js

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

package/build/models/index.d.ts

@@ -0,0 +1,3 @@
+export * from './torrent-blocker.report.schema';
+export * from './xray-webhook.schema';
+//# sourceMappingURL=index.d.ts.map

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

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

package/build/models/index.js

@@ -0,0 +1,18 @@
+"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("./torrent-blocker.report.schema"), exports);
+__exportStar(require("./xray-webhook.schema"), exports);

package/build/models/torrent-blocker.report.schema.d.ts

@@ -0,0 +1,118 @@
+import z from 'zod';
+export declare const TorrentBlockerReportSchema: z.ZodObject<{
+    actionReport: z.ZodObject<{
+        blocked: z.ZodBoolean;
+        whitelisted: z.ZodBoolean;
+        ip: z.ZodString;
+        blockDuration: z.ZodNumber;
+        userId: z.ZodString;
+        processedAt: z.ZodEffects<z.ZodString, Date, string>;
+    }, "strip", z.ZodTypeAny, {
+        userId: string;
+        blocked: boolean;
+        whitelisted: boolean;
+        ip: string;
+        blockDuration: number;
+        processedAt: Date;
+    }, {
+        userId: string;
+        blocked: boolean;
+        whitelisted: boolean;
+        ip: string;
+        blockDuration: number;
+        processedAt: string;
+    }>;
+    xrayReport: z.ZodObject<{
+        email: z.ZodNullable<z.ZodString>;
+        level: z.ZodNullable<z.ZodNumber>;
+        protocol: z.ZodNullable<z.ZodString>;
+        network: z.ZodString;
+        source: z.ZodNullable<z.ZodString>;
+        destination: z.ZodString;
+        routeTarget: z.ZodNullable<z.ZodString>;
+        originalTarget: z.ZodNullable<z.ZodString>;
+        inboundTag: z.ZodNullable<z.ZodString>;
+        inboundName: z.ZodNullable<z.ZodString>;
+        inboundLocal: z.ZodNullable<z.ZodString>;
+        outboundTag: z.ZodNullable<z.ZodString>;
+        ts: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        email: string | null;
+        level: number | null;
+        protocol: string | null;
+        network: string;
+        source: string | null;
+        destination: string;
+        routeTarget: string | null;
+        originalTarget: string | null;
+        inboundTag: string | null;
+        inboundName: string | null;
+        inboundLocal: string | null;
+        outboundTag: string | null;
+        ts: number;
+    }, {
+        email: string | null;
+        level: number | null;
+        protocol: string | null;
+        network: string;
+        source: string | null;
+        destination: string;
+        routeTarget: string | null;
+        originalTarget: string | null;
+        inboundTag: string | null;
+        inboundName: string | null;
+        inboundLocal: string | null;
+        outboundTag: string | null;
+        ts: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    actionReport: {
+        userId: string;
+        blocked: boolean;
+        whitelisted: boolean;
+        ip: string;
+        blockDuration: number;
+        processedAt: Date;
+    };
+    xrayReport: {
+        email: string | null;
+        level: number | null;
+        protocol: string | null;
+        network: string;
+        source: string | null;
+        destination: string;
+        routeTarget: string | null;
+        originalTarget: string | null;
+        inboundTag: string | null;
+        inboundName: string | null;
+        inboundLocal: string | null;
+        outboundTag: string | null;
+        ts: number;
+    };
+}, {
+    actionReport: {
+        userId: string;
+        blocked: boolean;
+        whitelisted: boolean;
+        ip: string;
+        blockDuration: number;
+        processedAt: string;
+    };
+    xrayReport: {
+        email: string | null;
+        level: number | null;
+        protocol: string | null;
+        network: string;
+        source: string | null;
+        destination: string;
+        routeTarget: string | null;
+        originalTarget: string | null;
+        inboundTag: string | null;
+        inboundName: string | null;
+        inboundLocal: string | null;
+        outboundTag: string | null;
+        ts: number;
+    };
+}>;
+export type TorrentBlockerReportModel = z.infer<typeof TorrentBlockerReportSchema>;
+//# sourceMappingURL=torrent-blocker.report.schema.d.ts.map

package/build/models/torrent-blocker.report.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"torrent-blocker.report.schema.d.ts","sourceRoot":"","sources":["../../models/torrent-blocker.report.schema.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAC;AAIpB,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcrC,CAAC;AAEH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC"}

package/build/models/torrent-blocker.report.schema.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TorrentBlockerReportSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+const xray_webhook_schema_1 = require("./xray-webhook.schema");
+exports.TorrentBlockerReportSchema = zod_1.default.object({
+    actionReport: zod_1.default.object({
+        blocked: zod_1.default.boolean(),
+        whitelisted: zod_1.default.boolean(),
+        ip: zod_1.default.string(),
+        blockDuration: zod_1.default.number(),
+        userId: zod_1.default.string(),
+        processedAt: zod_1.default
+            .string()
+            .datetime({ offset: true, local: true })
+            .transform((str) => new Date(str)),
+    }),
+    xrayReport: xray_webhook_schema_1.XrayWebhookSchema,
+});

package/build/models/xray-webhook.schema.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+export declare const XrayWebhookSchema: z.ZodObject<{
+    email: z.ZodNullable<z.ZodString>;
+    level: z.ZodNullable<z.ZodNumber>;
+    protocol: z.ZodNullable<z.ZodString>;
+    network: z.ZodString;
+    source: z.ZodNullable<z.ZodString>;
+    destination: z.ZodString;
+    routeTarget: z.ZodNullable<z.ZodString>;
+    originalTarget: z.ZodNullable<z.ZodString>;
+    inboundTag: z.ZodNullable<z.ZodString>;
+    inboundName: z.ZodNullable<z.ZodString>;
+    inboundLocal: z.ZodNullable<z.ZodString>;
+    outboundTag: z.ZodNullable<z.ZodString>;
+    ts: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    email: string | null;
+    level: number | null;
+    protocol: string | null;
+    network: string;
+    source: string | null;
+    destination: string;
+    routeTarget: string | null;
+    originalTarget: string | null;
+    inboundTag: string | null;
+    inboundName: string | null;
+    inboundLocal: string | null;
+    outboundTag: string | null;
+    ts: number;
+}, {
+    email: string | null;
+    level: number | null;
+    protocol: string | null;
+    network: string;
+    source: string | null;
+    destination: string;
+    routeTarget: string | null;
+    originalTarget: string | null;
+    inboundTag: string | null;
+    inboundName: string | null;
+    inboundLocal: string | null;
+    outboundTag: string | null;
+    ts: number;
+}>;
+export type XrayWebhookModel = z.infer<typeof XrayWebhookSchema>;
+//# sourceMappingURL=xray-webhook.schema.d.ts.map

package/build/models/xray-webhook.schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xray-webhook.schema.d.ts","sourceRoot":"","sources":["../../models/xray-webhook.schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAc5B,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/build/models/xray-webhook.schema.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.XrayWebhookSchema = void 0;
+const zod_1 = require("zod");
+exports.XrayWebhookSchema = zod_1.z.object({
+    email: zod_1.z.string().nullable(),
+    level: zod_1.z.number().nullable(),
+    protocol: zod_1.z.string().nullable(),
+    network: zod_1.z.string(),
+    source: zod_1.z.string().nullable(),
+    destination: zod_1.z.string(),
+    routeTarget: zod_1.z.string().nullable(),
+    originalTarget: zod_1.z.string().nullable(),
+    inboundTag: zod_1.z.string().nullable(),
+    inboundName: zod_1.z.string().nullable(),
+    inboundLocal: zod_1.z.string().nullable(),
+    outboundTag: zod_1.z.string().nullable(),
+    ts: zod_1.z.number(),
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnawave/node-contract",
-  "version": "2.6.0",
+  "version": "2.6.3",
   "description": "A node-contract library for Remnawave Panel",
   "main": "build/index.js",
   "types": "build/index.d.ts",