@ackplus/nest-auth 1.1.1 → 1.1.2

package/src/lib/user/services/{user.service.ts → user.service.js}

@@ -1,196 +1,162 @@
-import { Injectable, NotFoundException, BadRequestException, ConflictException } from '@nestjs/common';
-import { InjectRepository } from '@nestjs/typeorm';
-import { FindManyOptions, FindOneOptions, IsNull, Not, Repository } from 'typeorm';
-import { NestAuthUser } from '../entities/user.entity';
-import { EventEmitter2 } from '@nestjs/event-emitter';
-import { EMAIL_AUTH_PROVIDER, NestAuthEvents, PHONE_AUTH_PROVIDER } from '../../auth.constants';
-import { UserUpdatedEvent } from '../events/user-updated.event';
-import { UserDeletedEvent } from '../events/user-deleted.event';
-import { UserCreatedEvent } from '../events/user-created.event';
-import { TenantService } from '../../tenant';
-import { DebugLoggerService } from '../../core/services/debug-logger.service';
-
-@Injectable()
-export class UserService {
-    constructor(
-        @InjectRepository(NestAuthUser)
-        private userRepository: Repository<NestAuthUser>,
-        private eventEmitter: EventEmitter2,
-        private tenantService: TenantService,
-        private debugLogger: DebugLoggerService
-    ) { }
-
-    async createUser(data: Partial<NestAuthUser>): Promise<NestAuthUser> {
-        this.debugLogger.logFunctionEntry('createUser', 'UserService', { email: data.email, phone: data.phone, hasPassword: !!(data as any).password });
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const typeorm_2 = require("typeorm");
+const user_entity_1 = require("../entities/user.entity");
+const event_emitter_1 = require("@nestjs/event-emitter");
+const auth_constants_1 = require("../../auth.constants");
+const user_updated_event_1 = require("../events/user-updated.event");
+const user_deleted_event_1 = require("../events/user-deleted.event");
+const user_created_event_1 = require("../events/user-created.event");
+const tenant_1 = require("../../tenant");
+const debug_logger_service_1 = require("../../core/services/debug-logger.service");
+let UserService = class UserService {
+    constructor(userRepository, eventEmitter, tenantService, debugLogger) {
+        this.userRepository = userRepository;
+        this.eventEmitter = eventEmitter;
+        this.tenantService = tenantService;
+        this.debugLogger = debugLogger;
+    }
+    async createUser(data) {
+        this.debugLogger.logFunctionEntry('createUser', 'UserService', { email: data.email, phone: data.phone, hasPassword: !!data.password });
         try {
             const { email, phone } = data;
-
             const tenantId = await this.tenantService.resolveTenantId(data?.tenantId || null);
             this.debugLogger.logUserOperation('createUser', undefined, { email: !!email, phone: !!phone, resolvedTenantId: tenantId });
-
             if (!tenantId) {
                 this.debugLogger.error('Tenant ID is required for user creation', 'UserService', { email: !!email, phone: !!phone });
-                throw new BadRequestException('Tenant ID is required');
+                throw new common_1.BadRequestException('Tenant ID is required');
             }
-
             if (!email && !phone) {
                 this.debugLogger.error('Neither email nor phone provided for user creation', 'UserService');
-                throw new BadRequestException('Either email or phone must be provided');
+                throw new common_1.BadRequestException('Either email or phone must be provided');
             }
-
             // Check for existing user with same email or phone in the same tenant
             this.debugLogger.debug('Checking for existing user', 'UserService', { email: !!email, phone: !!phone, tenantId });
             let existingUser = null;
-
             // Normalize email to lowercase for case-insensitive matching
             const normalizedEmail = email ? email.toLowerCase().trim() : email;
-
             if (phone) {
                 existingUser = await this.userRepository.findOne({
                     where: { phone, tenantId }
                 });
             }
-
             if (!existingUser && normalizedEmail) {
                 existingUser = await this.userRepository.findOne({
                     where: { email: normalizedEmail, tenantId }
                 });
             }
-
             if (existingUser) {
                 this.debugLogger.warn('User already exists', 'UserService', { email: !!email, phone: !!phone, tenantId, existingUserId: existingUser.id });
-                throw new ConflictException({
+                throw new common_1.ConflictException({
                     message: `User with ${email ? `email ${email}` : ''}${email && phone ? ' or ' : ''}${phone ? `phone ${phone}` : ''} already exists.`,
                     code: 'USER_ALREADY_EXISTS'
                 });
             }
-
             this.debugLogger.debug('Creating new user', 'UserService', { email: !!email, phone: !!phone, tenantId });
             const user = this.userRepository.create({
                 ...data,
                 email: normalizedEmail || data.email,
                 tenantId
             });
-
             await this.userRepository.save(user);
             this.debugLogger.info('User created successfully', 'UserService', { userId: user.id, tenantId });
-
             // Create authentication identity for login
             if (normalizedEmail) {
                 this.debugLogger.debug('Creating email identity', 'UserService', { userId: user.id });
-                await user.findOrCreateIdentity(EMAIL_AUTH_PROVIDER, normalizedEmail);
+                await user.findOrCreateIdentity(auth_constants_1.EMAIL_AUTH_PROVIDER, normalizedEmail);
             }
             if (phone) {
                 this.debugLogger.debug('Creating phone identity', 'UserService', { userId: user.id });
-                await user.findOrCreateIdentity(PHONE_AUTH_PROVIDER, phone);
+                await user.findOrCreateIdentity(auth_constants_1.PHONE_AUTH_PROVIDER, phone);
             }
-
             // Emit user created event
             this.debugLogger.debug('Emitting user created event', 'UserService', { userId: user.id });
-            await this.eventEmitter.emitAsync(
-                NestAuthEvents.USER_CREATED,
-                new UserCreatedEvent({
-                    user
-                })
-            );
-
+            await this.eventEmitter.emitAsync(auth_constants_1.NestAuthEvents.USER_CREATED, new user_created_event_1.UserCreatedEvent({
+                user
+            }));
             this.debugLogger.logFunctionExit('createUser', 'UserService', { userId: user.id });
             return user;
-
-        } catch (error) {
+        }
+        catch (error) {
             this.debugLogger.logError(error, 'createUser', { email: data.email, phone: data.phone });
             throw error;
         }
     }
-
-    async getUserById(id: string, options?: FindOneOptions<NestAuthUser>): Promise<NestAuthUser> {
+    async getUserById(id, options) {
         this.debugLogger.debug('Getting user by ID', 'UserService', { userId: id });
-
         if (!id) {
             this.debugLogger.warn('No user ID provided', 'UserService');
             return null;
         }
-
         const user = await this.userRepository.findOne({
             ...(options ? options : {}),
             where: { id }
         });
-
         if (!user) {
             this.debugLogger.warn('User not found', 'UserService', { userId: id });
             return null;
         }
-
         this.debugLogger.debug('User found', 'UserService', { userId: user.id });
         return user;
     }
-
-    async getUserByEmail(email: string, tenantId?: string, options?: FindOneOptions<NestAuthUser>): Promise<NestAuthUser> {
+    async getUserByEmail(email, tenantId, options) {
         this.debugLogger.debug('Getting user by email', 'UserService', { email: !!email, tenantId });
-
         tenantId = await this.tenantService.resolveTenantId(tenantId || null);
         if (!email) {
             this.debugLogger.warn('No email provided for user lookup', 'UserService');
             return null;
         }
-
         // Normalize email to lowercase for case-insensitive matching
         const normalizedEmail = email.toLowerCase().trim();
-
         const user = await this.userRepository.findOne({
             ...(options ? options : {}),
             where: {
                 email: normalizedEmail,
-                tenantId: tenantId || IsNull()
+                tenantId: tenantId || (0, typeorm_2.IsNull)()
             }
         });
-
         if (user) {
             this.debugLogger.debug('User found by email', 'UserService', { userId: user.id, tenantId });
-        } else {
+        }
+        else {
             this.debugLogger.debug('No user found with email', 'UserService', { tenantId });
         }
-
         return user;
     }
-
-    async getUserByPhone(phone: string, tenantId?: string, options?: FindOneOptions<NestAuthUser>): Promise<NestAuthUser> {
+    async getUserByPhone(phone, tenantId, options) {
         this.debugLogger.debug('Getting user by phone', 'UserService', { phone: !!phone, tenantId });
-
         tenantId = await this.tenantService.resolveTenantId(tenantId || null);
         if (!phone) {
             this.debugLogger.warn('No phone provided for user lookup', 'UserService');
             return null;
         }
-
         const user = await this.userRepository.findOne({
             ...(options ? options : {}),
             where: {
                 phone,
-                tenantId: tenantId || IsNull()
+                tenantId: tenantId || (0, typeorm_2.IsNull)()
             }
         });
-
         if (user) {
             this.debugLogger.debug('User found by phone', 'UserService', { userId: user.id, tenantId });
-        } else {
+        }
+        else {
             this.debugLogger.debug('No user found with phone', 'UserService', { tenantId });
         }
-
         return user;
     }
-
-    async getUsers(options?: FindManyOptions<NestAuthUser>): Promise<NestAuthUser[]> {
+    async getUsers(options) {
         return this.userRepository.find(options);
     }
-
-    async getUsersByTenant(tenantId: string, options?: FindManyOptions<NestAuthUser>): Promise<NestAuthUser[]> {
+    async getUsersByTenant(tenantId, options) {
         tenantId = await this.tenantService.resolveTenantId(tenantId || null);
         if (!tenantId) {
             return [];
         }
-
         return this.userRepository.find({
             ...(options ? options : {}),
             where: {
@@ -199,218 +165,180 @@ export class UserService {
             }
         });
     }
-
-    async updateUser(id: string, data: Partial<NestAuthUser>): Promise<NestAuthUser> {
+    async updateUser(id, data) {
         this.debugLogger.logFunctionEntry('updateUser', 'UserService', { userId: id, fields: Object.keys(data) });
-
         try {
             const user = await this.getUserById(id);
-
             if (!user) {
                 this.debugLogger.error('User not found for update', 'UserService', { userId: id });
-                throw new NotFoundException({
+                throw new common_1.NotFoundException({
                     message: `User with ID ${id} not found`,
                     code: 'USER_NOT_FOUND'
                 });
             }
-
             // If email or phone is being changed, check for conflicts
             if (data.email || data.phone) {
                 this.debugLogger.debug('Checking for conflicts during user update', 'UserService', { userId: id, email: !!data.email, phone: !!data.phone });
-
                 let existingUser = null;
-
                 if (data.phone) {
                     existingUser = await this.userRepository.findOne({
-                        where: { phone: data.phone, tenantId: user.tenantId, id: Not(user.id) }
+                        where: { phone: data.phone, tenantId: user.tenantId, id: (0, typeorm_2.Not)(user.id) }
                     });
                 }
-
                 if (!existingUser && data.email) {
                     existingUser = await this.userRepository.findOne({
-                        where: { email: data.email, tenantId: user.tenantId, id: Not(user.id) }
+                        where: { email: data.email, tenantId: user.tenantId, id: (0, typeorm_2.Not)(user.id) }
                     });
                 }
-
                 if (existingUser) {
                     this.debugLogger.warn('Conflict detected during user update', 'UserService', { userId: id, conflictingUserId: existingUser.id });
-                    throw new ConflictException({
+                    throw new common_1.ConflictException({
                         message: `User with ${data.email ? `email ${data.email}` : ''}${data.email && data.phone ? ' or ' : ''}${data.phone ? `phone ${data.phone}` : ''} already exists.`,
                         code: 'USER_ALREADY_EXISTS'
                     });
                 }
             }
-
             // Prevent changing tenant
             delete data.tenantId;
-
             this.debugLogger.debug('Updating user data', 'UserService', { userId: id, fields: Object.keys(data) });
             Object.assign(user, data);
             const updatedUser = await this.userRepository.save(user);
             this.debugLogger.info('User updated successfully', 'UserService', { userId: updatedUser.id });
-
             if (data.email) {
                 this.debugLogger.debug('Updating email identity', 'UserService', { userId: id });
-                await user.updateOrCreateIdentity(EMAIL_AUTH_PROVIDER, { providerId: data.email });
+                await user.updateOrCreateIdentity(auth_constants_1.EMAIL_AUTH_PROVIDER, { providerId: data.email });
             }
-
             if (data.phone) {
                 this.debugLogger.debug('Updating phone identity', 'UserService', { userId: id });
-                await user.updateOrCreateIdentity(PHONE_AUTH_PROVIDER, { providerId: data.phone });
+                await user.updateOrCreateIdentity(auth_constants_1.PHONE_AUTH_PROVIDER, { providerId: data.phone });
             }
-
             // Emit user updated event
             this.debugLogger.debug('Emitting user updated event', 'UserService', { userId: updatedUser.id });
-            await this.eventEmitter.emitAsync(
-                NestAuthEvents.USER_UPDATED,
-                new UserUpdatedEvent({
-                    user: updatedUser,
-                    tenantId: updatedUser.tenantId,
-                    updatedFields: Object.keys(data)
-                })
-            );
-
+            await this.eventEmitter.emitAsync(auth_constants_1.NestAuthEvents.USER_UPDATED, new user_updated_event_1.UserUpdatedEvent({
+                user: updatedUser,
+                tenantId: updatedUser.tenantId,
+                updatedFields: Object.keys(data)
+            }));
             this.debugLogger.logFunctionExit('updateUser', 'UserService', { userId: updatedUser.id });
             return updatedUser;
-
-        } catch (error) {
+        }
+        catch (error) {
             this.debugLogger.logError(error, 'updateUser', { userId: id, fields: Object.keys(data) });
             throw error;
         }
     }
-
-    async deleteUser(id: string): Promise<void> {
+    async deleteUser(id) {
         this.debugLogger.logFunctionEntry('deleteUser', 'UserService', { userId: id });
-
         try {
             const user = await this.getUserById(id);
-
             if (!user) {
                 this.debugLogger.error('User not found for deletion', 'UserService', { userId: id });
-                throw new NotFoundException({
+                throw new common_1.NotFoundException({
                     message: `User with ID ${id} not found`,
                     code: 'USER_NOT_FOUND'
                 });
             }
-
             // Emit user deleted event before deletion
             this.debugLogger.debug('Emitting user deleted event', 'UserService', { userId: id });
-            await this.eventEmitter.emitAsync(
-                NestAuthEvents.USER_DELETED,
-                new UserDeletedEvent({
-                    user,
-                    tenantId: user.tenantId
-                })
-            );
-
+            await this.eventEmitter.emitAsync(auth_constants_1.NestAuthEvents.USER_DELETED, new user_deleted_event_1.UserDeletedEvent({
+                user,
+                tenantId: user.tenantId
+            }));
             this.debugLogger.debug('Deleting user from database', 'UserService', { userId: id });
             await this.userRepository.remove(user);
             this.debugLogger.info('User deleted successfully', 'UserService', { userId: id });
-
             this.debugLogger.logFunctionExit('deleteUser', 'UserService', { userId: id });
-
-        } catch (error) {
+        }
+        catch (error) {
             this.debugLogger.logError(error, 'deleteUser', { userId: id });
             throw error;
         }
     }
-
-    async verifyUser(id: string, verificationType?: 'email' | 'phone' | 'none'): Promise<NestAuthUser> {
+    async verifyUser(id, verificationType) {
         const user = await this.getUserById(id);
-
         if (!user) {
-            throw new NotFoundException({
+            throw new common_1.NotFoundException({
                 message: `User with ID ${id} not found`,
                 code: 'USER_NOT_FOUND'
             });
         }
-
         if (verificationType === 'email') {
             user.emailVerifiedAt = new Date();
-        } else if (verificationType === 'phone') {
+        }
+        else if (verificationType === 'phone') {
             user.phoneVerifiedAt = new Date();
         }
-
         user.isVerified = true;
-
         return this.userRepository.save(user);
     }
-
-    async unverifyUser(id: string, verificationType?: 'email' | 'phone' | 'none'): Promise<NestAuthUser> {
+    async unverifyUser(id, verificationType) {
         const user = await this.getUserById(id);
-
         if (!user) {
-            throw new NotFoundException({
+            throw new common_1.NotFoundException({
                 message: `User with ID ${id} not found`,
                 code: 'USER_NOT_FOUND'
             });
         }
-
         if (verificationType === 'email') {
             user.emailVerifiedAt = null;
-        } else if (verificationType === 'phone') {
+        }
+        else if (verificationType === 'phone') {
             user.phoneVerifiedAt = null;
         }
-
         user.isVerified = false;
-
         // Update isVerified flag based on remaining verification status
         user.isVerified = Boolean(user.emailVerifiedAt || user.phoneVerifiedAt);
-
         return this.userRepository.save(user);
     }
-
-    async updateUserStatus(id: string, isActive: boolean): Promise<NestAuthUser> {
+    async updateUserStatus(id, isActive) {
         const user = await this.getUserById(id);
-
         if (!user) {
-            throw new NotFoundException({
+            throw new common_1.NotFoundException({
                 message: `User with ID ${id} not found`,
                 code: 'USER_NOT_FOUND'
             });
         }
-
         user.isActive = isActive;
         return this.userRepository.save(user);
     }
-
-    async updateUserMetadata(id: string, metadata: Record<string, any>): Promise<NestAuthUser> {
+    async updateUserMetadata(id, metadata) {
         const user = await this.getUserById(id);
-
         if (!user) {
-            throw new NotFoundException({
+            throw new common_1.NotFoundException({
                 message: `User with ID ${id} not found`,
                 code: 'USER_NOT_FOUND'
             });
         }
-
         user.metadata = {
             ...user.metadata,
             ...metadata
         };
-
         return this.userRepository.save(user);
     }
-
-    async countUsers(options?: FindManyOptions<NestAuthUser>): Promise<number> {
+    async countUsers(options) {
         return this.userRepository.count(options);
     }
-
-    async getUsersAndCount(options?: FindManyOptions<NestAuthUser>): Promise<[NestAuthUser[], number]> {
+    async getUsersAndCount(options) {
         return this.userRepository.findAndCount(options);
     }
-
-    async getUsersByRole(roleName: string, guard: string): Promise<NestAuthUser[]> {
+    async getUsersByRole(roleName, guard) {
         this.debugLogger.debug('Getting users by role', 'UserService', { roleName, guard });
-
         const users = await this.userRepository
             .createQueryBuilder('user')
             .leftJoinAndSelect('user.roles', 'role')
             .where('role.name = :roleName', { roleName })
             .andWhere('role.guard = :guard', { guard })
             .getMany();
-
         this.debugLogger.debug('Found users with role', 'UserService', { roleName, count: users.length });
         return users;
     }
-}
+};
+exports.UserService = UserService;
+exports.UserService = UserService = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(0, (0, typeorm_1.InjectRepository)(user_entity_1.NestAuthUser)),
+    tslib_1.__metadata("design:paramtypes", [typeorm_2.Repository,
+        event_emitter_1.EventEmitter2,
+        tenant_1.TenantService,
+        debug_logger_service_1.DebugLoggerService])
+], UserService);

package/src/lib/user/user.module.d.ts

@@ -0,0 +1,3 @@
+export declare class UserModule {
+}
+//# sourceMappingURL=user.module.d.ts.map

package/src/lib/user/user.module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user.module.d.ts","sourceRoot":"","sources":["../../../../../../packages/nest-auth/src/lib/user/user.module.ts"],"names":[],"mappings":"AAUA,qBAea,UAAU;CAAI"}

package/src/lib/user/user.module.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserModule = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("@nestjs/typeorm");
+const user_entity_1 = require("./entities/user.entity");
+const user_service_1 = require("./services/user.service");
+const access_key_service_1 = require("./services/access-key.service");
+const auth_module_1 = require("../auth/auth.module");
+const access_key_entity_1 = require("./entities/access-key.entity");
+const identity_entity_1 = require("./entities/identity.entity");
+const tenant_module_1 = require("../tenant/tenant.module");
+let UserModule = class UserModule {
+};
+exports.UserModule = UserModule;
+exports.UserModule = UserModule = tslib_1.__decorate([
+    (0, common_1.Module)({
+        imports: [
+            typeorm_1.TypeOrmModule.forFeature([user_entity_1.NestAuthUser, access_key_entity_1.NestAuthAccessKey, identity_entity_1.NestAuthIdentity]),
+            (0, common_1.forwardRef)(() => auth_module_1.AuthModule),
+            (0, common_1.forwardRef)(() => tenant_module_1.TenantModule),
+        ],
+        providers: [
+            user_service_1.UserService,
+            access_key_service_1.AccessKeyService,
+        ],
+        exports: [
+            user_service_1.UserService,
+            access_key_service_1.AccessKeyService,
+        ],
+    })
+], UserModule);

package/src/lib/utils/database.utils.d.ts

@@ -0,0 +1,3 @@
+import { DataSource } from 'typeorm';
+export declare function getJsonColumnType(dataSource: DataSource): string;
+//# sourceMappingURL=database.utils.d.ts.map

package/src/lib/utils/database.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database.utils.d.ts","sourceRoot":"","sources":["../../../../../../packages/nest-auth/src/lib/utils/database.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAErC,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM,CAGhE"}

package/src/lib/utils/database.utils.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJsonColumnType = getJsonColumnType;
+function getJsonColumnType(dataSource) {
+    const driver = dataSource.driver;
+    return driver.options.type === 'sqlite' ? 'simple-json' : 'jsonb';
+}

package/src/lib/utils/date.util.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Date and time utilities
+ */
+export declare class DateUtil {
+    /**
+     * Parse duration string to milliseconds
+     */
+    static parseDuration(duration: string | number): number;
+    /**
+     * Add duration to date
+     */
+    static addDuration(date: Date, duration: string | number): Date;
+    /**
+     * Check if date is in the past
+     */
+    static isPast(date: Date): boolean;
+    /**
+     * Check if date is in the future
+     */
+    static isFuture(date: Date): boolean;
+    /**
+     * Get time remaining until date
+     */
+    static getTimeUntil(date: Date): {
+        milliseconds: number;
+        seconds: number;
+        minutes: number;
+        hours: number;
+        days: number;
+        formatted: string;
+    };
+    /**
+     * Format date for display
+     */
+    static format(date: Date, format?: 'short' | 'long' | 'iso'): string;
+    /**
+     * Get relative time (e.g., "2 hours ago")
+     */
+    static getRelativeTime(date: Date): string;
+}
+//# sourceMappingURL=date.util.d.ts.map

package/src/lib/utils/date.util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"date.util.d.ts","sourceRoot":"","sources":["../../../../../../packages/nest-auth/src/lib/utils/date.util.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,qBAAa,QAAQ;IACjB;;OAEG;IACH,MAAM,CAAC,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM;IAOvD;;OAEG;IACH,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAK/D;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO;IAIlC;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO;IAIpC;;OAEG;IACH,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE,IAAI,GAAG;QAC7B,YAAY,EAAE,MAAM,CAAC;QACrB,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,IAAI,EAAE,MAAM,CAAC;QACb,SAAS,EAAE,MAAM,CAAC;KACrB;IAiBD;;OAEG;IACH,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,GAAE,OAAO,GAAG,MAAM,GAAG,KAAe,GAAG,MAAM;IAY7E;;OAEG;IACH,MAAM,CAAC,eAAe,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM;CAsB7C"}