@remnawave/backend-contract 0.3.33 → 0.3.35

package/build/backend/api/controllers/hosts.d.ts

@@ -7,5 +7,10 @@ export declare const HOSTS_ROUTES: {
     readonly UPDATE_MANY: "many";
     readonly REORDER: "reorder";
     readonly GET_ONE: "get-one";
+    readonly BULK: {
+        readonly ENABLE_HOSTS: "bulk/enable";
+        readonly DISABLE_HOSTS: "bulk/disable";
+        readonly DELETE_HOSTS: "bulk/delete";
+    };
 };
 //# sourceMappingURL=hosts.d.ts.map

package/build/backend/api/controllers/hosts.d.ts.map

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

package/build/backend/api/controllers/hosts.js

@@ -10,4 +10,9 @@ exports.HOSTS_ROUTES = {
     UPDATE_MANY: 'many',
     REORDER: 'reorder',
     GET_ONE: 'get-one',
+    BULK: {
+        ENABLE_HOSTS: 'bulk/enable',
+        DISABLE_HOSTS: 'bulk/disable',
+        DELETE_HOSTS: 'bulk/delete',
+    },
 };

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

@@ -77,6 +77,11 @@ export declare const REST_API: {
         readonly REORDER: "/api/hosts/reorder";
         readonly DELETE: (uuid: string) => string;
         readonly GET_ONE: (uuid: string) => string;
+        readonly BULK: {
+            readonly ENABLE_HOSTS: "/api/hosts/bulk/enable";
+            readonly DISABLE_HOSTS: "/api/hosts/bulk/disable";
+            readonly DELETE_HOSTS: "/api/hosts/bulk/delete";
+        };
     };
     readonly SYSTEM: {
         readonly STATS: "/api/system/stats";

package/build/backend/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,MAAe,CAAC;AACpC,eAAO,MAAM,YAAY,EAAG,UAAmB,CAAC;AAChD,eAAO,MAAM,cAAc,EAAG,SAAkB,CAAC;AAEjD,eAAO,MAAM,QAAQ;;;;;;;;gCAQE,MAAM;;;;;;;;gCASN,MAAM;;;iCAIL,MAAM;iCAEN,MAAM;iCAEN,MAAM;gCAEP,MAAM;;;;;;;;;;;;;;kDAeY,MAAM;;;;;;;;;;qCAWnB,MAAM;gDAEK,MAAM;6CAET,MAAM;8DAEW,MAAM;6CAEvB,MAAM;sCAEb,MAAM;qCAEP,MAAM;qCAEN,MAAM;;;4CAIC,MAAM;;;;kDAKA,MAAM;uCAEjB,MAAM;;;kCAIX,MAAM;0CAEE,MAAM;uCAET,MAAM;;;;;;;;gCASb,MAAM;iCAEL,MAAM;;;;;;;;0CASG,MAAM;;;;;;;CAQ7B,CAAC"}
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../../api/routes.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,IAAI,EAAG,MAAe,CAAC;AACpC,eAAO,MAAM,YAAY,EAAG,UAAmB,CAAC;AAChD,eAAO,MAAM,cAAc,EAAG,SAAkB,CAAC;AAEjD,eAAO,MAAM,QAAQ;;;;;;;;gCAQE,MAAM;;;;;;;;gCASN,MAAM;;;iCAIL,MAAM;iCAEN,MAAM;iCAEN,MAAM;gCAEP,MAAM;;;;;;;;;;;;;;kDAeY,MAAM;;;;;;;;;;qCAWnB,MAAM;gDAEK,MAAM;6CAET,MAAM;8DAEW,MAAM;6CAEvB,MAAM;sCAEb,MAAM;qCAEP,MAAM;qCAEN,MAAM;;;4CAIC,MAAM;;;;kDAKA,MAAM;uCAEjB,MAAM;;;kCAIX,MAAM;0CAEE,MAAM;uCAET,MAAM;;;;;;;;gCASb,MAAM;iCAEL,MAAM;;;;;;;;;;;;;0CAcG,MAAM;;;;;;;CAQ7B,CAAC"}

package/build/backend/api/routes.js

@@ -114,6 +114,11 @@ exports.REST_API = {
         REORDER: `${exports.ROOT}/${CONTROLLERS.HOSTS_CONTROLLER}/${CONTROLLERS.HOSTS_ROUTES.REORDER}`,
         DELETE: (uuid) => `${exports.ROOT}/${CONTROLLERS.HOSTS_CONTROLLER}/${CONTROLLERS.HOSTS_ROUTES.DELETE}/${uuid}`,
         GET_ONE: (uuid) => `${exports.ROOT}/${CONTROLLERS.HOSTS_CONTROLLER}/${CONTROLLERS.HOSTS_ROUTES.GET_ONE}/${uuid}`,
+        BULK: {
+            ENABLE_HOSTS: `${exports.ROOT}/${CONTROLLERS.HOSTS_CONTROLLER}/${CONTROLLERS.HOSTS_ROUTES.BULK.ENABLE_HOSTS}`,
+            DISABLE_HOSTS: `${exports.ROOT}/${CONTROLLERS.HOSTS_CONTROLLER}/${CONTROLLERS.HOSTS_ROUTES.BULK.DISABLE_HOSTS}`,
+            DELETE_HOSTS: `${exports.ROOT}/${CONTROLLERS.HOSTS_CONTROLLER}/${CONTROLLERS.HOSTS_ROUTES.BULK.DELETE_HOSTS}`,
+        },
     },
     SYSTEM: {
         STATS: `${exports.ROOT}/${CONTROLLERS.SYSTEM_CONTROLLER}/${CONTROLLERS.SYSTEM_ROUTES.STATS}`,

package/build/backend/commands/hosts/bulk/delete-many-hosts.command.d.ts

@@ -0,0 +1,101 @@
+import { z } from 'zod';
+export declare namespace BulkDeleteHostsCommand {
+    const url: "/api/hosts/bulk/delete";
+    const TSQ_url: "/api/hosts/bulk/delete";
+    const RequestSchema: z.ZodObject<{
+        uuids: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        uuids: string[];
+    }, {
+        uuids: string[];
+    }>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        response: z.ZodArray<z.ZodObject<{
+            uuid: z.ZodString;
+            inboundUuid: z.ZodString;
+            viewPosition: z.ZodNumber;
+            remark: z.ZodString;
+            address: z.ZodString;
+            port: z.ZodNumber;
+            path: z.ZodNullable<z.ZodString>;
+            sni: z.ZodNullable<z.ZodString>;
+            host: z.ZodNullable<z.ZodString>;
+            alpn: z.ZodNullable<z.ZodString>;
+            fingerprint: z.ZodNullable<z.ZodString>;
+            allowInsecure: z.ZodDefault<z.ZodBoolean>;
+            isDisabled: z.ZodDefault<z.ZodBoolean>;
+            securityLayer: z.ZodDefault<z.ZodNativeEnum<{
+                readonly DEFAULT: "DEFAULT";
+                readonly TLS: "TLS";
+                readonly NONE: "NONE";
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            uuid: string;
+            path: string | null;
+            port: number;
+            inboundUuid: string;
+            viewPosition: number;
+            remark: string;
+            address: string;
+            sni: string | null;
+            host: string | null;
+            alpn: string | null;
+            fingerprint: string | null;
+            allowInsecure: boolean;
+            isDisabled: boolean;
+            securityLayer: "DEFAULT" | "TLS" | "NONE";
+        }, {
+            uuid: string;
+            path: string | null;
+            port: number;
+            inboundUuid: string;
+            viewPosition: number;
+            remark: string;
+            address: string;
+            sni: string | null;
+            host: string | null;
+            alpn: string | null;
+            fingerprint: string | null;
+            allowInsecure?: boolean | undefined;
+            isDisabled?: boolean | undefined;
+            securityLayer?: "DEFAULT" | "TLS" | "NONE" | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        response: {
+            uuid: string;
+            path: string | null;
+            port: number;
+            inboundUuid: string;
+            viewPosition: number;
+            remark: string;
+            address: string;
+            sni: string | null;
+            host: string | null;
+            alpn: string | null;
+            fingerprint: string | null;
+            allowInsecure: boolean;
+            isDisabled: boolean;
+            securityLayer: "DEFAULT" | "TLS" | "NONE";
+        }[];
+    }, {
+        response: {
+            uuid: string;
+            path: string | null;
+            port: number;
+            inboundUuid: string;
+            viewPosition: number;
+            remark: string;
+            address: string;
+            sni: string | null;
+            host: string | null;
+            alpn: string | null;
+            fingerprint: string | null;
+            allowInsecure?: boolean | undefined;
+            isDisabled?: boolean | undefined;
+            securityLayer?: "DEFAULT" | "TLS" | "NONE" | undefined;
+        }[];
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+//# sourceMappingURL=delete-many-hosts.command.d.ts.map

package/build/backend/commands/hosts/bulk/delete-many-hosts.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-many-hosts.command.d.ts","sourceRoot":"","sources":["../../../../../commands/hosts/bulk/delete-many-hosts.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,yBAAiB,sBAAsB,CAAC;IAC7B,MAAM,GAAG,0BAAmC,CAAC;IAC7C,MAAM,OAAO,0BAAM,CAAC;IAEpB,MAAM,aAAa;;;;;;MAExB,CAAC;IAEH,KAAY,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IAE7C,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/backend/commands/hosts/bulk/delete-many-hosts.command.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BulkDeleteHostsCommand = void 0;
+const zod_1 = require("zod");
+const models_1 = require("../../../models");
+const api_1 = require("../../../api");
+var BulkDeleteHostsCommand;
+(function (BulkDeleteHostsCommand) {
+    BulkDeleteHostsCommand.url = api_1.REST_API.HOSTS.BULK.DELETE_HOSTS;
+    BulkDeleteHostsCommand.TSQ_url = BulkDeleteHostsCommand.url;
+    BulkDeleteHostsCommand.RequestSchema = zod_1.z.object({
+        uuids: zod_1.z.array(zod_1.z.string().uuid()),
+    });
+    BulkDeleteHostsCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.array(models_1.HostsSchema),
+    });
+})(BulkDeleteHostsCommand || (exports.BulkDeleteHostsCommand = BulkDeleteHostsCommand = {}));

package/build/backend/commands/hosts/bulk/disable-many-hosts.command.d.ts

@@ -0,0 +1,101 @@
+import { z } from 'zod';
+export declare namespace BulkDisableHostsCommand {
+    const url: "/api/hosts/bulk/disable";
+    const TSQ_url: "/api/hosts/bulk/disable";
+    const RequestSchema: z.ZodObject<{
+        uuids: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        uuids: string[];
+    }, {
+        uuids: string[];
+    }>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        response: z.ZodArray<z.ZodObject<{
+            uuid: z.ZodString;
+            inboundUuid: z.ZodString;
+            viewPosition: z.ZodNumber;
+            remark: z.ZodString;
+            address: z.ZodString;
+            port: z.ZodNumber;
+            path: z.ZodNullable<z.ZodString>;
+            sni: z.ZodNullable<z.ZodString>;
+            host: z.ZodNullable<z.ZodString>;
+            alpn: z.ZodNullable<z.ZodString>;
+            fingerprint: z.ZodNullable<z.ZodString>;
+            allowInsecure: z.ZodDefault<z.ZodBoolean>;
+            isDisabled: z.ZodDefault<z.ZodBoolean>;
+            securityLayer: z.ZodDefault<z.ZodNativeEnum<{
+                readonly DEFAULT: "DEFAULT";
+                readonly TLS: "TLS";
+                readonly NONE: "NONE";
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            uuid: string;
+            path: string | null;
+            port: number;
+            inboundUuid: string;
+            viewPosition: number;
+            remark: string;
+            address: string;
+            sni: string | null;
+            host: string | null;
+            alpn: string | null;
+            fingerprint: string | null;
+            allowInsecure: boolean;
+            isDisabled: boolean;
+            securityLayer: "DEFAULT" | "TLS" | "NONE";
+        }, {
+            uuid: string;
+            path: string | null;
+            port: number;
+            inboundUuid: string;
+            viewPosition: number;
+            remark: string;
+            address: string;
+            sni: string | null;
+            host: string | null;
+            alpn: string | null;
+            fingerprint: string | null;
+            allowInsecure?: boolean | undefined;
+            isDisabled?: boolean | undefined;
+            securityLayer?: "DEFAULT" | "TLS" | "NONE" | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        response: {
+            uuid: string;
+            path: string | null;
+            port: number;
+            inboundUuid: string;
+            viewPosition: number;
+            remark: string;
+            address: string;
+            sni: string | null;
+            host: string | null;
+            alpn: string | null;
+            fingerprint: string | null;
+            allowInsecure: boolean;
+            isDisabled: boolean;
+            securityLayer: "DEFAULT" | "TLS" | "NONE";
+        }[];
+    }, {
+        response: {
+            uuid: string;
+            path: string | null;
+            port: number;
+            inboundUuid: string;
+            viewPosition: number;
+            remark: string;
+            address: string;
+            sni: string | null;
+            host: string | null;
+            alpn: string | null;
+            fingerprint: string | null;
+            allowInsecure?: boolean | undefined;
+            isDisabled?: boolean | undefined;
+            securityLayer?: "DEFAULT" | "TLS" | "NONE" | undefined;
+        }[];
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+//# sourceMappingURL=disable-many-hosts.command.d.ts.map

package/build/backend/commands/hosts/bulk/disable-many-hosts.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"disable-many-hosts.command.d.ts","sourceRoot":"","sources":["../../../../../commands/hosts/bulk/disable-many-hosts.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,yBAAiB,uBAAuB,CAAC;IAC9B,MAAM,GAAG,2BAAoC,CAAC;IAC9C,MAAM,OAAO,2BAAM,CAAC;IAEpB,MAAM,aAAa;;;;;;MAExB,CAAC;IAEH,KAAY,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IAE7C,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/backend/commands/hosts/bulk/disable-many-hosts.command.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BulkDisableHostsCommand = void 0;
+const zod_1 = require("zod");
+const models_1 = require("../../../models");
+const api_1 = require("../../../api");
+var BulkDisableHostsCommand;
+(function (BulkDisableHostsCommand) {
+    BulkDisableHostsCommand.url = api_1.REST_API.HOSTS.BULK.DISABLE_HOSTS;
+    BulkDisableHostsCommand.TSQ_url = BulkDisableHostsCommand.url;
+    BulkDisableHostsCommand.RequestSchema = zod_1.z.object({
+        uuids: zod_1.z.array(zod_1.z.string().uuid()),
+    });
+    BulkDisableHostsCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.array(models_1.HostsSchema),
+    });
+})(BulkDisableHostsCommand || (exports.BulkDisableHostsCommand = BulkDisableHostsCommand = {}));

package/build/backend/commands/hosts/bulk/enable-many-hosts.command.d.ts

@@ -0,0 +1,101 @@
+import { z } from 'zod';
+export declare namespace BulkEnableHostsCommand {
+    const url: "/api/hosts/bulk/enable";
+    const TSQ_url: "/api/hosts/bulk/enable";
+    const RequestSchema: z.ZodObject<{
+        uuids: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        uuids: string[];
+    }, {
+        uuids: string[];
+    }>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        response: z.ZodArray<z.ZodObject<{
+            uuid: z.ZodString;
+            inboundUuid: z.ZodString;
+            viewPosition: z.ZodNumber;
+            remark: z.ZodString;
+            address: z.ZodString;
+            port: z.ZodNumber;
+            path: z.ZodNullable<z.ZodString>;
+            sni: z.ZodNullable<z.ZodString>;
+            host: z.ZodNullable<z.ZodString>;
+            alpn: z.ZodNullable<z.ZodString>;
+            fingerprint: z.ZodNullable<z.ZodString>;
+            allowInsecure: z.ZodDefault<z.ZodBoolean>;
+            isDisabled: z.ZodDefault<z.ZodBoolean>;
+            securityLayer: z.ZodDefault<z.ZodNativeEnum<{
+                readonly DEFAULT: "DEFAULT";
+                readonly TLS: "TLS";
+                readonly NONE: "NONE";
+            }>>;
+        }, "strip", z.ZodTypeAny, {
+            uuid: string;
+            path: string | null;
+            port: number;
+            inboundUuid: string;
+            viewPosition: number;
+            remark: string;
+            address: string;
+            sni: string | null;
+            host: string | null;
+            alpn: string | null;
+            fingerprint: string | null;
+            allowInsecure: boolean;
+            isDisabled: boolean;
+            securityLayer: "DEFAULT" | "TLS" | "NONE";
+        }, {
+            uuid: string;
+            path: string | null;
+            port: number;
+            inboundUuid: string;
+            viewPosition: number;
+            remark: string;
+            address: string;
+            sni: string | null;
+            host: string | null;
+            alpn: string | null;
+            fingerprint: string | null;
+            allowInsecure?: boolean | undefined;
+            isDisabled?: boolean | undefined;
+            securityLayer?: "DEFAULT" | "TLS" | "NONE" | undefined;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        response: {
+            uuid: string;
+            path: string | null;
+            port: number;
+            inboundUuid: string;
+            viewPosition: number;
+            remark: string;
+            address: string;
+            sni: string | null;
+            host: string | null;
+            alpn: string | null;
+            fingerprint: string | null;
+            allowInsecure: boolean;
+            isDisabled: boolean;
+            securityLayer: "DEFAULT" | "TLS" | "NONE";
+        }[];
+    }, {
+        response: {
+            uuid: string;
+            path: string | null;
+            port: number;
+            inboundUuid: string;
+            viewPosition: number;
+            remark: string;
+            address: string;
+            sni: string | null;
+            host: string | null;
+            alpn: string | null;
+            fingerprint: string | null;
+            allowInsecure?: boolean | undefined;
+            isDisabled?: boolean | undefined;
+            securityLayer?: "DEFAULT" | "TLS" | "NONE" | undefined;
+        }[];
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+//# sourceMappingURL=enable-many-hosts.command.d.ts.map

package/build/backend/commands/hosts/bulk/enable-many-hosts.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enable-many-hosts.command.d.ts","sourceRoot":"","sources":["../../../../../commands/hosts/bulk/enable-many-hosts.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,yBAAiB,sBAAsB,CAAC;IAC7B,MAAM,GAAG,0BAAmC,CAAC;IAC7C,MAAM,OAAO,0BAAM,CAAC;IAEpB,MAAM,aAAa;;;;;;MAExB,CAAC;IAEH,KAAY,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;IAE7C,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/backend/commands/hosts/bulk/enable-many-hosts.command.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BulkEnableHostsCommand = void 0;
+const zod_1 = require("zod");
+const models_1 = require("../../../models");
+const api_1 = require("../../../api");
+var BulkEnableHostsCommand;
+(function (BulkEnableHostsCommand) {
+    BulkEnableHostsCommand.url = api_1.REST_API.HOSTS.BULK.ENABLE_HOSTS;
+    BulkEnableHostsCommand.TSQ_url = BulkEnableHostsCommand.url;
+    BulkEnableHostsCommand.RequestSchema = zod_1.z.object({
+        uuids: zod_1.z.array(zod_1.z.string().uuid()),
+    });
+    BulkEnableHostsCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.array(models_1.HostsSchema),
+    });
+})(BulkEnableHostsCommand || (exports.BulkEnableHostsCommand = BulkEnableHostsCommand = {}));

package/build/backend/commands/hosts/bulk/index.d.ts

@@ -0,0 +1,4 @@
+export * from './delete-many-hosts.command';
+export * from './disable-many-hosts.command';
+export * from './enable-many-hosts.command';
+//# sourceMappingURL=index.d.ts.map

package/build/backend/commands/hosts/bulk/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../commands/hosts/bulk/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC"}

package/build/backend/commands/hosts/bulk/index.js

@@ -0,0 +1,19 @@
+"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("./delete-many-hosts.command"), exports);
+__exportStar(require("./disable-many-hosts.command"), exports);
+__exportStar(require("./enable-many-hosts.command"), exports);

package/build/backend/commands/hosts/index.d.ts

@@ -1,3 +1,4 @@
+export * from './bulk';
 export * from './create.command';
 export * from './delete.command';
 export * from './get-all.command';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../commands/hosts/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../commands/hosts/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC"}

package/build/backend/commands/hosts/index.js

@@ -14,6 +14,7 @@ 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("./bulk"), exports);
 __exportStar(require("./create.command"), exports);
 __exportStar(require("./delete.command"), exports);
 __exportStar(require("./get-all.command"), exports);

package/build/backend/commands/inbounds/bulk/add-inbound-to-nodes.command.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+export declare namespace AddInboundToNodesCommand {
+    const url: "/api/inbounds/bulk/add-to-nodes";
+    const TSQ_url: "/api/inbounds/bulk/add-to-nodes";
+    const RequestSchema: z.ZodObject<{
+        inboundUuid: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        inboundUuid: string;
+    }, {
+        inboundUuid: string;
+    }>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        response: z.ZodObject<{
+            isSuccess: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            isSuccess: boolean;
+        }, {
+            isSuccess: boolean;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        response: {
+            isSuccess: boolean;
+        };
+    }, {
+        response: {
+            isSuccess: boolean;
+        };
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+//# sourceMappingURL=add-inbound-to-nodes.command.d.ts.map

package/build/backend/commands/inbounds/bulk/add-inbound-to-nodes.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-inbound-to-nodes.command.d.ts","sourceRoot":"","sources":["../../../../../commands/inbounds/bulk/add-inbound-to-nodes.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,yBAAiB,wBAAwB,CAAC;IAC/B,MAAM,GAAG,mCAA8C,CAAC;IACxD,MAAM,OAAO,mCAAM,CAAC;IAEpB,MAAM,aAAa;;;;;;MAMxB,CAAC;IACH,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/backend/commands/inbounds/bulk/add-inbound-to-nodes.command.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddInboundToNodesCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../../api");
+var AddInboundToNodesCommand;
+(function (AddInboundToNodesCommand) {
+    AddInboundToNodesCommand.url = api_1.REST_API.INBOUNDS.BULK.ADD_INBOUND_TO_NODES;
+    AddInboundToNodesCommand.TSQ_url = AddInboundToNodesCommand.url;
+    AddInboundToNodesCommand.RequestSchema = zod_1.z.object({
+        inboundUuid: zod_1.z
+            .string({
+            invalid_type_error: 'Inbound UUID must be a string',
+        })
+            .uuid('Inbound UUID must be a valid UUID'),
+    });
+    AddInboundToNodesCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.object({
+            isSuccess: zod_1.z.boolean(),
+        }),
+    });
+})(AddInboundToNodesCommand || (exports.AddInboundToNodesCommand = AddInboundToNodesCommand = {}));

package/build/backend/commands/inbounds/bulk/add-inbound-to-users.command.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+export declare namespace AddInboundToUsersCommand {
+    const url: "/api/inbounds/bulk/add-to-users";
+    const TSQ_url: "/api/inbounds/bulk/add-to-users";
+    const RequestSchema: z.ZodObject<{
+        inboundUuid: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        inboundUuid: string;
+    }, {
+        inboundUuid: string;
+    }>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        response: z.ZodObject<{
+            isSuccess: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            isSuccess: boolean;
+        }, {
+            isSuccess: boolean;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        response: {
+            isSuccess: boolean;
+        };
+    }, {
+        response: {
+            isSuccess: boolean;
+        };
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+//# sourceMappingURL=add-inbound-to-users.command.d.ts.map

package/build/backend/commands/inbounds/bulk/add-inbound-to-users.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-inbound-to-users.command.d.ts","sourceRoot":"","sources":["../../../../../commands/inbounds/bulk/add-inbound-to-users.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,yBAAiB,wBAAwB,CAAC;IAC/B,MAAM,GAAG,mCAA8C,CAAC;IACxD,MAAM,OAAO,mCAAM,CAAC;IAEpB,MAAM,aAAa;;;;;;MAMxB,CAAC;IACH,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/backend/commands/inbounds/bulk/add-inbound-to-users.command.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddInboundToUsersCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../../api");
+var AddInboundToUsersCommand;
+(function (AddInboundToUsersCommand) {
+    AddInboundToUsersCommand.url = api_1.REST_API.INBOUNDS.BULK.ADD_INBOUND_TO_USERS;
+    AddInboundToUsersCommand.TSQ_url = AddInboundToUsersCommand.url;
+    AddInboundToUsersCommand.RequestSchema = zod_1.z.object({
+        inboundUuid: zod_1.z
+            .string({
+            invalid_type_error: 'Inbound UUID must be a string',
+        })
+            .uuid('Inbound UUID must be a valid UUID'),
+    });
+    AddInboundToUsersCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.object({
+            isSuccess: zod_1.z.boolean(),
+        }),
+    });
+})(AddInboundToUsersCommand || (exports.AddInboundToUsersCommand = AddInboundToUsersCommand = {}));

package/build/backend/commands/inbounds/bulk/index.d.ts

@@ -0,0 +1,5 @@
+export * from './add-inbound-to-nodes.command';
+export * from './add-inbound-to-users.command';
+export * from './remove-inbound-from-nodes.command';
+export * from './remove-inbound-from-users.command';
+//# sourceMappingURL=index.d.ts.map

package/build/backend/commands/inbounds/bulk/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../commands/inbounds/bulk/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qCAAqC,CAAC;AACpD,cAAc,qCAAqC,CAAC"}

package/build/backend/commands/inbounds/bulk/index.js

@@ -0,0 +1,20 @@
+"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("./add-inbound-to-nodes.command"), exports);
+__exportStar(require("./add-inbound-to-users.command"), exports);
+__exportStar(require("./remove-inbound-from-nodes.command"), exports);
+__exportStar(require("./remove-inbound-from-users.command"), exports);

package/build/backend/commands/inbounds/bulk/remove-inbound-from-nodes.command.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+export declare namespace RemoveInboundFromNodesCommand {
+    const url: "/api/inbounds/bulk/remove-from-nodes";
+    const TSQ_url: "/api/inbounds/bulk/remove-from-nodes";
+    const RequestSchema: z.ZodObject<{
+        inboundUuid: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        inboundUuid: string;
+    }, {
+        inboundUuid: string;
+    }>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        response: z.ZodObject<{
+            isSuccess: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            isSuccess: boolean;
+        }, {
+            isSuccess: boolean;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        response: {
+            isSuccess: boolean;
+        };
+    }, {
+        response: {
+            isSuccess: boolean;
+        };
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+//# sourceMappingURL=remove-inbound-from-nodes.command.d.ts.map

package/build/backend/commands/inbounds/bulk/remove-inbound-from-nodes.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-inbound-from-nodes.command.d.ts","sourceRoot":"","sources":["../../../../../commands/inbounds/bulk/remove-inbound-from-nodes.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,yBAAiB,6BAA6B,CAAC;IACpC,MAAM,GAAG,wCAAmD,CAAC;IAC7D,MAAM,OAAO,wCAAM,CAAC;IAEpB,MAAM,aAAa;;;;;;MAMxB,CAAC;IACH,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/backend/commands/inbounds/bulk/remove-inbound-from-nodes.command.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoveInboundFromNodesCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../../api");
+var RemoveInboundFromNodesCommand;
+(function (RemoveInboundFromNodesCommand) {
+    RemoveInboundFromNodesCommand.url = api_1.REST_API.INBOUNDS.BULK.REMOVE_INBOUND_FROM_NODES;
+    RemoveInboundFromNodesCommand.TSQ_url = RemoveInboundFromNodesCommand.url;
+    RemoveInboundFromNodesCommand.RequestSchema = zod_1.z.object({
+        inboundUuid: zod_1.z
+            .string({
+            invalid_type_error: 'Inbound UUID must be a string',
+        })
+            .uuid('Inbound UUID must be a valid UUID'),
+    });
+    RemoveInboundFromNodesCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.object({
+            isSuccess: zod_1.z.boolean(),
+        }),
+    });
+})(RemoveInboundFromNodesCommand || (exports.RemoveInboundFromNodesCommand = RemoveInboundFromNodesCommand = {}));

package/build/backend/commands/inbounds/bulk/remove-inbound-from-users.command.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+export declare namespace RemoveInboundFromUsersCommand {
+    const url: "/api/inbounds/bulk/remove-from-users";
+    const TSQ_url: "/api/inbounds/bulk/remove-from-users";
+    const RequestSchema: z.ZodObject<{
+        inboundUuid: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        inboundUuid: string;
+    }, {
+        inboundUuid: string;
+    }>;
+    type Request = z.infer<typeof RequestSchema>;
+    const ResponseSchema: z.ZodObject<{
+        response: z.ZodObject<{
+            isSuccess: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            isSuccess: boolean;
+        }, {
+            isSuccess: boolean;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        response: {
+            isSuccess: boolean;
+        };
+    }, {
+        response: {
+            isSuccess: boolean;
+        };
+    }>;
+    type Response = z.infer<typeof ResponseSchema>;
+}
+//# sourceMappingURL=remove-inbound-from-users.command.d.ts.map

package/build/backend/commands/inbounds/bulk/remove-inbound-from-users.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remove-inbound-from-users.command.d.ts","sourceRoot":"","sources":["../../../../../commands/inbounds/bulk/remove-inbound-from-users.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,yBAAiB,6BAA6B,CAAC;IACpC,MAAM,GAAG,wCAAmD,CAAC;IAC7D,MAAM,OAAO,wCAAM,CAAC;IAEpB,MAAM,aAAa;;;;;;MAMxB,CAAC;IACH,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/backend/commands/inbounds/bulk/remove-inbound-from-users.command.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoveInboundFromUsersCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../../api");
+var RemoveInboundFromUsersCommand;
+(function (RemoveInboundFromUsersCommand) {
+    RemoveInboundFromUsersCommand.url = api_1.REST_API.INBOUNDS.BULK.REMOVE_INBOUND_FROM_USERS;
+    RemoveInboundFromUsersCommand.TSQ_url = RemoveInboundFromUsersCommand.url;
+    RemoveInboundFromUsersCommand.RequestSchema = zod_1.z.object({
+        inboundUuid: zod_1.z
+            .string({
+            invalid_type_error: 'Inbound UUID must be a string',
+        })
+            .uuid('Inbound UUID must be a valid UUID'),
+    });
+    RemoveInboundFromUsersCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.object({
+            isSuccess: zod_1.z.boolean(),
+        }),
+    });
+})(RemoveInboundFromUsersCommand || (exports.RemoveInboundFromUsersCommand = RemoveInboundFromUsersCommand = {}));

package/build/backend/commands/inbounds/index.d.ts

@@ -1,3 +1,4 @@
+export * from './bulk';
 export * from './get-full-inbounds.command';
 export * from './get-inbounds.command';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../commands/inbounds/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../commands/inbounds/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wBAAwB,CAAC"}

package/build/backend/commands/inbounds/index.js

@@ -14,5 +14,6 @@ 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("./bulk"), exports);
 __exportStar(require("./get-full-inbounds.command"), exports);
 __exportStar(require("./get-inbounds.command"), exports);

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

@@ -389,5 +389,45 @@ export declare const ERRORS: {
         readonly message: "Update subscription settings error";
         readonly httpCode: 500;
     };
+    readonly ADD_INBOUND_TO_USERS_ERROR: {
+        readonly code: "A074";
+        readonly message: "Add inbound to users error";
+        readonly httpCode: 500;
+    };
+    readonly REMOVE_INBOUND_FROM_USERS_ERROR: {
+        readonly code: "A075";
+        readonly message: "Remove inbound from users error";
+        readonly httpCode: 500;
+    };
+    readonly INBOUND_NOT_FOUND: {
+        readonly code: "A076";
+        readonly message: "Inbound not found";
+        readonly httpCode: 404;
+    };
+    readonly ADD_INBOUND_TO_NODES_ERROR: {
+        readonly code: "A077";
+        readonly message: "Add inbound to nodes error";
+        readonly httpCode: 500;
+    };
+    readonly REMOVE_INBOUND_FROM_NODES_ERROR: {
+        readonly code: "A078";
+        readonly message: "Remove inbound from nodes error";
+        readonly httpCode: 500;
+    };
+    readonly DELETE_HOSTS_ERROR: {
+        readonly code: "A079";
+        readonly message: "Delete hosts error";
+        readonly httpCode: 500;
+    };
+    readonly BULK_ENABLE_HOSTS_ERROR: {
+        readonly code: "A080";
+        readonly message: "Bulk enable hosts error";
+        readonly httpCode: 500;
+    };
+    readonly BULK_DISABLE_HOSTS_ERROR: {
+        readonly code: "A081";
+        readonly message: "Bulk disable hosts error";
+        readonly httpCode: 500;
+    };
 };
 //# sourceMappingURL=errors.d.ts.map

package/build/backend/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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAwJY,MAAM;;;;;;;;;;wCAUN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCA4IN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0D3B,CAAC"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../constants/errors/errors.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCAwJY,MAAM;;;;;;;;;;wCAUN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wCA4IN,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkG3B,CAAC"}

package/build/backend/constants/errors/errors.js

@@ -360,4 +360,44 @@ exports.ERRORS = {
         message: 'Update subscription settings error',
         httpCode: 500,
     },
+    ADD_INBOUND_TO_USERS_ERROR: {
+        code: 'A074',
+        message: 'Add inbound to users error',
+        httpCode: 500,
+    },
+    REMOVE_INBOUND_FROM_USERS_ERROR: {
+        code: 'A075',
+        message: 'Remove inbound from users error',
+        httpCode: 500,
+    },
+    INBOUND_NOT_FOUND: {
+        code: 'A076',
+        message: 'Inbound not found',
+        httpCode: 404,
+    },
+    ADD_INBOUND_TO_NODES_ERROR: {
+        code: 'A077',
+        message: 'Add inbound to nodes error',
+        httpCode: 500,
+    },
+    REMOVE_INBOUND_FROM_NODES_ERROR: {
+        code: 'A078',
+        message: 'Remove inbound from nodes error',
+        httpCode: 500,
+    },
+    DELETE_HOSTS_ERROR: {
+        code: 'A079',
+        message: 'Delete hosts error',
+        httpCode: 500,
+    },
+    BULK_ENABLE_HOSTS_ERROR: {
+        code: 'A080',
+        message: 'Bulk enable hosts error',
+        httpCode: 500,
+    },
+    BULK_DISABLE_HOSTS_ERROR: {
+        code: 'A081',
+        message: 'Bulk disable hosts error',
+        httpCode: 500,
+    },
 };

package/build/frontend/api/controllers/hosts.js

@@ -10,4 +10,9 @@ exports.HOSTS_ROUTES = {
     UPDATE_MANY: 'many',
     REORDER: 'reorder',
     GET_ONE: 'get-one',
+    BULK: {
+        ENABLE_HOSTS: 'bulk/enable',
+        DISABLE_HOSTS: 'bulk/disable',
+        DELETE_HOSTS: 'bulk/delete',
+    },
 };

package/build/frontend/api/routes.js

@@ -114,6 +114,11 @@ exports.REST_API = {
         REORDER: `${exports.ROOT}/${CONTROLLERS.HOSTS_CONTROLLER}/${CONTROLLERS.HOSTS_ROUTES.REORDER}`,
         DELETE: (uuid) => `${exports.ROOT}/${CONTROLLERS.HOSTS_CONTROLLER}/${CONTROLLERS.HOSTS_ROUTES.DELETE}/${uuid}`,
         GET_ONE: (uuid) => `${exports.ROOT}/${CONTROLLERS.HOSTS_CONTROLLER}/${CONTROLLERS.HOSTS_ROUTES.GET_ONE}/${uuid}`,
+        BULK: {
+            ENABLE_HOSTS: `${exports.ROOT}/${CONTROLLERS.HOSTS_CONTROLLER}/${CONTROLLERS.HOSTS_ROUTES.BULK.ENABLE_HOSTS}`,
+            DISABLE_HOSTS: `${exports.ROOT}/${CONTROLLERS.HOSTS_CONTROLLER}/${CONTROLLERS.HOSTS_ROUTES.BULK.DISABLE_HOSTS}`,
+            DELETE_HOSTS: `${exports.ROOT}/${CONTROLLERS.HOSTS_CONTROLLER}/${CONTROLLERS.HOSTS_ROUTES.BULK.DELETE_HOSTS}`,
+        },
     },
     SYSTEM: {
         STATS: `${exports.ROOT}/${CONTROLLERS.SYSTEM_CONTROLLER}/${CONTROLLERS.SYSTEM_ROUTES.STATS}`,

package/build/frontend/commands/hosts/bulk/delete-many-hosts.command.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BulkDeleteHostsCommand = void 0;
+const zod_1 = require("zod");
+const models_1 = require("../../../models");
+const api_1 = require("../../../api");
+var BulkDeleteHostsCommand;
+(function (BulkDeleteHostsCommand) {
+    BulkDeleteHostsCommand.url = api_1.REST_API.HOSTS.BULK.DELETE_HOSTS;
+    BulkDeleteHostsCommand.TSQ_url = BulkDeleteHostsCommand.url;
+    BulkDeleteHostsCommand.RequestSchema = zod_1.z.object({
+        uuids: zod_1.z.array(zod_1.z.string().uuid()),
+    });
+    BulkDeleteHostsCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.array(models_1.HostsSchema),
+    });
+})(BulkDeleteHostsCommand || (exports.BulkDeleteHostsCommand = BulkDeleteHostsCommand = {}));

package/build/frontend/commands/hosts/bulk/disable-many-hosts.command.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BulkDisableHostsCommand = void 0;
+const zod_1 = require("zod");
+const models_1 = require("../../../models");
+const api_1 = require("../../../api");
+var BulkDisableHostsCommand;
+(function (BulkDisableHostsCommand) {
+    BulkDisableHostsCommand.url = api_1.REST_API.HOSTS.BULK.DISABLE_HOSTS;
+    BulkDisableHostsCommand.TSQ_url = BulkDisableHostsCommand.url;
+    BulkDisableHostsCommand.RequestSchema = zod_1.z.object({
+        uuids: zod_1.z.array(zod_1.z.string().uuid()),
+    });
+    BulkDisableHostsCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.array(models_1.HostsSchema),
+    });
+})(BulkDisableHostsCommand || (exports.BulkDisableHostsCommand = BulkDisableHostsCommand = {}));

package/build/frontend/commands/hosts/bulk/enable-many-hosts.command.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BulkEnableHostsCommand = void 0;
+const zod_1 = require("zod");
+const models_1 = require("../../../models");
+const api_1 = require("../../../api");
+var BulkEnableHostsCommand;
+(function (BulkEnableHostsCommand) {
+    BulkEnableHostsCommand.url = api_1.REST_API.HOSTS.BULK.ENABLE_HOSTS;
+    BulkEnableHostsCommand.TSQ_url = BulkEnableHostsCommand.url;
+    BulkEnableHostsCommand.RequestSchema = zod_1.z.object({
+        uuids: zod_1.z.array(zod_1.z.string().uuid()),
+    });
+    BulkEnableHostsCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.array(models_1.HostsSchema),
+    });
+})(BulkEnableHostsCommand || (exports.BulkEnableHostsCommand = BulkEnableHostsCommand = {}));

package/build/frontend/commands/hosts/bulk/index.js

@@ -0,0 +1,19 @@
+"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("./delete-many-hosts.command"), exports);
+__exportStar(require("./disable-many-hosts.command"), exports);
+__exportStar(require("./enable-many-hosts.command"), exports);

package/build/frontend/commands/hosts/index.js

@@ -14,6 +14,7 @@ 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("./bulk"), exports);
 __exportStar(require("./create.command"), exports);
 __exportStar(require("./delete.command"), exports);
 __exportStar(require("./get-all.command"), exports);

package/build/frontend/commands/inbounds/bulk/add-inbound-to-nodes.command.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddInboundToNodesCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../../api");
+var AddInboundToNodesCommand;
+(function (AddInboundToNodesCommand) {
+    AddInboundToNodesCommand.url = api_1.REST_API.INBOUNDS.BULK.ADD_INBOUND_TO_NODES;
+    AddInboundToNodesCommand.TSQ_url = AddInboundToNodesCommand.url;
+    AddInboundToNodesCommand.RequestSchema = zod_1.z.object({
+        inboundUuid: zod_1.z
+            .string({
+            invalid_type_error: 'Inbound UUID must be a string',
+        })
+            .uuid('Inbound UUID must be a valid UUID'),
+    });
+    AddInboundToNodesCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.object({
+            isSuccess: zod_1.z.boolean(),
+        }),
+    });
+})(AddInboundToNodesCommand || (exports.AddInboundToNodesCommand = AddInboundToNodesCommand = {}));

package/build/frontend/commands/inbounds/bulk/add-inbound-to-users.command.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddInboundToUsersCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../../api");
+var AddInboundToUsersCommand;
+(function (AddInboundToUsersCommand) {
+    AddInboundToUsersCommand.url = api_1.REST_API.INBOUNDS.BULK.ADD_INBOUND_TO_USERS;
+    AddInboundToUsersCommand.TSQ_url = AddInboundToUsersCommand.url;
+    AddInboundToUsersCommand.RequestSchema = zod_1.z.object({
+        inboundUuid: zod_1.z
+            .string({
+            invalid_type_error: 'Inbound UUID must be a string',
+        })
+            .uuid('Inbound UUID must be a valid UUID'),
+    });
+    AddInboundToUsersCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.object({
+            isSuccess: zod_1.z.boolean(),
+        }),
+    });
+})(AddInboundToUsersCommand || (exports.AddInboundToUsersCommand = AddInboundToUsersCommand = {}));

package/build/frontend/commands/inbounds/bulk/index.js

@@ -0,0 +1,20 @@
+"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("./add-inbound-to-nodes.command"), exports);
+__exportStar(require("./add-inbound-to-users.command"), exports);
+__exportStar(require("./remove-inbound-from-nodes.command"), exports);
+__exportStar(require("./remove-inbound-from-users.command"), exports);

package/build/frontend/commands/inbounds/bulk/remove-inbound-from-nodes.command.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoveInboundFromNodesCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../../api");
+var RemoveInboundFromNodesCommand;
+(function (RemoveInboundFromNodesCommand) {
+    RemoveInboundFromNodesCommand.url = api_1.REST_API.INBOUNDS.BULK.REMOVE_INBOUND_FROM_NODES;
+    RemoveInboundFromNodesCommand.TSQ_url = RemoveInboundFromNodesCommand.url;
+    RemoveInboundFromNodesCommand.RequestSchema = zod_1.z.object({
+        inboundUuid: zod_1.z
+            .string({
+            invalid_type_error: 'Inbound UUID must be a string',
+        })
+            .uuid('Inbound UUID must be a valid UUID'),
+    });
+    RemoveInboundFromNodesCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.object({
+            isSuccess: zod_1.z.boolean(),
+        }),
+    });
+})(RemoveInboundFromNodesCommand || (exports.RemoveInboundFromNodesCommand = RemoveInboundFromNodesCommand = {}));

package/build/frontend/commands/inbounds/bulk/remove-inbound-from-users.command.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RemoveInboundFromUsersCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../../api");
+var RemoveInboundFromUsersCommand;
+(function (RemoveInboundFromUsersCommand) {
+    RemoveInboundFromUsersCommand.url = api_1.REST_API.INBOUNDS.BULK.REMOVE_INBOUND_FROM_USERS;
+    RemoveInboundFromUsersCommand.TSQ_url = RemoveInboundFromUsersCommand.url;
+    RemoveInboundFromUsersCommand.RequestSchema = zod_1.z.object({
+        inboundUuid: zod_1.z
+            .string({
+            invalid_type_error: 'Inbound UUID must be a string',
+        })
+            .uuid('Inbound UUID must be a valid UUID'),
+    });
+    RemoveInboundFromUsersCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.object({
+            isSuccess: zod_1.z.boolean(),
+        }),
+    });
+})(RemoveInboundFromUsersCommand || (exports.RemoveInboundFromUsersCommand = RemoveInboundFromUsersCommand = {}));

package/build/frontend/commands/inbounds/index.js

@@ -14,5 +14,6 @@ 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("./bulk"), exports);
 __exportStar(require("./get-full-inbounds.command"), exports);
 __exportStar(require("./get-inbounds.command"), exports);

package/build/frontend/constants/errors/errors.js

@@ -360,4 +360,44 @@ exports.ERRORS = {
         message: 'Update subscription settings error',
         httpCode: 500,
     },
+    ADD_INBOUND_TO_USERS_ERROR: {
+        code: 'A074',
+        message: 'Add inbound to users error',
+        httpCode: 500,
+    },
+    REMOVE_INBOUND_FROM_USERS_ERROR: {
+        code: 'A075',
+        message: 'Remove inbound from users error',
+        httpCode: 500,
+    },
+    INBOUND_NOT_FOUND: {
+        code: 'A076',
+        message: 'Inbound not found',
+        httpCode: 404,
+    },
+    ADD_INBOUND_TO_NODES_ERROR: {
+        code: 'A077',
+        message: 'Add inbound to nodes error',
+        httpCode: 500,
+    },
+    REMOVE_INBOUND_FROM_NODES_ERROR: {
+        code: 'A078',
+        message: 'Remove inbound from nodes error',
+        httpCode: 500,
+    },
+    DELETE_HOSTS_ERROR: {
+        code: 'A079',
+        message: 'Delete hosts error',
+        httpCode: 500,
+    },
+    BULK_ENABLE_HOSTS_ERROR: {
+        code: 'A080',
+        message: 'Bulk enable hosts error',
+        httpCode: 500,
+    },
+    BULK_DISABLE_HOSTS_ERROR: {
+        code: 'A081',
+        message: 'Bulk disable hosts error',
+        httpCode: 500,
+    },
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnawave/backend-contract",
-  "version": "0.3.33",
+  "version": "0.3.35",
   "public": true,
   "license": "AGPL-3.0-only",
   "description": "A contract library for Remnawave Backend. It can be used in backend and frontend.",