@remnawave/backend-contract 2.8.34 → 2.9.0

package/build/backend/commands/external-squads/create-external-squad.command.js

@@ -10,7 +10,7 @@ var CreateExternalSquadCommand;
     CreateExternalSquadCommand.url = api_1.REST_API.EXTERNAL_SQUADS.CREATE;
     CreateExternalSquadCommand.TSQ_url = CreateExternalSquadCommand.url;
     CreateExternalSquadCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.EXTERNAL_SQUADS_ROUTES.CREATE, 'post', 'Create external squad', { scope: 'create', kind: 'write' });
-    CreateExternalSquadCommand.RequestSchema = zod_1.z.object({
+    CreateExternalSquadCommand.RequestBodySchema = zod_1.z.object({
         name: zod_1.z
             .string()
             .min(2, 'Name must be at least 2 characters')

package/build/backend/commands/external-squads/delete-external-squad.command.d.ts

@@ -3,14 +3,13 @@ export declare namespace DeleteExternalSquadCommand {
     const url: (uuid: string) => string;
     const TSQ_url: string;
     const endpointDetails: import("../../constants").EndpointDetails;
-    const RequestSchema: z.ZodObject<{
+    const RequestParamSchema: z.ZodObject<{
         uuid: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         uuid: string;
     }, {
         uuid: string;
     }>;
-    type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{
         response: z.ZodObject<{
             isDeleted: z.ZodBoolean;
@@ -28,6 +27,7 @@ export declare namespace DeleteExternalSquadCommand {
             isDeleted: boolean;
         };
     }>;
+    type RequestParam = z.infer<typeof RequestParamSchema>;
     type Response = z.infer<typeof ResponseSchema>;
 }
 //# sourceMappingURL=delete-external-squad.command.d.ts.map

package/build/backend/commands/external-squads/delete-external-squad.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"delete-external-squad.command.d.ts","sourceRoot":"","sources":["../../../../commands/external-squads/delete-external-squad.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,yBAAiB,0BAA0B,CAAC;IACjC,MAAM,GAAG,0BAAkC,CAAC;IAC5C,MAAM,OAAO,QAAe,CAAC;IAE7B,MAAM,eAAe,2CAK3B,CAAC;IAEK,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"}
+{"version":3,"file":"delete-external-squad.command.d.ts","sourceRoot":"","sources":["../../../../commands/external-squads/delete-external-squad.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,yBAAiB,0BAA0B,CAAC;IACjC,MAAM,GAAG,0BAAkC,CAAC;IAC5C,MAAM,OAAO,QAAe,CAAC;IAE7B,MAAM,eAAe,2CAK3B,CAAC;IAEK,MAAM,kBAAkB;;;;;;MAE7B,CAAC;IAEI,MAAM,cAAc;;;;;;;;;;;;;;;;MAIzB,CAAC;IAEH,KAAY,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;IAC9D,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/backend/commands/external-squads/delete-external-squad.command.js

@@ -9,8 +9,8 @@ var DeleteExternalSquadCommand;
     DeleteExternalSquadCommand.url = api_1.REST_API.EXTERNAL_SQUADS.DELETE;
     DeleteExternalSquadCommand.TSQ_url = DeleteExternalSquadCommand.url(':uuid');
     DeleteExternalSquadCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.EXTERNAL_SQUADS_ROUTES.DELETE(':uuid'), 'delete', 'Delete external squad', { scope: 'delete', kind: 'write' });
-    DeleteExternalSquadCommand.RequestSchema = zod_1.z.object({
-        uuid: zod_1.z.string().uuid(),
+    DeleteExternalSquadCommand.RequestParamSchema = zod_1.z.object({
+        uuid: zod_1.z.string().uuid().describe('UUID of the external squad'),
     });
     DeleteExternalSquadCommand.ResponseSchema = zod_1.z.object({
         response: zod_1.z.object({

package/build/backend/commands/external-squads/get-external-squad-by-uuid.command.d.ts

@@ -3,14 +3,13 @@ export declare namespace GetExternalSquadByUuidCommand {
     const url: (uuid: string) => string;
     const TSQ_url: string;
     const endpointDetails: import("../../constants").EndpointDetails;
-    const RequestSchema: z.ZodObject<{
+    const RequestParamSchema: z.ZodObject<{
         uuid: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         uuid: string;
     }, {
         uuid: string;
     }>;
-    type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{
         response: z.ZodObject<{
             uuid: z.ZodString;
@@ -298,6 +297,7 @@ export declare namespace GetExternalSquadByUuidCommand {
             subpageConfigUuid: string | null;
         };
     }>;
+    type RequestParam = z.infer<typeof RequestParamSchema>;
     type Response = z.infer<typeof ResponseSchema>;
 }
 //# sourceMappingURL=get-external-squad-by-uuid.command.d.ts.map

package/build/backend/commands/external-squads/get-external-squad-by-uuid.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-external-squad-by-uuid.command.d.ts","sourceRoot":"","sources":["../../../../commands/external-squads/get-external-squad-by-uuid.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,6BAA6B,CAAC;IACpC,MAAM,GAAG,0BAAuC,CAAC;IACjD,MAAM,OAAO,QAAe,CAAC;IAE7B,MAAM,eAAe,2CAK3B,CAAC;IAEK,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"}
+{"version":3,"file":"get-external-squad-by-uuid.command.d.ts","sourceRoot":"","sources":["../../../../commands/external-squads/get-external-squad-by-uuid.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,6BAA6B,CAAC;IACpC,MAAM,GAAG,0BAAuC,CAAC;IACjD,MAAM,OAAO,QAAe,CAAC;IAE7B,MAAM,eAAe,2CAK3B,CAAC;IAEK,MAAM,kBAAkB;;;;;;MAE7B,CAAC;IAEI,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEzB,CAAC;IAEH,KAAY,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;IAC9D,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/backend/commands/external-squads/get-external-squad-by-uuid.command.js

@@ -10,8 +10,8 @@ var GetExternalSquadByUuidCommand;
     GetExternalSquadByUuidCommand.url = api_1.REST_API.EXTERNAL_SQUADS.GET_BY_UUID;
     GetExternalSquadByUuidCommand.TSQ_url = GetExternalSquadByUuidCommand.url(':uuid');
     GetExternalSquadByUuidCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.EXTERNAL_SQUADS_ROUTES.GET_BY_UUID(':uuid'), 'get', 'Get external squad by uuid', { scope: 'get', kind: 'read' });
-    GetExternalSquadByUuidCommand.RequestSchema = zod_1.z.object({
-        uuid: zod_1.z.string().uuid(),
+    GetExternalSquadByUuidCommand.RequestParamSchema = zod_1.z.object({
+        uuid: zod_1.z.string().uuid().describe('UUID of the external squad'),
     });
     GetExternalSquadByUuidCommand.ResponseSchema = zod_1.z.object({
         response: models_1.ExternalSquadSchema,

package/build/backend/commands/external-squads/update-external-squad.command.d.ts

@@ -3,7 +3,7 @@ export declare namespace UpdateExternalSquadCommand {
     const url: "/api/external-squads/";
     const TSQ_url: "/api/external-squads/";
     const endpointDetails: import("../../constants").EndpointDetails;
-    const RequestSchema: z.ZodObject<{
+    const RequestBodySchema: z.ZodObject<{
         uuid: z.ZodString;
         name: z.ZodOptional<z.ZodString>;
         templates: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -176,7 +176,6 @@ export declare namespace UpdateExternalSquadCommand {
         responseHeaders?: Record<string, string> | null | undefined;
         subpageConfigUuid?: string | null | undefined;
     }>;
-    type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{
         response: z.ZodObject<{
             uuid: z.ZodString;
@@ -464,6 +463,7 @@ export declare namespace UpdateExternalSquadCommand {
             subpageConfigUuid: string | null;
         };
     }>;
+    type RequestBody = z.infer<typeof RequestBodySchema>;
     type Response = z.infer<typeof ResponseSchema>;
 }
 //# sourceMappingURL=update-external-squad.command.d.ts.map

package/build/backend/commands/external-squads/update-external-squad.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"update-external-squad.command.d.ts","sourceRoot":"","sources":["../../../../commands/external-squads/update-external-squad.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAaxB,yBAAiB,0BAA0B,CAAC;IACjC,MAAM,GAAG,yBAAkC,CAAC;IAC5C,MAAM,OAAO,yBAAM,CAAC;IAEpB,MAAM,eAAe,2CAK3B,CAAC;IAEK,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAyBxB,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"}
+{"version":3,"file":"update-external-squad.command.d.ts","sourceRoot":"","sources":["../../../../commands/external-squads/update-external-squad.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAaxB,yBAAiB,0BAA0B,CAAC;IACjC,MAAM,GAAG,yBAAkC,CAAC;IAC5C,MAAM,OAAO,yBAAM,CAAC;IAEpB,MAAM,eAAe,2CAK3B,CAAC;IAEK,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2B5B,CAAC;IAEI,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEzB,CAAC;IAEH,KAAY,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;IAC5D,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/backend/commands/external-squads/update-external-squad.command.js

@@ -10,8 +10,8 @@ var UpdateExternalSquadCommand;
     UpdateExternalSquadCommand.url = api_1.REST_API.EXTERNAL_SQUADS.UPDATE;
     UpdateExternalSquadCommand.TSQ_url = UpdateExternalSquadCommand.url;
     UpdateExternalSquadCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.EXTERNAL_SQUADS_ROUTES.UPDATE, 'patch', 'Update external squad', { scope: 'update', kind: 'write' });
-    UpdateExternalSquadCommand.RequestSchema = zod_1.z.object({
-        uuid: zod_1.z.string().uuid(),
+    UpdateExternalSquadCommand.RequestBodySchema = zod_1.z.object({
+        uuid: zod_1.z.string().uuid().describe('UUID of the external squad'),
         name: zod_1.z
             .string()
             .min(2, 'Name must be at least 2 characters')
@@ -20,8 +20,10 @@ var UpdateExternalSquadCommand;
             .optional(),
         templates: zod_1.z
             .array(zod_1.z.object({
-            templateUuid: zod_1.z.string().uuid(),
-            templateType: zod_1.z.nativeEnum(constants_1.SUBSCRIPTION_TEMPLATE_TYPE),
+            templateUuid: zod_1.z.string().uuid().describe('UUID of the subscription template'),
+            templateType: zod_1.z
+                .nativeEnum(constants_1.SUBSCRIPTION_TEMPLATE_TYPE)
+                .describe('Type of the subscription template'),
         }))
             .optional(),
         subscriptionSettings: models_1.ExternalSquadSubscriptionSettingsSchema.optional(),

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

@@ -3,14 +3,13 @@ export declare namespace BulkDeleteHostsCommand {
     const url: "/api/hosts/bulk/delete";
     const TSQ_url: "/api/hosts/bulk/delete";
     const endpointDetails: import("../../../constants").EndpointDetails;
-    const RequestSchema: z.ZodObject<{
+    const RequestBodySchema: 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;
@@ -228,6 +227,7 @@ export declare namespace BulkDeleteHostsCommand {
             keepSniBlank?: boolean | undefined;
         }[];
     }>;
+    type RequestBody = z.infer<typeof RequestBodySchema>;
     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

@@ -1 +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;AAMxB,yBAAiB,sBAAsB,CAAC;IAC7B,MAAM,GAAG,0BAAmC,CAAC;IAC7C,MAAM,OAAO,0BAAM,CAAC;IAEpB,MAAM,eAAe,8CAK3B,CAAC;IAEK,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"}
+{"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;AAMxB,yBAAiB,sBAAsB,CAAC;IAC7B,MAAM,GAAG,0BAAmC,CAAC;IAC7C,MAAM,OAAO,0BAAM,CAAC;IAEpB,MAAM,eAAe,8CAK3B,CAAC;IAEK,MAAM,iBAAiB;;;;;;MAE5B,CAAC;IAEI,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEzB,CAAC;IAEH,KAAY,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;IAC5D,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

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

@@ -10,7 +10,7 @@ var BulkDeleteHostsCommand;
     BulkDeleteHostsCommand.url = api_1.REST_API.HOSTS.BULK.DELETE_HOSTS;
     BulkDeleteHostsCommand.TSQ_url = BulkDeleteHostsCommand.url;
     BulkDeleteHostsCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.HOSTS_ROUTES.BULK.DELETE_HOSTS, 'post', 'Delete hosts by UUIDs', { scope: 'bulk-delete', kind: 'write' });
-    BulkDeleteHostsCommand.RequestSchema = zod_1.z.object({
+    BulkDeleteHostsCommand.RequestBodySchema = zod_1.z.object({
         uuids: zod_1.z.array(zod_1.z.string().uuid()),
     });
     BulkDeleteHostsCommand.ResponseSchema = zod_1.z.object({

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

@@ -3,14 +3,13 @@ export declare namespace BulkDisableHostsCommand {
     const url: "/api/hosts/bulk/disable";
     const TSQ_url: "/api/hosts/bulk/disable";
     const endpointDetails: import("../../../constants").EndpointDetails;
-    const RequestSchema: z.ZodObject<{
+    const RequestBodySchema: 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;
@@ -228,6 +227,7 @@ export declare namespace BulkDisableHostsCommand {
             keepSniBlank?: boolean | undefined;
         }[];
     }>;
+    type RequestBody = z.infer<typeof RequestBodySchema>;
     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

@@ -1 +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;AAMxB,yBAAiB,uBAAuB,CAAC;IAC9B,MAAM,GAAG,2BAAoC,CAAC;IAC9C,MAAM,OAAO,2BAAM,CAAC;IAEpB,MAAM,eAAe,8CAK3B,CAAC;IAEK,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"}
+{"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;AAMxB,yBAAiB,uBAAuB,CAAC;IAC9B,MAAM,GAAG,2BAAoC,CAAC;IAC9C,MAAM,OAAO,2BAAM,CAAC;IAEpB,MAAM,eAAe,8CAK3B,CAAC;IAEK,MAAM,iBAAiB;;;;;;MAE5B,CAAC;IAEI,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEzB,CAAC;IAEH,KAAY,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;IAC5D,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

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

@@ -10,7 +10,7 @@ var BulkDisableHostsCommand;
     BulkDisableHostsCommand.url = api_1.REST_API.HOSTS.BULK.DISABLE_HOSTS;
     BulkDisableHostsCommand.TSQ_url = BulkDisableHostsCommand.url;
     BulkDisableHostsCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.HOSTS_ROUTES.BULK.DISABLE_HOSTS, 'post', 'Disable hosts by UUIDs', { scope: 'bulk-disable', kind: 'write' });
-    BulkDisableHostsCommand.RequestSchema = zod_1.z.object({
+    BulkDisableHostsCommand.RequestBodySchema = zod_1.z.object({
         uuids: zod_1.z.array(zod_1.z.string().uuid()),
     });
     BulkDisableHostsCommand.ResponseSchema = zod_1.z.object({

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

@@ -3,14 +3,13 @@ export declare namespace BulkEnableHostsCommand {
     const url: "/api/hosts/bulk/enable";
     const TSQ_url: "/api/hosts/bulk/enable";
     const endpointDetails: import("../../../constants").EndpointDetails;
-    const RequestSchema: z.ZodObject<{
+    const RequestBodySchema: 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;
@@ -228,6 +227,7 @@ export declare namespace BulkEnableHostsCommand {
             keepSniBlank?: boolean | undefined;
         }[];
     }>;
+    type RequestBody = z.infer<typeof RequestBodySchema>;
     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

@@ -1 +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;AAMxB,yBAAiB,sBAAsB,CAAC;IAC7B,MAAM,GAAG,0BAAmC,CAAC;IAC7C,MAAM,OAAO,0BAAM,CAAC;IAEpB,MAAM,eAAe,8CAK3B,CAAC;IAEK,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"}
+{"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;AAMxB,yBAAiB,sBAAsB,CAAC;IAC7B,MAAM,GAAG,0BAAmC,CAAC;IAC7C,MAAM,OAAO,0BAAM,CAAC;IAEpB,MAAM,eAAe,8CAK3B,CAAC;IAEK,MAAM,iBAAiB;;;;;;MAE5B,CAAC;IAEI,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEzB,CAAC;IAEH,KAAY,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;IAC5D,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

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

@@ -10,7 +10,7 @@ var BulkEnableHostsCommand;
     BulkEnableHostsCommand.url = api_1.REST_API.HOSTS.BULK.ENABLE_HOSTS;
     BulkEnableHostsCommand.TSQ_url = BulkEnableHostsCommand.url;
     BulkEnableHostsCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.HOSTS_ROUTES.BULK.ENABLE_HOSTS, 'post', 'Enable hosts by UUIDs', { scope: 'bulk-enable', kind: 'write' });
-    BulkEnableHostsCommand.RequestSchema = zod_1.z.object({
+    BulkEnableHostsCommand.RequestBodySchema = zod_1.z.object({
         uuids: zod_1.z.array(zod_1.z.string().uuid()),
     });
     BulkEnableHostsCommand.ResponseSchema = zod_1.z.object({

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

@@ -3,7 +3,7 @@ export declare namespace UpdateManyHostsCommand {
     const url: "/api/hosts/bulk/update";
     const TSQ_url: "/api/hosts/bulk/update";
     const endpointDetails: import("../../../constants").EndpointDetails;
-    const RequestSchema: z.ZodObject<{
+    const RequestBodySchema: z.ZodObject<{
         nodes: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
         tags: z.ZodOptional<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
         path: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
@@ -140,7 +140,6 @@ export declare namespace UpdateManyHostsCommand {
         excludedInternalSquads?: string[] | undefined;
         excludeFromSubscriptionTypes?: ("STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64")[] | undefined;
     }>;
-    type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{
         response: z.ZodArray<z.ZodObject<{
             uuid: z.ZodString;
@@ -358,6 +357,7 @@ export declare namespace UpdateManyHostsCommand {
             keepSniBlank?: boolean | undefined;
         }[];
     }>;
+    type RequestBody = z.infer<typeof RequestBodySchema>;
     type Response = z.infer<typeof ResponseSchema>;
 }
 //# sourceMappingURL=update-many-hosts.command.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"update-many-hosts.command.d.ts","sourceRoot":"","sources":["../../../../../commands/hosts/bulk/update-many-hosts.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,yBAAiB,sBAAsB,CAAC;IAC7B,MAAM,GAAG,0BAA6B,CAAC;IACvC,MAAM,OAAO,0BAAM,CAAC;IAEpB,MAAM,eAAe,8CAK3B,CAAC;IAEK,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAIpB,CAAC;IACP,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"}
+{"version":3,"file":"update-many-hosts.command.d.ts","sourceRoot":"","sources":["../../../../../commands/hosts/bulk/update-many-hosts.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,yBAAiB,sBAAsB,CAAC;IAC7B,MAAM,GAAG,0BAA6B,CAAC;IACvC,MAAM,OAAO,0BAAM,CAAC;IAEpB,MAAM,eAAe,8CAK3B,CAAC;IAEK,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAIxB,CAAC;IAEA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEzB,CAAC;IAEH,KAAY,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;IAC5D,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

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

@@ -11,7 +11,7 @@ var UpdateManyHostsCommand;
     UpdateManyHostsCommand.url = api_1.REST_API.HOSTS.BULK.UPDATE;
     UpdateManyHostsCommand.TSQ_url = UpdateManyHostsCommand.url;
     UpdateManyHostsCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.HOSTS_ROUTES.BULK.UPDATE, 'patch', 'Update many hosts', { scope: 'bulk-update', kind: 'write' });
-    UpdateManyHostsCommand.RequestSchema = update_command_1.UpdateHostCommand.RequestSchema.omit({ uuid: true })
+    UpdateManyHostsCommand.RequestBodySchema = update_command_1.UpdateHostCommand.RequestBodySchema.omit({ uuid: true })
         .partial()
         .extend({
         uuids: zod_1.z.array(zod_1.z.string().uuid()).min(1, 'Must be at least 1 host UUID'),

package/build/backend/commands/hosts/create.command.d.ts

@@ -3,7 +3,7 @@ export declare namespace CreateHostCommand {
     const url: "/api/hosts/";
     const TSQ_url: "/api/hosts/";
     const endpointDetails: import("../../constants").EndpointDetails;
-    const RequestSchema: z.ZodObject<{
+    const RequestBodySchema: z.ZodObject<{
         inbound: z.ZodObject<{
             configProfileUuid: z.ZodString;
             configProfileInboundUuid: z.ZodString;
@@ -136,7 +136,6 @@ export declare namespace CreateHostCommand {
         excludedInternalSquads?: string[] | undefined;
         excludeFromSubscriptionTypes?: ("STASH" | "SINGBOX" | "MIHOMO" | "XRAY_JSON" | "CLASH" | "XRAY_BASE64")[] | undefined;
     }>;
-    type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{
         response: z.ZodObject<{
             uuid: z.ZodString;
@@ -354,6 +353,7 @@ export declare namespace CreateHostCommand {
             keepSniBlank?: boolean | undefined;
         };
     }>;
+    type RequestBody = z.infer<typeof RequestBodySchema>;
     type Response = z.infer<typeof ResponseSchema>;
 }
 //# sourceMappingURL=create.command.d.ts.map

package/build/backend/commands/hosts/create.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create.command.d.ts","sourceRoot":"","sources":["../../../../commands/hosts/create.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB,yBAAiB,iBAAiB,CAAC;IACxB,MAAM,GAAG,eAAwB,CAAC;IAClC,MAAM,OAAO,eAAM,CAAC;IAEpB,MAAM,eAAe,2CAK3B,CAAC;IAEK,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAwExB,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"}
+{"version":3,"file":"create.command.d.ts","sourceRoot":"","sources":["../../../../commands/hosts/create.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAYxB,yBAAiB,iBAAiB,CAAC;IACxB,MAAM,GAAG,eAAwB,CAAC;IAClC,MAAM,OAAO,eAAM,CAAC;IAEpB,MAAM,eAAe,2CAK3B,CAAC;IAEK,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAwE5B,CAAC;IAEI,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEzB,CAAC;IAEH,KAAY,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;IAC5D,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

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

@@ -10,7 +10,7 @@ var CreateHostCommand;
     CreateHostCommand.url = api_1.REST_API.HOSTS.CREATE;
     CreateHostCommand.TSQ_url = CreateHostCommand.url;
     CreateHostCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.HOSTS_ROUTES.CREATE, 'post', 'Create a new host', { scope: 'create', kind: 'write' });
-    CreateHostCommand.RequestSchema = zod_1.z.object({
+    CreateHostCommand.RequestBodySchema = zod_1.z.object({
         inbound: zod_1.z.object({
             configProfileUuid: zod_1.z.string().uuid(),
             configProfileInboundUuid: zod_1.z.string().uuid(),

package/build/backend/commands/hosts/delete.command.d.ts

@@ -3,14 +3,13 @@ export declare namespace DeleteHostCommand {
     const url: (uuid: string) => string;
     const TSQ_url: string;
     const endpointDetails: import("../../constants").EndpointDetails;
-    const RequestSchema: z.ZodObject<{
+    const RequestParamSchema: z.ZodObject<{
         uuid: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         uuid: string;
     }, {
         uuid: string;
     }>;
-    type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{
         response: z.ZodObject<{
             isDeleted: z.ZodBoolean;
@@ -28,6 +27,7 @@ export declare namespace DeleteHostCommand {
             isDeleted: boolean;
         };
     }>;
+    type RequestParam = z.infer<typeof RequestParamSchema>;
     type Response = z.infer<typeof ResponseSchema>;
 }
 //# sourceMappingURL=delete.command.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"delete.command.d.ts","sourceRoot":"","sources":["../../../../commands/hosts/delete.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,yBAAiB,iBAAiB,CAAC;IACxB,MAAM,GAAG,0BAAwB,CAAC;IAClC,MAAM,OAAO,QAAe,CAAC;IAE7B,MAAM,eAAe,2CAK3B,CAAC;IAEK,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"}
+{"version":3,"file":"delete.command.d.ts","sourceRoot":"","sources":["../../../../commands/hosts/delete.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,yBAAiB,iBAAiB,CAAC;IACxB,MAAM,GAAG,0BAAwB,CAAC;IAClC,MAAM,OAAO,QAAe,CAAC;IAE7B,MAAM,eAAe,2CAK3B,CAAC;IAEK,MAAM,kBAAkB;;;;;;MAE7B,CAAC;IAEI,MAAM,cAAc;;;;;;;;;;;;;;;;MAIzB,CAAC;IAEH,KAAY,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;IAC9D,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/backend/commands/hosts/delete.command.js

@@ -9,7 +9,7 @@ var DeleteHostCommand;
     DeleteHostCommand.url = api_1.REST_API.HOSTS.DELETE;
     DeleteHostCommand.TSQ_url = DeleteHostCommand.url(':uuid');
     DeleteHostCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.HOSTS_ROUTES.DELETE(':uuid'), 'delete', 'Delete a host by UUID', { scope: 'delete', kind: 'write' });
-    DeleteHostCommand.RequestSchema = zod_1.z.object({
+    DeleteHostCommand.RequestParamSchema = zod_1.z.object({
         uuid: zod_1.z.string().uuid(),
     });
     DeleteHostCommand.ResponseSchema = zod_1.z.object({

package/build/backend/commands/hosts/{get-one.command.d.ts → get-host.command.d.ts}

@@ -1,16 +1,15 @@
 import { z } from 'zod';
-export declare namespace GetOneHostCommand {
+export declare namespace GetHostCommand {
     const url: (uuid: string) => string;
     const TSQ_url: string;
     const endpointDetails: import("../../constants").EndpointDetails;
-    const RequestSchema: z.ZodObject<{
+    const RequestParamSchema: z.ZodObject<{
         uuid: z.ZodString;
     }, "strip", z.ZodTypeAny, {
         uuid: string;
     }, {
         uuid: string;
     }>;
-    type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{
         response: z.ZodObject<{
             uuid: z.ZodString;
@@ -228,6 +227,7 @@ export declare namespace GetOneHostCommand {
             keepSniBlank?: boolean | undefined;
         };
     }>;
+    type RequestParam = z.infer<typeof RequestParamSchema>;
     type Response = z.infer<typeof ResponseSchema>;
 }
-//# sourceMappingURL=get-one.command.d.ts.map
+//# sourceMappingURL=get-host.command.d.ts.map

package/build/backend/commands/hosts/get-host.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-host.command.d.ts","sourceRoot":"","sources":["../../../../commands/hosts/get-host.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,cAAc,CAAC;IACrB,MAAM,GAAG,0BAA6B,CAAC;IACvC,MAAM,OAAO,QAAe,CAAC;IAE7B,MAAM,eAAe,2CAK3B,CAAC;IAEK,MAAM,kBAAkB;;;;;;MAE7B,CAAC;IAEI,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEzB,CAAC;IAEH,KAAY,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;IAC9D,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/backend/commands/hosts/get-host.command.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetHostCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../api");
+const constants_1 = require("../../constants");
+const models_1 = require("../../models");
+var GetHostCommand;
+(function (GetHostCommand) {
+    GetHostCommand.url = api_1.REST_API.HOSTS.GET_BY_UUID;
+    GetHostCommand.TSQ_url = GetHostCommand.url(':uuid');
+    GetHostCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.HOSTS_ROUTES.GET_BY_UUID(':uuid'), 'get', 'Get a host by UUID', { scope: 'get', kind: 'read' });
+    GetHostCommand.RequestParamSchema = zod_1.z.object({
+        uuid: zod_1.z.string().uuid(),
+    });
+    GetHostCommand.ResponseSchema = zod_1.z.object({
+        response: models_1.HostsSchema,
+    });
+})(GetHostCommand || (exports.GetHostCommand = GetHostCommand = {}));

package/build/backend/commands/hosts/{get-all.command.d.ts → get-hosts.command.d.ts}

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-export declare namespace GetAllHostsCommand {
+export declare namespace GetHostsCommand {
     const url: "/api/hosts/";
     const TSQ_url: "/api/hosts/";
     const endpointDetails: import("../../constants").EndpointDetails;
@@ -222,4 +222,4 @@ export declare namespace GetAllHostsCommand {
     }>;
     type Response = z.infer<typeof ResponseSchema>;
 }
-//# sourceMappingURL=get-all.command.d.ts.map
+//# sourceMappingURL=get-hosts.command.d.ts.map

package/build/backend/commands/hosts/get-hosts.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-hosts.command.d.ts","sourceRoot":"","sources":["../../../../commands/hosts/get-hosts.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,eAAe,CAAC;IACtB,MAAM,GAAG,eAAqB,CAAC;IAC/B,MAAM,OAAO,eAAM,CAAC;IAEpB,MAAM,eAAe,2CAG1B,CAAC;IAEI,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAEzB,CAAC;IAEH,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/backend/commands/hosts/get-hosts.command.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetHostsCommand = void 0;
+const zod_1 = require("zod");
+const api_1 = require("../../api");
+const constants_1 = require("../../constants");
+const models_1 = require("../../models");
+var GetHostsCommand;
+(function (GetHostsCommand) {
+    GetHostsCommand.url = api_1.REST_API.HOSTS.GET;
+    GetHostsCommand.TSQ_url = GetHostsCommand.url;
+    GetHostsCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.HOSTS_ROUTES.GET, 'get', 'Get hosts', {
+        scope: 'list',
+        kind: 'read',
+    });
+    GetHostsCommand.ResponseSchema = zod_1.z.object({
+        response: zod_1.z.array(models_1.HostsSchema),
+    });
+})(GetHostsCommand || (exports.GetHostsCommand = GetHostsCommand = {}));

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

@@ -1,8 +1,8 @@
 export * from './bulk';
 export * from './create.command';
 export * from './delete.command';
-export * from './get-all.command';
-export * from './get-one.command';
+export * from './get-hosts.command';
+export * from './get-host.command';
 export * from './reorder.command';
 export * from './tags';
 export * from './update.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,QAAQ,CAAC;AACvB,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,QAAQ,CAAC;AACvB,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,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,QAAQ,CAAC;AACvB,cAAc,kBAAkB,CAAC"}

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

@@ -17,8 +17,8 @@ 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);
-__exportStar(require("./get-one.command"), exports);
+__exportStar(require("./get-hosts.command"), exports);
+__exportStar(require("./get-host.command"), exports);
 __exportStar(require("./reorder.command"), exports);
 __exportStar(require("./tags"), exports);
 __exportStar(require("./update.command"), exports);

package/build/backend/commands/hosts/reorder.command.d.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
-export declare namespace ReorderHostCommand {
+export declare namespace ReorderHostsCommand {
     const url: "/api/hosts/actions/reorder";
     const TSQ_url: "/api/hosts/actions/reorder";
     const endpointDetails: import("../../constants").EndpointDetails;
-    const RequestSchema: z.ZodObject<{
+    const RequestBodySchema: z.ZodObject<{
         hosts: z.ZodArray<z.ZodObject<Pick<{
             uuid: z.ZodString;
             viewPosition: z.ZodNumber;
@@ -88,7 +88,6 @@ export declare namespace ReorderHostCommand {
             viewPosition: number;
         }[];
     }>;
-    type Request = z.infer<typeof RequestSchema>;
     const ResponseSchema: z.ZodObject<{
         response: z.ZodObject<{
             isUpdated: z.ZodBoolean;
@@ -106,6 +105,7 @@ export declare namespace ReorderHostCommand {
             isUpdated: boolean;
         };
     }>;
+    type RequestBody = z.infer<typeof RequestBodySchema>;
     type Response = z.infer<typeof ResponseSchema>;
 }
 //# sourceMappingURL=reorder.command.d.ts.map

package/build/backend/commands/hosts/reorder.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reorder.command.d.ts","sourceRoot":"","sources":["../../../../commands/hosts/reorder.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,kBAAkB,CAAC;IACzB,MAAM,GAAG,8BAAiC,CAAC;IAC3C,MAAM,OAAO,8BAAM,CAAC;IAEpB,MAAM,eAAe,2CAK3B,CAAC;IAEK,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAOxB,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"}
+{"version":3,"file":"reorder.command.d.ts","sourceRoot":"","sources":["../../../../commands/hosts/reorder.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,mBAAmB,CAAC;IAC1B,MAAM,GAAG,8BAAiC,CAAC;IAC3C,MAAM,OAAO,8BAAM,CAAC;IAEpB,MAAM,eAAe,2CAK3B,CAAC;IAEK,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAO5B,CAAC;IAEI,MAAM,cAAc;;;;;;;;;;;;;;;;MAIzB,CAAC;IAEH,KAAY,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;IAC5D,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}

package/build/backend/commands/hosts/reorder.command.js

@@ -1,24 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReorderHostCommand = void 0;
+exports.ReorderHostsCommand = void 0;
 const zod_1 = require("zod");
 const api_1 = require("../../api");
 const constants_1 = require("../../constants");
 const models_1 = require("../../models");
-var ReorderHostCommand;
-(function (ReorderHostCommand) {
-    ReorderHostCommand.url = api_1.REST_API.HOSTS.ACTIONS.REORDER;
-    ReorderHostCommand.TSQ_url = ReorderHostCommand.url;
-    ReorderHostCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.HOSTS_ROUTES.ACTIONS.REORDER, 'post', 'Reorder hosts', { scope: 'reorder', kind: 'write' });
-    ReorderHostCommand.RequestSchema = zod_1.z.object({
+var ReorderHostsCommand;
+(function (ReorderHostsCommand) {
+    ReorderHostsCommand.url = api_1.REST_API.HOSTS.ACTIONS.REORDER;
+    ReorderHostsCommand.TSQ_url = ReorderHostsCommand.url;
+    ReorderHostsCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.HOSTS_ROUTES.ACTIONS.REORDER, 'post', 'Reorder hosts', { scope: 'reorder', kind: 'write' });
+    ReorderHostsCommand.RequestBodySchema = zod_1.z.object({
         hosts: zod_1.z.array(models_1.HostsSchema.pick({
             viewPosition: true,
             uuid: true,
         })),
     });
-    ReorderHostCommand.ResponseSchema = zod_1.z.object({
+    ReorderHostsCommand.ResponseSchema = zod_1.z.object({
         response: zod_1.z.object({
             isUpdated: zod_1.z.boolean(),
         }),
     });
-})(ReorderHostCommand || (exports.ReorderHostCommand = ReorderHostCommand = {}));
+})(ReorderHostsCommand || (exports.ReorderHostsCommand = ReorderHostsCommand = {}));