@remnawave/backend-contract 2.9.3 → 2.9.4

package/build/backend/commands/users/create-user.command.d.ts

@@ -5,288 +5,85 @@ export declare namespace CreateUserCommand {
     const endpointDetails: import("../../constants").EndpointDetails;
     const RequestBodySchema: z.ZodObject<{
         username: z.ZodString;
-        status: z.ZodDefault<z.ZodOptional<z.ZodDefault<z.ZodNativeEnum<{
+        status: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
             readonly ACTIVE: "ACTIVE";
             readonly DISABLED: "DISABLED";
             readonly LIMITED: "LIMITED";
             readonly EXPIRED: "EXPIRED";
-        }>>>>;
+        }>>>;
         shortUuid: z.ZodOptional<z.ZodString>;
         trojanPassword: z.ZodOptional<z.ZodString>;
-        vlessUuid: z.ZodOptional<z.ZodString>;
+        vlessUuid: z.ZodOptional<z.ZodUUID>;
         ssPassword: z.ZodOptional<z.ZodString>;
         trafficLimitBytes: z.ZodOptional<z.ZodNumber>;
-        trafficLimitStrategy: z.ZodOptional<z.ZodEffects<z.ZodDefault<z.ZodDefault<z.ZodNativeEnum<{
+        trafficLimitStrategy: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
             readonly NO_RESET: "NO_RESET";
             readonly DAY: "DAY";
             readonly WEEK: "WEEK";
             readonly MONTH: "MONTH";
             readonly MONTH_ROLLING: "MONTH_ROLLING";
-        }>>>, "MONTH" | "NO_RESET" | "DAY" | "WEEK" | "MONTH_ROLLING", "MONTH" | "NO_RESET" | "DAY" | "WEEK" | "MONTH_ROLLING" | undefined>>;
-        expireAt: z.ZodEffects<z.ZodString, Date, string>;
-        createdAt: z.ZodOptional<z.ZodEffects<z.ZodString, Date, string>>;
-        lastTrafficResetAt: z.ZodOptional<z.ZodEffects<z.ZodString, Date, string>>;
+        }>>>;
+        expireAt: z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>;
+        createdAt: z.ZodOptional<z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>>;
+        lastTrafficResetAt: z.ZodOptional<z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>>;
         description: z.ZodOptional<z.ZodString>;
         tag: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         telegramId: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
-        email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-        hwidDeviceLimit: z.ZodOptional<z.ZodNumber>;
-        activeInternalSquads: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-        uuid: z.ZodOptional<z.ZodString>;
-        externalSquadUuid: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-    }, "strip", z.ZodTypeAny, {
-        status: "DISABLED" | "LIMITED" | "EXPIRED" | "ACTIVE";
-        expireAt: Date;
-        username: string;
-        uuid?: string | undefined;
-        createdAt?: Date | undefined;
-        description?: string | undefined;
-        tag?: string | null | undefined;
-        shortUuid?: string | undefined;
-        trafficLimitBytes?: number | undefined;
-        trafficLimitStrategy?: "MONTH" | "NO_RESET" | "DAY" | "WEEK" | "MONTH_ROLLING" | undefined;
-        telegramId?: number | null | undefined;
-        email?: string | null | undefined;
-        hwidDeviceLimit?: number | undefined;
-        externalSquadUuid?: string | null | undefined;
-        trojanPassword?: string | undefined;
-        vlessUuid?: string | undefined;
-        ssPassword?: string | undefined;
-        lastTrafficResetAt?: Date | undefined;
-        activeInternalSquads?: string[] | undefined;
-    }, {
-        expireAt: string;
-        username: string;
-        status?: "DISABLED" | "LIMITED" | "EXPIRED" | "ACTIVE" | undefined;
-        uuid?: string | undefined;
-        createdAt?: string | undefined;
-        description?: string | undefined;
-        tag?: string | null | undefined;
-        shortUuid?: string | undefined;
-        trafficLimitBytes?: number | undefined;
-        trafficLimitStrategy?: "MONTH" | "NO_RESET" | "DAY" | "WEEK" | "MONTH_ROLLING" | undefined;
-        telegramId?: number | null | undefined;
-        email?: string | null | undefined;
-        hwidDeviceLimit?: number | undefined;
-        externalSquadUuid?: string | null | undefined;
-        trojanPassword?: string | undefined;
-        vlessUuid?: string | undefined;
-        ssPassword?: string | undefined;
-        lastTrafficResetAt?: string | undefined;
-        activeInternalSquads?: string[] | undefined;
-    }>;
+        email: z.ZodOptional<z.ZodNullable<z.ZodEmail>>;
+        hwidDeviceLimit: z.ZodOptional<z.ZodInt>;
+        activeInternalSquads: z.ZodOptional<z.ZodArray<z.ZodUUID>>;
+        uuid: z.ZodOptional<z.ZodUUID>;
+        externalSquadUuid: z.ZodOptional<z.ZodNullable<z.ZodUUID>>;
+    }, z.core.$strip>;
     const ResponseSchema: z.ZodObject<{
         response: z.ZodObject<{
-            uuid: z.ZodString;
+            uuid: z.ZodUUID;
             id: z.ZodNumber;
             shortUuid: z.ZodString;
             username: z.ZodString;
-            status: z.ZodDefault<z.ZodNativeEnum<{
+            status: z.ZodEnum<{
                 readonly ACTIVE: "ACTIVE";
                 readonly DISABLED: "DISABLED";
                 readonly LIMITED: "LIMITED";
                 readonly EXPIRED: "EXPIRED";
-            }>>;
-            trafficLimitBytes: z.ZodDefault<z.ZodNumber>;
-            trafficLimitStrategy: z.ZodDefault<z.ZodNativeEnum<{
+            }>;
+            trafficLimitBytes: z.ZodNumber;
+            trafficLimitStrategy: z.ZodEnum<{
                 readonly NO_RESET: "NO_RESET";
                 readonly DAY: "DAY";
                 readonly WEEK: "WEEK";
                 readonly MONTH: "MONTH";
                 readonly MONTH_ROLLING: "MONTH_ROLLING";
-            }>>;
-            expireAt: z.ZodEffects<z.ZodString, Date, string>;
+            }>;
+            expireAt: z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>;
             telegramId: z.ZodNullable<z.ZodNumber>;
-            email: z.ZodNullable<z.ZodString>;
+            email: z.ZodNullable<z.ZodEmail>;
             description: z.ZodNullable<z.ZodString>;
             tag: z.ZodNullable<z.ZodString>;
-            hwidDeviceLimit: z.ZodNullable<z.ZodNumber>;
-            externalSquadUuid: z.ZodNullable<z.ZodString>;
+            hwidDeviceLimit: z.ZodNullable<z.ZodInt>;
+            externalSquadUuid: z.ZodNullable<z.ZodUUID>;
             trojanPassword: z.ZodString;
-            vlessUuid: z.ZodString;
+            vlessUuid: z.ZodUUID;
             ssPassword: z.ZodString;
-            lastTriggeredThreshold: z.ZodDefault<z.ZodNumber>;
-            subRevokedAt: z.ZodNullable<z.ZodEffects<z.ZodString, Date, string>>;
-            lastTrafficResetAt: z.ZodNullable<z.ZodEffects<z.ZodString, Date, string>>;
-            createdAt: z.ZodEffects<z.ZodString, Date, string>;
-            updatedAt: z.ZodEffects<z.ZodString, Date, string>;
-        } & {
+            lastTriggeredThreshold: z.ZodInt;
+            subRevokedAt: z.ZodNullable<z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>>;
+            lastTrafficResetAt: z.ZodNullable<z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>>;
+            createdAt: z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>;
+            updatedAt: z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>;
             subscriptionUrl: z.ZodString;
             activeInternalSquads: z.ZodArray<z.ZodObject<{
-                uuid: z.ZodString;
+                uuid: z.ZodUUID;
                 name: z.ZodString;
-            }, "strip", z.ZodTypeAny, {
-                uuid: string;
-                name: string;
-            }, {
-                uuid: string;
-                name: string;
-            }>, "many">;
+            }, z.core.$strip>>;
             userTraffic: z.ZodObject<{
                 usedTrafficBytes: z.ZodNumber;
                 lifetimeUsedTrafficBytes: z.ZodNumber;
-                onlineAt: z.ZodNullable<z.ZodEffects<z.ZodString, Date, string>>;
-                firstConnectedAt: z.ZodNullable<z.ZodEffects<z.ZodString, Date, string>>;
-                lastConnectedNodeUuid: z.ZodNullable<z.ZodString>;
-            }, "strip", z.ZodTypeAny, {
-                usedTrafficBytes: number;
-                lifetimeUsedTrafficBytes: number;
-                onlineAt: Date | null;
-                firstConnectedAt: Date | null;
-                lastConnectedNodeUuid: string | null;
-            }, {
-                usedTrafficBytes: number;
-                lifetimeUsedTrafficBytes: number;
-                onlineAt: string | null;
-                firstConnectedAt: string | null;
-                lastConnectedNodeUuid: string | null;
-            }>;
-        }, "strip", z.ZodTypeAny, {
-            status: "DISABLED" | "LIMITED" | "EXPIRED" | "ACTIVE";
-            uuid: string;
-            expireAt: Date;
-            createdAt: Date;
-            updatedAt: Date;
-            description: string | null;
-            username: string;
-            tag: string | null;
-            id: number;
-            shortUuid: string;
-            trafficLimitBytes: number;
-            trafficLimitStrategy: "MONTH" | "NO_RESET" | "DAY" | "WEEK" | "MONTH_ROLLING";
-            telegramId: number | null;
-            email: string | null;
-            hwidDeviceLimit: number | null;
-            externalSquadUuid: string | null;
-            trojanPassword: string;
-            vlessUuid: string;
-            ssPassword: string;
-            lastTriggeredThreshold: number;
-            subRevokedAt: Date | null;
-            lastTrafficResetAt: Date | null;
-            subscriptionUrl: string;
-            activeInternalSquads: {
-                uuid: string;
-                name: string;
-            }[];
-            userTraffic: {
-                usedTrafficBytes: number;
-                lifetimeUsedTrafficBytes: number;
-                onlineAt: Date | null;
-                firstConnectedAt: Date | null;
-                lastConnectedNodeUuid: string | null;
-            };
-        }, {
-            uuid: string;
-            expireAt: string;
-            createdAt: string;
-            updatedAt: string;
-            description: string | null;
-            username: string;
-            tag: string | null;
-            id: number;
-            shortUuid: string;
-            telegramId: number | null;
-            email: string | null;
-            hwidDeviceLimit: number | null;
-            externalSquadUuid: string | null;
-            trojanPassword: string;
-            vlessUuid: string;
-            ssPassword: string;
-            subRevokedAt: string | null;
-            lastTrafficResetAt: string | null;
-            subscriptionUrl: string;
-            activeInternalSquads: {
-                uuid: string;
-                name: string;
-            }[];
-            userTraffic: {
-                usedTrafficBytes: number;
-                lifetimeUsedTrafficBytes: number;
-                onlineAt: string | null;
-                firstConnectedAt: string | null;
-                lastConnectedNodeUuid: string | null;
-            };
-            status?: "DISABLED" | "LIMITED" | "EXPIRED" | "ACTIVE" | undefined;
-            trafficLimitBytes?: number | undefined;
-            trafficLimitStrategy?: "MONTH" | "NO_RESET" | "DAY" | "WEEK" | "MONTH_ROLLING" | undefined;
-            lastTriggeredThreshold?: number | undefined;
-        }>;
-    }, "strip", z.ZodTypeAny, {
-        response: {
-            status: "DISABLED" | "LIMITED" | "EXPIRED" | "ACTIVE";
-            uuid: string;
-            expireAt: Date;
-            createdAt: Date;
-            updatedAt: Date;
-            description: string | null;
-            username: string;
-            tag: string | null;
-            id: number;
-            shortUuid: string;
-            trafficLimitBytes: number;
-            trafficLimitStrategy: "MONTH" | "NO_RESET" | "DAY" | "WEEK" | "MONTH_ROLLING";
-            telegramId: number | null;
-            email: string | null;
-            hwidDeviceLimit: number | null;
-            externalSquadUuid: string | null;
-            trojanPassword: string;
-            vlessUuid: string;
-            ssPassword: string;
-            lastTriggeredThreshold: number;
-            subRevokedAt: Date | null;
-            lastTrafficResetAt: Date | null;
-            subscriptionUrl: string;
-            activeInternalSquads: {
-                uuid: string;
-                name: string;
-            }[];
-            userTraffic: {
-                usedTrafficBytes: number;
-                lifetimeUsedTrafficBytes: number;
-                onlineAt: Date | null;
-                firstConnectedAt: Date | null;
-                lastConnectedNodeUuid: string | null;
-            };
-        };
-    }, {
-        response: {
-            uuid: string;
-            expireAt: string;
-            createdAt: string;
-            updatedAt: string;
-            description: string | null;
-            username: string;
-            tag: string | null;
-            id: number;
-            shortUuid: string;
-            telegramId: number | null;
-            email: string | null;
-            hwidDeviceLimit: number | null;
-            externalSquadUuid: string | null;
-            trojanPassword: string;
-            vlessUuid: string;
-            ssPassword: string;
-            subRevokedAt: string | null;
-            lastTrafficResetAt: string | null;
-            subscriptionUrl: string;
-            activeInternalSquads: {
-                uuid: string;
-                name: string;
-            }[];
-            userTraffic: {
-                usedTrafficBytes: number;
-                lifetimeUsedTrafficBytes: number;
-                onlineAt: string | null;
-                firstConnectedAt: string | null;
-                lastConnectedNodeUuid: string | null;
-            };
-            status?: "DISABLED" | "LIMITED" | "EXPIRED" | "ACTIVE" | undefined;
-            trafficLimitBytes?: number | undefined;
-            trafficLimitStrategy?: "MONTH" | "NO_RESET" | "DAY" | "WEEK" | "MONTH_ROLLING" | undefined;
-            lastTriggeredThreshold?: number | undefined;
-        };
-    }>;
+                onlineAt: z.ZodNullable<z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>>;
+                firstConnectedAt: z.ZodNullable<z.ZodPipe<z.ZodISODateTime, z.ZodTransform<Date, string>>>;
+                lastConnectedNodeUuid: z.ZodNullable<z.ZodUUID>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
     type RequestBody = z.infer<typeof RequestBodySchema>;
     type Response = z.infer<typeof ResponseSchema>;
 }

package/build/backend/commands/users/create-user.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-user.command.d.ts","sourceRoot":"","sources":["../../../../commands/users/create-user.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,yBAAiB,iBAAiB,CAAC;IACxB,MAAM,GAAG,eAAwB,CAAC;IAClC,MAAM,OAAO,eAAM,CAAC;IAEpB,MAAM,eAAe,2CAK3B,CAAC;IAEK,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAkJ5B,CAAC;IAEI,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAAqB,CAAC;IAEjD,KAAY,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;IAC5D,KAAY,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;CACzD"}
+{"version":3,"file":"create-user.command.d.ts","sourceRoot":"","sources":["../../../../commands/users/create-user.command.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,yBAAiB,iBAAiB,CAAC;IACxB,MAAM,GAAG,eAAwB,CAAC;IAClC,MAAM,OAAO,eAAM,CAAC;IAEpB,MAAM,eAAe,2CAK3B,CAAC;IAEK,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA6G5B,CAAC;IAEI,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBAAqB,CAAC;IAEjD,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/users/create-user.command.js

@@ -4,7 +4,6 @@ exports.CreateUserCommand = void 0;
 const zod_1 = require("zod");
 const api_1 = require("../../api");
 const constants_1 = require("../../constants");
-const models_1 = require("../../models");
 const user_response_1 = require("./user.response");
 var CreateUserCommand;
 (function (CreateUserCommand) {
@@ -13,88 +12,53 @@ var CreateUserCommand;
     CreateUserCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.USERS_ROUTES.CREATE, 'post', 'Create a new user', { scope: 'create', kind: 'write' });
     CreateUserCommand.RequestBodySchema = zod_1.z.object({
         username: zod_1.z
-            .string({
-            required_error: 'Username is required',
-            invalid_type_error: 'Username must be a string',
-        })
+            .string()
             .regex(/^[a-zA-Z0-9_-]+$/, 'Username can only contain letters, numbers, underscores and dashes')
             .max(36, 'Username must be less than 36 characters')
             .min(3, 'Username must be at least 3 characters')
             .describe('Unique username for the user. Required. Must be 3-36 characters long and contain only letters, numbers, underscores and dashes.'),
-        status: models_1.UsersSchema.shape.status
-            .optional()
+        status: zod_1.z
+            .enum(constants_1.USERS_STATUS)
             .default(constants_1.USERS_STATUS.ACTIVE)
-            .describe('Optional. User account status. Defaults to ACTIVE.'),
-        shortUuid: zod_1.z
-            .string({
-            invalid_type_error: 'Short UUID must be a string',
-        })
             .optional()
-            .describe('Optional. Short UUID identifier for the user.'),
+            .describe('Optional. User account status. Defaults to ACTIVE.'),
+        shortUuid: zod_1.z.string().optional().describe('Optional. Short UUID identifier for the user.'),
         trojanPassword: zod_1.z
-            .string({
-            invalid_type_error: 'Trojan password must be a string',
-        })
+            .string()
             .min(8, 'Trojan password must be at least 8 characters')
             .max(32, 'Trojan password must be less than 32 characters')
             .optional()
             .describe('Optional. Password for Trojan protocol. Must be 8-32 characters.'),
         vlessUuid: zod_1.z
-            .string({
-            invalid_type_error: 'Vless UUID must be a string',
-        })
             .uuid('Invalid Vless UUID format')
             .optional()
             .describe('Optional. UUID for VLESS protocol. Must be a valid UUID format.'),
         ssPassword: zod_1.z
-            .string({
-            invalid_type_error: 'SS password must be a string',
-        })
+            .string()
             .min(8, 'SS password must be at least 8 characters')
             .max(32, 'SS password must be less than 32 characters')
             .optional()
             .describe('Optional. Password for Shadowsocks protocol. Must be 8-32 characters.'),
         trafficLimitBytes: zod_1.z
-            .number({
-            invalid_type_error: 'Traffic limit must be a number',
-        })
+            .number()
             .min(0, 'Traffic limit must be greater than 0')
             .optional()
             .describe('Optional. Traffic limit in bytes. Set to 0 for unlimited traffic.'),
-        trafficLimitStrategy: zod_1.z.optional(models_1.UsersSchema.shape.trafficLimitStrategy
+        trafficLimitStrategy: zod_1.z.optional(zod_1.z
+            .enum(constants_1.RESET_PERIODS)
             .default(constants_1.RESET_PERIODS.NO_RESET)
-            .superRefine((val, ctx) => {
-            if (val && !Object.values(constants_1.RESET_PERIODS).includes(val)) {
-                ctx.addIssue({
-                    code: zod_1.z.ZodIssueCode.invalid_enum_value,
-                    message: 'Invalid traffic limit strategy',
-                    path: ['trafficLimitStrategy'],
-                    received: val,
-                    options: Object.values(constants_1.RESET_PERIODS),
-                });
-            }
-        })),
-        expireAt: zod_1.z
-            .string({
-            required_error: 'Expiration date is required',
-            invalid_type_error: 'Invalid date format',
-        })
-            .datetime({ message: 'Invalid date format', offset: true, local: true })
+            .describe('Available reset periods')),
+        expireAt: zod_1.z.iso
+            .datetime({ offset: true, local: true })
             .transform((str) => new Date(str))
             .describe('Account expiration date. Required. Format: 2025-01-17T15:38:45.065Z'),
-        createdAt: zod_1.z
-            .string({
-            invalid_type_error: 'Invalid date format',
-        })
-            .datetime({ message: 'Invalid date format', offset: true, local: true })
+        createdAt: zod_1.z.iso
+            .datetime({ offset: true, local: true })
             .transform((str) => new Date(str))
             .optional()
             .describe('Optional. Account creation date. Format: 2025-01-17T15:38:45.065Z'),
-        lastTrafficResetAt: zod_1.z
-            .string({
-            invalid_type_error: 'Invalid date format',
-        })
-            .datetime({ message: 'Invalid date format', offset: true, local: true })
+        lastTrafficResetAt: zod_1.z.iso
+            .datetime({ offset: true, local: true })
             .transform((str) => new Date(str))
             .optional()
             .describe('Optional. Date of last traffic reset. Format: 2025-01-17T15:38:45.065Z'),
@@ -110,28 +74,26 @@ var CreateUserCommand;
             .nullable())
             .describe('Optional. User tag for categorization. Max 16 characters, uppercase letters, numbers and underscores only.'),
         telegramId: zod_1.z
-            .optional(zod_1.z.number().int().nullable())
+            .number()
+            .nullish()
             .describe('Optional. Telegram user ID for notifications. Must be an integer.'),
         email: zod_1.z
-            .optional(zod_1.z.string().email('Invalid email format').nullable())
+            .email()
+            .nullish()
             .describe('Optional. User email address. Must be a valid email format.'),
         hwidDeviceLimit: zod_1.z.optional(zod_1.z
-            .number({ invalid_type_error: 'Device limit must be a number' })
-            .int('Device limit must be an integer')
-            .min(0, 'Device limit must be greater than 0')
+            .int()
+            .min(0)
             .describe('Optional. Maximum number of hardware devices allowed. Must be a positive integer.')),
         activeInternalSquads: zod_1.z
-            .array(zod_1.z.string().uuid(), {
-            invalid_type_error: 'Enabled internal squads must be an array',
-        })
+            .array(zod_1.z.uuid())
             .optional()
             .describe('Optional. Array of UUIDs representing enabled internal squads.'),
         uuid: zod_1.z.optional(zod_1.z
-            .string()
             .uuid()
             .describe('Optional. Pass UUID to create user with specific UUID, otherwise it will be generated automatically.')),
         externalSquadUuid: zod_1.z
-            .optional(zod_1.z.nullable(zod_1.z.string().uuid()))
+            .optional(zod_1.z.nullable(zod_1.z.uuid()))
             .describe('Optional. External squad UUID.'),
     });
     CreateUserCommand.ResponseSchema = user_response_1.UserResponseSchema;

package/build/backend/commands/users/delete-user.command.d.ts

@@ -4,12 +4,8 @@ export declare namespace DeleteUserCommand {
     const TSQ_url: string;
     const endpointDetails: import("../../constants").EndpointDetails;
     const RequestParamSchema: z.ZodObject<{
-        uuid: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        uuid: string;
-    }, {
-        uuid: string;
-    }>;
+        uuid: z.ZodUUID;
+    }, z.core.$strip>;
     type RequestParam = z.infer<typeof RequestParamSchema>;
 }
 //# sourceMappingURL=delete-user.command.d.ts.map

package/build/backend/commands/users/delete-user.command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"delete-user.command.d.ts","sourceRoot":"","sources":["../../../../commands/users/delete-user.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;IAEH,KAAY,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;CACjE"}
+{"version":3,"file":"delete-user.command.d.ts","sourceRoot":"","sources":["../../../../commands/users/delete-user.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;;qBAE7B,CAAC;IAEH,KAAY,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;CACjE"}

package/build/backend/commands/users/delete-user.command.js

@@ -10,6 +10,6 @@ var DeleteUserCommand;
     DeleteUserCommand.TSQ_url = DeleteUserCommand.url(':uuid');
     DeleteUserCommand.endpointDetails = (0, constants_1.getEndpointDetails)(api_1.USERS_ROUTES.DELETE(':uuid'), 'delete', 'Delete user', { scope: 'delete', kind: 'write' });
     DeleteUserCommand.RequestParamSchema = zod_1.z.object({
-        uuid: zod_1.z.string().uuid(),
+        uuid: zod_1.z.uuid(),
     });
 })(DeleteUserCommand || (exports.DeleteUserCommand = DeleteUserCommand = {}));