@drax/identity-back 0.49.0 → 0.51.0

package/types/factory/UserApiKeyServiceFactory.d.ts

@@ -1,4 +1,4 @@
 import UserApiKeyService from "../services/UserApiKeyService.js";
 declare const UserApiKeyServiceFactory: (verbose?: boolean) => UserApiKeyService;
 export default UserApiKeyServiceFactory;
-//# sourceMappingURL=UserRegistryServiceFactory.d.ts.map
+//# sourceMappingURL=UserApiKeyServiceFactory.d.ts.map

package/types/models/RoleModel.d.ts

@@ -1,10 +1,10 @@
 import { mongoose } from '@drax/common-back';
 import { IRole } from '@drax/identity-share';
-declare const RoleMongoSchema: mongoose.Schema<IRole, mongoose.Model<IRole, any, any, any, mongoose.Document<unknown, any, IRole> & IRole & Required<{
+declare const RoleMongoSchema: mongoose.Schema<IRole, mongoose.Model<IRole, any, any, any, mongoose.Document<unknown, any, IRole, any, {}> & IRole & Required<{
     _id: string;
 }> & {
     __v: number;
-}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IRole, mongoose.Document<unknown, {}, mongoose.FlatRecord<IRole>> & mongoose.FlatRecord<IRole> & Required<{
+}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IRole, mongoose.Document<unknown, {}, mongoose.FlatRecord<IRole>, {}, mongoose.ResolveSchemaOptions<mongoose.DefaultSchemaOptions>> & mongoose.FlatRecord<IRole> & Required<{
     _id: string;
 }> & {
     __v: number;

package/types/models/TenantModel.d.ts

@@ -1,10 +1,10 @@
 import { mongoose } from '@drax/common-back';
 import { ITenant } from '@drax/identity-share';
-declare const TenantMongoSchema: mongoose.Schema<ITenant, mongoose.Model<ITenant, any, any, any, mongoose.Document<unknown, any, ITenant> & ITenant & Required<{
+declare const TenantMongoSchema: mongoose.Schema<ITenant, mongoose.Model<ITenant, any, any, any, mongoose.Document<unknown, any, ITenant, any, {}> & ITenant & Required<{
     _id: string;
 }> & {
     __v: number;
-}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, ITenant, mongoose.Document<unknown, {}, mongoose.FlatRecord<ITenant>> & mongoose.FlatRecord<ITenant> & Required<{
+}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, ITenant, mongoose.Document<unknown, {}, mongoose.FlatRecord<ITenant>, {}, mongoose.ResolveSchemaOptions<mongoose.DefaultSchemaOptions>> & mongoose.FlatRecord<ITenant> & Required<{
     _id: string;
 }> & {
     __v: number;

package/types/models/UserApiKeyModel.d.ts

@@ -1,10 +1,10 @@
 import { mongoose } from '@drax/common-back';
 import { IUserApiKey } from "@drax/identity-share";
-declare const UserApiKeyMongoSchema: mongoose.Schema<IUserApiKey, mongoose.Model<IUserApiKey, any, any, any, mongoose.Document<unknown, any, IUserApiKey> & IUserApiKey & Required<{
+declare const UserApiKeyMongoSchema: mongoose.Schema<IUserApiKey, mongoose.Model<IUserApiKey, any, any, any, mongoose.Document<unknown, any, IUserApiKey, any, {}> & IUserApiKey & Required<{
     _id: string;
 }> & {
     __v: number;
-}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IUserApiKey, mongoose.Document<unknown, {}, mongoose.FlatRecord<IUserApiKey>> & mongoose.FlatRecord<IUserApiKey> & Required<{
+}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IUserApiKey, mongoose.Document<unknown, {}, mongoose.FlatRecord<IUserApiKey>, {}, mongoose.ResolveSchemaOptions<mongoose.DefaultSchemaOptions>> & mongoose.FlatRecord<IUserApiKey> & Required<{
     _id: string;
 }> & {
     __v: number;

package/types/models/UserGroupModel.d.ts

@@ -1,10 +1,10 @@
 import { mongoose } from '@drax/common-back';
 import { IUserGroup } from "@drax/identity-share";
-declare const UserGroupMongoSchema: mongoose.Schema<IUserGroup, mongoose.Model<IUserGroup, any, any, any, mongoose.Document<unknown, any, IUserGroup> & IUserGroup & {
+declare const UserGroupMongoSchema: mongoose.Schema<IUserGroup, mongoose.Model<IUserGroup, any, any, any, mongoose.Document<unknown, any, IUserGroup, any, {}> & IUserGroup & {
     _id: mongoose.Types.ObjectId;
 } & {
     __v: number;
-}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IUserGroup, mongoose.Document<unknown, {}, mongoose.FlatRecord<IUserGroup>> & mongoose.FlatRecord<IUserGroup> & {
+}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IUserGroup, mongoose.Document<unknown, {}, mongoose.FlatRecord<IUserGroup>, {}, mongoose.ResolveSchemaOptions<mongoose.DefaultSchemaOptions>> & mongoose.FlatRecord<IUserGroup> & {
     _id: mongoose.Types.ObjectId;
 } & {
     __v: number;

package/types/models/UserLoginFailModel.d.ts

@@ -1,10 +1,10 @@
 import { mongoose } from '@drax/common-back';
 import type { IUserLoginFail } from '@drax/identity-share';
-declare const UserLoginFailMongoSchema: mongoose.Schema<IUserLoginFail, mongoose.Model<IUserLoginFail, any, any, any, mongoose.Document<unknown, any, IUserLoginFail> & IUserLoginFail & Required<{
+declare const UserLoginFailMongoSchema: mongoose.Schema<IUserLoginFail, mongoose.Model<IUserLoginFail, any, any, any, mongoose.Document<unknown, any, IUserLoginFail, any, {}> & IUserLoginFail & Required<{
     _id: string;
 }> & {
     __v: number;
-}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IUserLoginFail, mongoose.Document<unknown, {}, mongoose.FlatRecord<IUserLoginFail>> & mongoose.FlatRecord<IUserLoginFail> & Required<{
+}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IUserLoginFail, mongoose.Document<unknown, {}, mongoose.FlatRecord<IUserLoginFail>, {}, mongoose.ResolveSchemaOptions<mongoose.DefaultSchemaOptions>> & mongoose.FlatRecord<IUserLoginFail> & Required<{
     _id: string;
 }> & {
     __v: number;

package/types/models/UserModel.d.ts

@@ -1,10 +1,10 @@
 import { mongoose } from '@drax/common-back';
 import { IUser } from "@drax/identity-share";
-declare const UserMongoSchema: mongoose.Schema<IUser, mongoose.Model<IUser, any, any, any, mongoose.Document<unknown, any, IUser> & IUser & Required<{
+declare const UserMongoSchema: mongoose.Schema<IUser, mongoose.Model<IUser, any, any, any, mongoose.Document<unknown, any, IUser, any, {}> & IUser & Required<{
     _id: string;
 }> & {
     __v: number;
-}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IUser, mongoose.Document<unknown, {}, mongoose.FlatRecord<IUser>> & mongoose.FlatRecord<IUser> & Required<{
+}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IUser, mongoose.Document<unknown, {}, mongoose.FlatRecord<IUser>, {}, mongoose.ResolveSchemaOptions<mongoose.DefaultSchemaOptions>> & mongoose.FlatRecord<IUser> & Required<{
     _id: string;
 }> & {
     __v: number;

package/types/models/UserSessionModel.d.ts

@@ -1,10 +1,10 @@
 import { mongoose } from '@drax/common-back';
 import type { IUserSession } from '@drax/identity-share';
-declare const UserSessionMongoSchema: mongoose.Schema<IUserSession, mongoose.Model<IUserSession, any, any, any, mongoose.Document<unknown, any, IUserSession> & IUserSession & Required<{
+declare const UserSessionMongoSchema: mongoose.Schema<IUserSession, mongoose.Model<IUserSession, any, any, any, mongoose.Document<unknown, any, IUserSession, any, {}> & IUserSession & Required<{
     _id: string;
 }> & {
     __v: number;
-}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IUserSession, mongoose.Document<unknown, {}, mongoose.FlatRecord<IUserSession>> & mongoose.FlatRecord<IUserSession> & Required<{
+}, any>, {}, {}, {}, {}, mongoose.DefaultSchemaOptions, IUserSession, mongoose.Document<unknown, {}, mongoose.FlatRecord<IUserSession>, {}, mongoose.ResolveSchemaOptions<mongoose.DefaultSchemaOptions>> & mongoose.FlatRecord<IUserSession> & Required<{
     _id: string;
 }> & {
     __v: number;

package/types/schemas/PasswordSchema.d.ts

@@ -3,11 +3,11 @@ declare const MyPasswordBodyRequestSchema: z.ZodObject<{
     currentPassword: z.ZodString;
     newPassword: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    newPassword?: string;
     currentPassword?: string;
-}, {
     newPassword?: string;
+}, {
     currentPassword?: string;
+    newPassword?: string;
 }>;
 declare const PasswordBodyRequestSchema: z.ZodObject<{
     newPassword: z.ZodString;

package/types/schemas/RegisterSchema.d.ts

@@ -9,14 +9,14 @@ declare const RegisterBodyRequestSchema: z.ZodObject<{
     name?: string;
     username?: string;
     email?: string;
-    phone?: string;
     password?: string;
+    phone?: string;
 }, {
     name?: string;
     username?: string;
     email?: string;
-    phone?: string;
     password?: string;
+    phone?: string;
 }>;
 declare const RegisterBodyResponseSchema: z.ZodObject<{
     success: z.ZodBoolean;

package/types/schemas/RoleSchema.d.ts

@@ -6,24 +6,20 @@ declare const RoleBaseSchema: import("zod").ZodObject<{
     childRoles: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
 }, "strip", import("zod").ZodTypeAny, {
     name?: string;
+    permissions?: string[];
     icon?: string;
     color?: string;
-    permissions?: string[];
     childRoles?: string[];
 }, {
     name?: string;
+    permissions?: string[];
     icon?: string;
     color?: string;
-    permissions?: string[];
     childRoles?: string[];
 }>;
-declare const RoleSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+declare const RoleSchema: import("zod").ZodObject<{
     name: import("zod").ZodString;
-    permissions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
-    icon: import("zod").ZodOptional<import("zod").ZodString>;
-    color: import("zod").ZodOptional<import("zod").ZodString>;
-    childRoles: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
-}, {
+} & {
     _id: import("zod").ZodString;
     id: import("zod").ZodOptional<import("zod").ZodString>;
     permissions: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
@@ -35,46 +31,46 @@ declare const RoleSchema: import("zod").ZodObject<import("zod").objectUtil.exten
         id: import("zod").ZodOptional<import("zod").ZodString>;
         name: import("zod").ZodString;
     }, "strip", import("zod").ZodTypeAny, {
-        _id?: string;
         id?: string;
         name?: string;
-    }, {
         _id?: string;
+    }, {
         id?: string;
         name?: string;
+        _id?: string;
     }>, "many">>;
     createdAt: import("zod").ZodOptional<import("zod").ZodDate>;
     updatedAt: import("zod").ZodOptional<import("zod").ZodDate>;
-}>, "strip", import("zod").ZodTypeAny, {
-    _id?: string;
+}, "strip", import("zod").ZodTypeAny, {
     id?: string;
     name?: string;
+    _id?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    permissions?: string[];
     icon?: string;
     color?: string;
-    permissions?: string[];
     childRoles?: {
-        _id?: string;
         id?: string;
         name?: string;
+        _id?: string;
     }[];
     readonly?: boolean;
-    createdAt?: Date;
-    updatedAt?: Date;
 }, {
-    _id?: string;
     id?: string;
     name?: string;
+    _id?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+    permissions?: string[];
     icon?: string;
     color?: string;
-    permissions?: string[];
     childRoles?: {
-        _id?: string;
         id?: string;
         name?: string;
+        _id?: string;
     }[];
     readonly?: boolean;
-    createdAt?: Date;
-    updatedAt?: Date;
 }>;
 export default RoleSchema;
 export { RoleSchema, RoleBaseSchema };

package/types/schemas/RoleSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RoleSchema.d.ts","sourceRoot":"","sources":["../../src/schemas/RoleSchema.ts"],"names":[],"mappings":"AAEA,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;EAQlB,CAAA;AAEF,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcd,CAAA;AAIF,eAAe,UAAU,CAAA;AAEzB,OAAO,EAAC,UAAU,EAAE,cAAc,EAAC,CAAA"}
+{"version":3,"file":"RoleSchema.d.ts","sourceRoot":"","sources":["../../src/schemas/RoleSchema.ts"],"names":[],"mappings":"AAEA,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;EAQlB,CAAA;AAEF,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcd,CAAA;AAIF,eAAe,UAAU,CAAA;AAEzB,OAAO,EAAC,UAAU,EAAE,cAAc,EAAC,CAAA"}

package/types/schemas/TenantSchema.d.ts

@@ -5,26 +5,26 @@ declare const TenantBaseSchema: import("zod").ZodObject<{
 }, {
     name?: string;
 }>;
-declare const TenantSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+declare const TenantSchema: import("zod").ZodObject<{
     name: import("zod").ZodString;
-}, {
+} & {
     _id: import("zod").ZodString;
     id: import("zod").ZodOptional<import("zod").ZodString>;
     custom: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
     createdAt: import("zod").ZodDate;
     updatedAt: import("zod").ZodDate;
-}>, "strip", import("zod").ZodTypeAny, {
-    name?: string;
-    _id?: string;
+}, "strip", import("zod").ZodTypeAny, {
     id?: string;
+    name?: string;
     custom?: Record<string, any>;
+    _id?: string;
     createdAt?: Date;
     updatedAt?: Date;
 }, {
-    name?: string;
-    _id?: string;
     id?: string;
+    name?: string;
     custom?: Record<string, any>;
+    _id?: string;
     createdAt?: Date;
     updatedAt?: Date;
 }>;

package/types/schemas/TokenPayloadSchema.d.ts

@@ -11,8 +11,8 @@ declare const TokenPayloadSchema: z.ZodObject<{
     apiKeyName: z.ZodNullable<z.ZodOptional<z.ZodString>>;
 }, "strip", z.ZodTypeAny, {
     id?: string;
-    username?: string;
     session?: string;
+    username?: string;
     roleId?: string;
     roleName?: string;
     tenantId?: string;
@@ -21,8 +21,8 @@ declare const TokenPayloadSchema: z.ZodObject<{
     apiKeyName?: string;
 }, {
     id?: string;
-    username?: string;
     session?: string;
+    username?: string;
     roleId?: string;
     roleName?: string;
     tenantId?: string;

package/types/schemas/UserApiKeySchema.d.ts

@@ -11,27 +11,27 @@ declare const UserApiKeyBaseSchema: import("zod").ZodObject<{
     ipv4?: string[];
     ipv6?: string[];
 }>;
-declare const UserApiKeySchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+declare const UserApiKeySchema: import("zod").ZodObject<{
     name: import("zod").ZodString;
     ipv4: import("zod").ZodArray<import("zod").ZodString, "many">;
     ipv6: import("zod").ZodArray<import("zod").ZodString, "many">;
-}, {
+} & {
     _id: import("zod").ZodString;
     id: import("zod").ZodOptional<import("zod").ZodString>;
     createdBy: import("zod").ZodString;
-}>, "strip", import("zod").ZodTypeAny, {
+}, "strip", import("zod").ZodTypeAny, {
+    id?: string;
     name?: string;
     ipv4?: string[];
     ipv6?: string[];
     _id?: string;
-    id?: string;
     createdBy?: string;
 }, {
+    id?: string;
     name?: string;
     ipv4?: string[];
     ipv6?: string[];
     _id?: string;
-    id?: string;
     createdBy?: string;
 }>;
 export default UserApiKeyBaseSchema;

package/types/schemas/UserLoginFailSchema.d.ts

@@ -12,14 +12,14 @@ declare const UserLoginFailBaseSchema: z.ZodObject<{
     ip?: string;
     username?: string;
 }>;
-declare const UserLoginFailSchema: z.ZodObject<z.objectUtil.extendShape<{
+declare const UserLoginFailSchema: z.ZodObject<{
     username: z.ZodString;
     userAgent: z.ZodOptional<z.ZodString>;
     ip: z.ZodOptional<z.ZodString>;
-}, {
+} & {
     _id: z.ZodString;
     createdAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
-}>, "strip", z.ZodTypeAny, {
+}, "strip", z.ZodTypeAny, {
     userAgent?: string;
     ip?: string;
     username?: string;
@@ -34,4 +34,4 @@ declare const UserLoginFailSchema: z.ZodObject<z.objectUtil.extendShape<{
 }>;
 export default UserLoginFailSchema;
 export { UserLoginFailSchema, UserLoginFailBaseSchema };
-//# sourceMappingURL=UserLoginFailMongoSchema.d.ts.map
+//# sourceMappingURL=UserLoginFailSchema.d.ts.map

package/types/schemas/UserSchema.d.ts

@@ -7,23 +7,23 @@ declare const UserBaseSchema: import("zod").ZodObject<{
     role: import("zod").ZodString;
     tenant: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
 }, "strip", import("zod").ZodTypeAny, {
+    tenant?: string;
     name?: string;
     username?: string;
+    role?: string;
     email?: string;
-    phone?: string;
     active?: boolean;
-    role?: string;
-    tenant?: string;
+    phone?: string;
 }, {
+    tenant?: string;
     name?: string;
     username?: string;
+    role?: string;
     email?: string;
-    phone?: string;
     active?: boolean;
-    role?: string;
-    tenant?: string;
+    phone?: string;
 }>;
-declare const UserCreateSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+declare const UserCreateSchema: import("zod").ZodObject<{
     name: import("zod").ZodString;
     username: import("zod").ZodString;
     email: import("zod").ZodString;
@@ -31,28 +31,28 @@ declare const UserCreateSchema: import("zod").ZodObject<import("zod").objectUtil
     active: import("zod").ZodOptional<import("zod").ZodBoolean>;
     role: import("zod").ZodString;
     tenant: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
-}, {
+} & {
     password: import("zod").ZodString;
-}>, "strip", import("zod").ZodTypeAny, {
+}, "strip", import("zod").ZodTypeAny, {
+    tenant?: string;
     name?: string;
     username?: string;
-    email?: string;
-    phone?: string;
-    active?: boolean;
     role?: string;
-    tenant?: string;
+    email?: string;
     password?: string;
+    active?: boolean;
+    phone?: string;
 }, {
+    tenant?: string;
     name?: string;
     username?: string;
-    email?: string;
-    phone?: string;
-    active?: boolean;
     role?: string;
-    tenant?: string;
+    email?: string;
     password?: string;
+    active?: boolean;
+    phone?: string;
 }>;
-declare const UserUpdateSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+declare const UserUpdateSchema: import("zod").ZodObject<{
     name: import("zod").ZodString;
     username: import("zod").ZodString;
     email: import("zod").ZodString;
@@ -60,32 +60,29 @@ declare const UserUpdateSchema: import("zod").ZodObject<import("zod").objectUtil
     active: import("zod").ZodOptional<import("zod").ZodBoolean>;
     role: import("zod").ZodString;
     tenant: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
-}, {}>, "strip", import("zod").ZodTypeAny, {
+}, "strip", import("zod").ZodTypeAny, {
+    tenant?: string;
     name?: string;
     username?: string;
+    role?: string;
     email?: string;
-    phone?: string;
     active?: boolean;
-    role?: string;
-    tenant?: string;
+    phone?: string;
 }, {
+    tenant?: string;
     name?: string;
     username?: string;
+    role?: string;
     email?: string;
-    phone?: string;
     active?: boolean;
-    role?: string;
-    tenant?: string;
+    phone?: string;
 }>;
-declare const UserSchema: import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+declare const UserSchema: import("zod").ZodObject<{
     name: import("zod").ZodString;
     username: import("zod").ZodString;
     email: import("zod").ZodString;
     phone: import("zod").ZodOptional<import("zod").ZodString>;
-    active: import("zod").ZodOptional<import("zod").ZodBoolean>;
-    role: import("zod").ZodString;
-    tenant: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
-}, {
+} & {
     _id: import("zod").ZodString;
     role: import("zod").ZodOptional<import("zod").ZodObject<{
         _id: import("zod").ZodString;
@@ -105,23 +102,23 @@ declare const UserSchema: import("zod").ZodObject<import("zod").objectUtil.exten
             _id?: string;
         }>, "many">>;
     }, "strip", import("zod").ZodTypeAny, {
+        id?: string;
         name?: string;
         _id?: string;
-        id?: string;
+        permissions?: string[];
         icon?: string;
         color?: string;
-        permissions?: string[];
         childRoles?: {
             name?: string;
             _id?: string;
         }[];
     }, {
+        id?: string;
         name?: string;
         _id?: string;
-        id?: string;
+        permissions?: string[];
         icon?: string;
         color?: string;
-        permissions?: string[];
         childRoles?: {
             name?: string;
             _id?: string;
@@ -134,72 +131,72 @@ declare const UserSchema: import("zod").ZodObject<import("zod").objectUtil.exten
         name: import("zod").ZodString;
         custom: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
     }, "strip", import("zod").ZodTypeAny, {
-        name?: string;
-        _id?: string;
         id?: string;
-        custom?: Record<string, any>;
-    }, {
         name?: string;
+        custom?: Record<string, any>;
         _id?: string;
+    }, {
         id?: string;
+        name?: string;
         custom?: Record<string, any>;
+        _id?: string;
     }>>>;
     createdAt: import("zod").ZodOptional<import("zod").ZodDate>;
     avatar: import("zod").ZodOptional<import("zod").ZodString>;
-}>, "strip", import("zod").ZodTypeAny, {
+}, "strip", import("zod").ZodTypeAny, {
+    tenant?: {
+        id?: string;
+        name?: string;
+        custom?: Record<string, any>;
+        _id?: string;
+    };
     name?: string;
+    avatar?: string;
     username?: string;
-    email?: string;
-    phone?: string;
-    active?: boolean;
     role?: {
+        id?: string;
         name?: string;
         _id?: string;
-        id?: string;
+        permissions?: string[];
         icon?: string;
         color?: string;
-        permissions?: string[];
         childRoles?: {
             name?: string;
             _id?: string;
         }[];
     };
+    email?: string;
+    _id?: string;
+    createdAt?: Date;
+    active?: boolean;
+    phone?: string;
+}, {
     tenant?: {
-        name?: string;
-        _id?: string;
         id?: string;
+        name?: string;
         custom?: Record<string, any>;
+        _id?: string;
     };
-    _id?: string;
-    createdAt?: Date;
-    avatar?: string;
-}, {
     name?: string;
+    avatar?: string;
     username?: string;
-    email?: string;
-    phone?: string;
-    active?: boolean;
     role?: {
+        id?: string;
         name?: string;
         _id?: string;
-        id?: string;
+        permissions?: string[];
         icon?: string;
         color?: string;
-        permissions?: string[];
         childRoles?: {
             name?: string;
             _id?: string;
         }[];
     };
-    tenant?: {
-        name?: string;
-        _id?: string;
-        id?: string;
-        custom?: Record<string, any>;
-    };
+    email?: string;
     _id?: string;
     createdAt?: Date;
-    avatar?: string;
+    active?: boolean;
+    phone?: string;
 }>;
 export { UserBaseSchema, UserSchema, UserCreateSchema, UserUpdateSchema, };
 //# sourceMappingURL=UserSchema.d.ts.map

package/types/schemas/UserSchema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"UserSchema.d.ts","sourceRoot":"","sources":["../../src/schemas/UserSchema.ts"],"names":[],"mappings":"AAEA,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;EAclB,CAAA;AAEF,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKpB,CAAC;AAGH,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;EAA4B,CAAC;AAEnD,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqBV,CAAC;AAGP,OAAO,EACH,cAAc,EACd,UAAU,EACV,gBAAgB,EAChB,gBAAgB,GACnB,CAAA"}
+{"version":3,"file":"UserSchema.d.ts","sourceRoot":"","sources":["../../src/schemas/UserSchema.ts"],"names":[],"mappings":"AAEA,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;EAclB,CAAA;AAEF,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKpB,CAAC;AAGH,QAAA,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;EAA4B,CAAC;AAEnD,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqBV,CAAC;AAGP,OAAO,EACH,cAAc,EACd,UAAU,EACV,gBAAgB,EAChB,gBAAgB,GACnB,CAAA"}

package/types/schemas/UserSessionSchema.d.ts

@@ -5,55 +5,54 @@ declare const UserSessionBaseSchema: z.ZodObject<{
     userAgent: z.ZodOptional<z.ZodString>;
     ip: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
-    uuid?: string;
+    userAgent?: string;
     ip?: string;
     user?: string;
-    userAgent?: string;
-}, {
     uuid?: string;
+}, {
+    userAgent?: string;
     ip?: string;
     user?: string;
-    userAgent?: string;
+    uuid?: string;
 }>;
-declare const UserSessionSchema: z.ZodObject<z.objectUtil.extendShape<{
+declare const UserSessionSchema: z.ZodObject<{
     uuid: z.ZodString;
-    user: z.ZodString;
     userAgent: z.ZodOptional<z.ZodString>;
     ip: z.ZodOptional<z.ZodString>;
-}, {
+} & {
     _id: z.ZodString;
     user: z.ZodObject<{
         _id: z.ZodString;
         username: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        _id?: string;
         username?: string;
-    }, {
         _id?: string;
+    }, {
         username?: string;
+        _id?: string;
     }>;
     createdAt: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
-}>, "strip", z.ZodTypeAny, {
-    _id?: string;
-    createdAt?: Date;
-    uuid?: string;
+}, "strip", z.ZodTypeAny, {
+    userAgent?: string;
     ip?: string;
     user?: {
-        _id?: string;
         username?: string;
+        _id?: string;
     };
-    userAgent?: string;
-}, {
     _id?: string;
     createdAt?: Date;
     uuid?: string;
+}, {
+    userAgent?: string;
     ip?: string;
     user?: {
-        _id?: string;
         username?: string;
+        _id?: string;
     };
-    userAgent?: string;
+    _id?: string;
+    createdAt?: Date;
+    uuid?: string;
 }>;
 export default UserSessionSchema;
 export { UserSessionSchema, UserSessionBaseSchema };
-//# sourceMappingURL=UserSessionMongoSchema.d.ts.map
+//# sourceMappingURL=UserSessionSchema.d.ts.map