@flusys/nestjs-auth 1.1.0-beta → 2.0.0-rc.0

package/cjs/services/branch.service.js

@@ -10,6 +10,7 @@ Object.defineProperty(exports, "BranchService", {
 });
 const _classes = require("@flusys/nestjs-shared/classes");
 const _modules = require("@flusys/nestjs-shared/modules");
+const _utils = require("@flusys/nestjs-shared/utils");
 const _common = require("@nestjs/common");
 const _companybranchentity = require("../entities/company-branch.entity");
 const _authconfigservice = require("./auth-config.service");
@@ -76,10 +77,14 @@ let BranchService = class BranchService extends _classes.RequestScopedApiService
     }
     async getExtraManipulateQuery(query, filterDto, user) {
         const result = await super.getExtraManipulateQuery(query, filterDto, user);
-        if (this.authConfig.isCompanyFeatureEnabled() && user?.companyId) {
-            query.andWhere('company_branch.company_id = :companyId', {
-                companyId: user.companyId
-            });
+        // Only apply company filter if companyId is NOT explicitly provided in filter
+        // This prevents dual filtering when user selects a specific company
+        if (!filterDto?.filter?.companyId) {
+            (0, _utils.applyCompanyFilter)(query, {
+                isCompanyFeatureEnabled: this.authConfig.isCompanyFeatureEnabled(),
+                entityAlias: 'company_branch',
+                columnName: 'company_id'
+            }, user);
         }
         return result;
     }

package/cjs/services/company-selection-session.service.js

@@ -43,7 +43,7 @@ const SESSION_TTL_MS = 5 * 60 * 1000; // 5 minutes
 let CompanySelectionSessionService = class CompanySelectionSessionService {
     /**
    * Create a new session for company/branch selection
-   */ async createSession(userId, companyId) {
+   */ async createSession(userId) {
         const sessionId = (0, _crypto.randomUUID)();
         const now = new Date();
         const expiresAt = new Date(now.getTime() + SESSION_TTL_MS);

package/cjs/services/user-permission.service.js

@@ -39,122 +39,92 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 let UserPermissionService = class UserPermissionService {
-    /** Get repository lazily - initialized on first access */ async getRepository() {
+    async getRepository() {
         if (!this._repository) {
             this._repository = await this.dataSourceProvider.getRepository(_usercompanypermissionentity.UserCompanyPermission);
         }
         return this._repository;
     }
-    // Company Permissions
-    /** Find all companies a user has access to */ async findUserCompanies(userId) {
+    // Generic Permission Operations
+    /** Find all permissions of a specific type for a user */ async findUserPermissions(userId, type) {
         const repository = await this.getRepository();
         return repository.find({
             where: {
                 userId,
-                permissionType: _usercompanypermissionentity.PermissionType.COMPANY
+                permissionType: type
             },
             relations: [
-                'company'
+                type === _usercompanypermissionentity.PermissionType.COMPANY ? 'company' : 'branch'
             ],
             order: {
                 createdAt: 'DESC'
             }
         });
     }
-    /** Assign user to a company */ async assignUserToCompany(dto) {
+    /** Assign permission to user */ async assignPermission(userId, targetId, type, metadata) {
         const repository = await this.getRepository();
-        // Check if already exists
+        const typeName = type === _usercompanypermissionentity.PermissionType.COMPANY ? 'company' : 'branch';
         const existing = await repository.findOne({
             where: {
-                userId: dto.userId,
-                targetId: dto.companyId,
-                permissionType: _usercompanypermissionentity.PermissionType.COMPANY
+                userId,
+                targetId,
+                permissionType: type
             }
         });
         if (existing) {
-            throw new _common.BadRequestException('User already assigned to this company');
+            throw new _common.ConflictException(`User already assigned to this ${typeName}`);
         }
-        const permission = repository.create({
-            userId: dto.userId,
-            permissionType: _usercompanypermissionentity.PermissionType.COMPANY,
-            targetId: dto.companyId,
-            metadata: dto.metadata
-        });
-        await repository.save(permission);
-    }
-    /** Revoke user access to a company */ async revokeCompanyAccess(userId, companyId) {
-        const repository = await this.getRepository();
-        const permission = await repository.findOne({
-            where: {
+        try {
+            await repository.save(repository.create({
                 userId,
-                targetId: companyId,
-                permissionType: _usercompanypermissionentity.PermissionType.COMPANY
+                permissionType: type,
+                targetId,
+                metadata
+            }));
+        } catch (error) {
+            if (error?.code === 'ER_DUP_ENTRY' || error?.message?.includes('Duplicate entry')) {
+                throw new _common.ConflictException(`User already assigned to this ${typeName}. Please refresh and try again.`);
             }
-        });
-        if (!permission) {
-            throw new _common.NotFoundException('Company permission not found');
+            throw error;
         }
-        await repository.remove(permission);
     }
-    // Branch Permissions
-    /** Find all branches a user has access to */ async findUserBranches(userId) {
-        const repository = await this.getRepository();
-        return repository.find({
-            where: {
-                userId,
-                permissionType: _usercompanypermissionentity.PermissionType.BRANCH
-            },
-            relations: [
-                'branch'
-            ],
-            order: {
-                createdAt: 'DESC'
-            }
-        });
-    }
-    /** Assign user to a branch */ async assignUserToBranch(dto) {
-        const repository = await this.getRepository();
-        // Check if already exists
-        const existing = await repository.findOne({
-            where: {
-                userId: dto.userId,
-                targetId: dto.branchId,
-                permissionType: _usercompanypermissionentity.PermissionType.BRANCH
-            }
-        });
-        if (existing) {
-            throw new _common.BadRequestException('User already assigned to this branch');
-        }
-        const permission = repository.create({
-            userId: dto.userId,
-            permissionType: _usercompanypermissionentity.PermissionType.BRANCH,
-            targetId: dto.branchId,
-            metadata: dto.metadata
-        });
-        await repository.save(permission);
-    }
-    /** Revoke user access to a branch */ async revokeBranchAccess(userId, branchId) {
+    /** Revoke permission from user */ async revokePermission(userId, targetId, type) {
         const repository = await this.getRepository();
+        const typeName = type === _usercompanypermissionentity.PermissionType.COMPANY ? 'company' : 'branch';
         const permission = await repository.findOne({
             where: {
                 userId,
-                targetId: branchId,
-                permissionType: _usercompanypermissionentity.PermissionType.BRANCH
+                targetId,
+                permissionType: type
             }
         });
         if (!permission) {
-            throw new _common.NotFoundException('Branch permission not found');
+            throw new _common.NotFoundException(`${typeName.charAt(0).toUpperCase() + typeName.slice(1)} permission not found`);
         }
         await repository.remove(permission);
     }
-    // NOTE: @Inject() required for bundled code - type metadata may be lost during esbuild
+    /** Find user branch permissions with optional company filter */ async findUserBranches(userId, companyId) {
+        const repository = await this.getRepository();
+        const queryBuilder = repository.createQueryBuilder('permission').leftJoinAndSelect('permission.branch', 'branch').where('permission.userId = :userId', {
+            userId
+        }).andWhere('permission.permissionType = :type', {
+            type: _usercompanypermissionentity.PermissionType.BRANCH
+        }).orderBy('permission.createdAt', 'DESC');
+        if (companyId) {
+            queryBuilder.andWhere('branch.companyId = :companyId', {
+                companyId
+            });
+        }
+        return queryBuilder.getMany();
+    }
     constructor(dataSourceProvider){
         _define_property(this, "dataSourceProvider", void 0);
-        _define_property(this, "logger", void 0);
         _define_property(this, "_repository", void 0);
+        // Convenience Methods
+        _define_property(this, "findUserCompanies", void 0);
         this.dataSourceProvider = dataSourceProvider;
-        this.logger = new _common.Logger(UserPermissionService.name);
         this._repository = null;
+        this.findUserCompanies = (userId)=>this.findUserPermissions(userId, _usercompanypermissionentity.PermissionType.COMPANY);
     }
 };
 UserPermissionService = _ts_decorate([

package/cjs/services/user.service.js

@@ -110,6 +110,24 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
         }
     }
     // Custom Methods
+    /**
+   * Validate profile ownership, ensure repository initialized, and fetch user.
+   * Throws ForbiddenException if not owner, NotFoundException if user not found.
+   */ async getUserForProfile(userId, user) {
+        if (userId !== user.id) {
+            throw new _common.ForbiddenException('Cannot access another user\'s profile');
+        }
+        await this.ensureRepositoryInitialized();
+        const userEntity = await this.repository.findOne({
+            where: {
+                id: userId
+            }
+        });
+        if (!userEntity) {
+            throw new _common.NotFoundException('User not found');
+        }
+        return userEntity;
+    }
     /** Verify email */ async verifyEmail(id) {
         // Ensure repository is initialized for custom method
         await this.ensureRepositoryInitialized();
@@ -178,26 +196,51 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
         return entity;
     }
     /** Convert entity to response DTO (removes password). In raw mode with company feature, isActive comes from permission table. */ convertEntityToResponseDto(entity, isRaw) {
+        if (isRaw) {
+            return this.convertRawToResponseDto(entity);
+        }
+        return this.convertEntityToDto(entity);
+    }
+    /** Convert raw query result to response DTO */ convertRawToResponseDto(raw) {
         // When raw mode is used with company feature, isActive comes from computed field
-        // Raw mode uses snake_case column names (due to SnakeNamingStrategy)
-        const isActive = isRaw && entity.user_companyIsActive !== undefined ? Boolean(entity.user_companyIsActive) : isRaw ? entity.user_is_active : entity.isActive;
+        const isActive = raw.user_companyIsActive !== undefined ? Boolean(raw.user_companyIsActive) : raw.user_is_active;
         return {
-            id: isRaw ? entity.user_id : entity.id,
-            name: isRaw ? entity.user_name : entity.name,
-            phone: isRaw ? entity.user_phone : entity.phone,
-            email: isRaw ? entity.user_email : entity.email,
-            profilePictureId: isRaw ? entity.user_profile_picture_id : entity.profilePictureId,
+            id: raw.user_id,
+            name: raw.user_name,
+            phone: raw.user_phone,
+            email: raw.user_email,
+            profilePictureId: raw.user_profile_picture_id,
             isActive,
-            emailVerified: isRaw ? entity.user_email_verified : entity.emailVerified,
-            phoneVerified: isRaw ? entity.user_phone_verified : entity.phoneVerified,
-            lastLoginAt: isRaw ? entity.user_last_login_at : entity.lastLoginAt,
-            additionalFields: isRaw ? entity.user_additional_fields : entity.additionalFields,
-            createdAt: isRaw ? entity.user_created_at : entity.createdAt,
-            updatedAt: isRaw ? entity.user_updated_at : entity.updatedAt,
-            deletedAt: isRaw ? entity.user_deleted_at : entity.deletedAt,
-            createdById: isRaw ? entity.user_created_by_id : entity.createdById,
-            updatedById: isRaw ? entity.user_updated_by_id : entity.updatedById,
-            deletedById: isRaw ? entity.user_deleted_by_id : entity.deletedById
+            emailVerified: raw.user_email_verified,
+            phoneVerified: raw.user_phone_verified,
+            lastLoginAt: raw.user_last_login_at,
+            additionalFields: raw.user_additional_fields,
+            createdAt: raw.user_created_at,
+            updatedAt: raw.user_updated_at,
+            deletedAt: raw.user_deleted_at,
+            createdById: raw.user_created_by_id,
+            updatedById: raw.user_updated_by_id,
+            deletedById: raw.user_deleted_by_id
+        };
+    }
+    /** Convert entity to response DTO */ convertEntityToDto(entity) {
+        return {
+            id: entity.id,
+            name: entity.name,
+            phone: entity.phone,
+            email: entity.email,
+            profilePictureId: entity.profilePictureId,
+            isActive: entity.isActive,
+            emailVerified: entity.emailVerified,
+            phoneVerified: entity.phoneVerified,
+            lastLoginAt: entity.lastLoginAt,
+            additionalFields: entity.additionalFields,
+            createdAt: entity.createdAt,
+            updatedAt: entity.updatedAt,
+            deletedAt: entity.deletedAt,
+            createdById: entity.createdById,
+            updatedById: entity.updatedById,
+            deletedById: entity.deletedById
         };
     }
     /** Convert entity list to response DTO list */ convertEntityListToResponseListDto(entities, isRaw) {
@@ -342,15 +385,7 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
    * Get user profile with extras from enricher
    * Returns base user data plus any extra data provided by enricher (roles, permissions, etc.)
    */ async getProfileWithExtras(userId, user) {
-        await this.ensureRepositoryInitialized();
-        const userEntity = await this.repository.findOne({
-            where: {
-                id: userId
-            }
-        });
-        if (!userEntity) {
-            throw new _common.NotFoundException('User not found');
-        }
+        const userEntity = await this.getUserForProfile(userId, user);
         const userData = this.convertEntityToResponseDto(userEntity, false);
         // Get extras from enricher if available
         let extras;
@@ -385,16 +420,7 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
     /**
    * Get specific profile section data
    */ async getProfileSectionData(userId, sectionId, user) {
-        await this.ensureRepositoryInitialized();
-        // Verify user exists
-        const userEntity = await this.repository.findOne({
-            where: {
-                id: userId
-            }
-        });
-        if (!userEntity) {
-            throw new _common.NotFoundException('User not found');
-        }
+        await this.getUserForProfile(userId, user);
         if (this.userEnricher?.getProfileSectionData) {
             return this.userEnricher.getProfileSectionData(userId, sectionId, user);
         }
@@ -403,19 +429,10 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
     /**
    * Update specific profile section
    */ async updateProfileSection(userId, sectionId, data, user) {
-        await this.ensureRepositoryInitialized();
+        const userEntity = await this.getUserForProfile(userId, user);
         if (!this.dataSource) {
             throw new _common.BadRequestException('DataSource not available');
         }
-        // Verify user exists
-        const userEntity = await this.repository.findOne({
-            where: {
-                id: userId
-            }
-        });
-        if (!userEntity) {
-            throw new _common.NotFoundException('User not found');
-        }
         if (!this.userEnricher?.updateProfileSection) {
             throw new _common.BadRequestException('Profile sections not supported');
         }
@@ -442,16 +459,7 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
     /**
    * Get profile completion percentage
    */ async getProfileCompletion(userId, user) {
-        await this.ensureRepositoryInitialized();
-        // Verify user exists
-        const userEntity = await this.repository.findOne({
-            where: {
-                id: userId
-            }
-        });
-        if (!userEntity) {
-            throw new _common.NotFoundException('User not found');
-        }
+        await this.getUserForProfile(userId, user);
         if (this.userEnricher?.calculateProfileCompletion) {
             return this.userEnricher.calculateProfileCompletion(userId, user);
         }
@@ -482,16 +490,22 @@ let UserService = class UserService extends _classes.RequestScopedApiService {
             }
             // Handle password update
             if (dto.password) {
-                // If updating own profile, require old password
-                if (!dto.id || dto.id === user.id) {
-                // This would need oldPassword in DTO - for now, skip if not provided
-                // In real implementation, add oldPassword to UpdateUserDto
+                // If updating own profile, require old password verification
+                const isOwnProfile = !dto.id || dto.id === user.id;
+                if (isOwnProfile) {
+                    if (!dto.oldPassword) {
+                        throw new _common.BadRequestException('Current password is required to change your password');
+                    }
+                    const isPasswordValid = await _bcrypt.compare(dto.oldPassword, findUser.password);
+                    if (!isPasswordValid) {
+                        throw new _common.BadRequestException('Current password is incorrect');
+                    }
                 }
-                const salt = await _bcrypt.genSalt();
-                findUser.password = await _bcrypt.hash(dto.password, salt);
+                findUser.password = await _bcrypt.hash(dto.password, _config.BCRYPT_SALT_ROUNDS);
             }
-            // Merge other fields (excluding password and extras)
-            const { password, extras, ...restDto } = dto;
+            // Merge other fields (excluding password, oldPassword, extras, and sensitive flags)
+            // Users cannot self-modify emailVerified, phoneVerified, or isActive via profile update
+            const { password, oldPassword, extras, emailVerified, phoneVerified, isActive, ...restDto } = dto;
             Object.assign(findUser, restDto);
             await queryRunner.manager.save(this.repository.target, findUser);
             // Handle extras update via enricher

package/cjs/strategies/jwt.strategy.js

@@ -12,10 +12,10 @@ const _common = require("@nestjs/common");
 const _core = require("@nestjs/core");
 const _passport = require("@nestjs/passport");
 const _passportjwt = require("passport-jwt");
+const _userentity = require("../entities/user.entity");
 const _authconfigservice = require("../services/auth-config.service");
 const _authdatasourceprovider = require("../services/auth-datasource.provider");
 const _authenticationservice = require("../services/authentication.service");
-const _userentity = require("../entities/user.entity");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -38,71 +38,71 @@ function _ts_decorate(decorators, target, key, desc) {
 function _ts_metadata(k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 }
-/**
- * Type guard to check if payload includes company context
- */ function isTokenPayloadWithCompany(payload) {
+function hasCompanyContext(payload) {
     return 'companyId' in payload && 'branchId' in payload;
 }
 let JwtStrategy = class JwtStrategy extends (0, _passport.PassportStrategy)(_passportjwt.Strategy, 'jwt') {
     async validate(_req, payload) {
-        // Resolve request-scoped services for this request
-        let userRepository = null;
-        let authService = null;
+        const userRepo = await this.resolveUserRepository();
+        await this.checkTokenRevocation(payload);
+        const user = await userRepo.findOne({
+            where: {
+                id: payload.id,
+                isActive: true
+            }
+        });
+        if (!user) {
+            throw new _common.UnauthorizedException('User not found or inactive');
+        }
+        return this.buildUserInfo(payload);
+    }
+    async resolveUserRepository() {
         try {
-            const dataSourceProvider = await this.moduleRef.resolve(_authdatasourceprovider.AuthDataSourceProvider, undefined, {
+            const provider = await this.moduleRef.resolve(_authdatasourceprovider.AuthDataSourceProvider, undefined, {
                 strict: false
             });
-            if (dataSourceProvider) {
-                userRepository = await dataSourceProvider.getRepository(_userentity.User);
+            if (provider) {
+                return provider.getRepository(_userentity.User);
             }
-            // Resolve AuthenticationService for token revocation check
-            authService = await this.moduleRef.resolve(_authenticationservice.AuthenticationService, undefined, {
-                strict: false
-            });
-        } catch (error) {
+        } catch  {
             throw new _common.UnauthorizedException('Unable to access user data');
         }
-        if (!userRepository) {
-            throw new _common.UnauthorizedException('User repository not available');
-        }
-        // Check if token is revoked (logged out)
-        if (authService && payload.iat) {
-            const isRevoked = await authService.isTokenRevoked(payload.id, payload.iat);
-            if (isRevoked) {
+        throw new _common.UnauthorizedException('User repository not available');
+    }
+    async checkTokenRevocation(payload) {
+        if (!payload.iat) return;
+        try {
+            const authService = await this.moduleRef.resolve(_authenticationservice.AuthenticationService, undefined, {
+                strict: false
+            });
+            if (authService && await authService.isTokenRevoked(payload.id, payload.iat)) {
                 throw new _common.UnauthorizedException('Token has been revoked');
             }
+        } catch (err) {
+            if (err instanceof _common.UnauthorizedException) throw err;
         }
-        // Find user and check if active
-        const user = await userRepository.findOne({
-            where: {
-                id: payload.id,
-                isActive: true
-            }
-        });
-        if (!user) {
-            throw new _common.UnauthorizedException('User not found or inactive');
-        }
-        const result = {
+    }
+    buildUserInfo(payload) {
+        const base = {
             id: payload.id,
             email: payload.email
         };
-        // Company context - use type guard for type safety
-        if (isTokenPayloadWithCompany(payload)) {
-            result.companyId = payload.companyId;
-            // Only set branchId if it's not empty string
-            if (payload.branchId) {
-                result.branchId = payload.branchId;
-            }
+        if (!hasCompanyContext(payload)) {
+            return base;
         }
-        return result;
+        return {
+            ...base,
+            companyId: payload.companyId,
+            ...payload.branchId && {
+                branchId: payload.branchId
+            }
+        };
     }
     constructor(authConfig, moduleRef){
         super({
             jwtFromRequest: _passportjwt.ExtractJwt.fromAuthHeaderAsBearerToken(),
             ignoreExpiration: false,
-            // Use secretOrKeyProvider instead of secretOrKey to defer secret lookup
-            // This ensures AuthConfigService is fully initialized when using forRootAsync
-            secretOrKeyProvider: (_request, _rawJwtToken, done)=>{
+            secretOrKeyProvider: (_req, _token, done)=>{
                 done(null, this.authConfig.getJwtSecret());
             },
             passReqToCallback: true

package/cjs/validators/password.validator.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "IsStrongPassword", {
+    enumerable: true,
+    get: function() {
+        return IsStrongPassword;
+    }
+});
+const _classvalidator = require("class-validator");
+function IsStrongPassword(options = {}, validationOptions) {
+    const { minLength = 8, maxLength = 128, requireUppercase = true, requireLowercase = true, requireNumber = true, requireSpecialChar = true } = options;
+    return function(object, propertyName) {
+        (0, _classvalidator.registerDecorator)({
+            name: 'isStrongPassword',
+            target: object.constructor,
+            propertyName: propertyName,
+            options: validationOptions,
+            validator: {
+                validate (value) {
+                    if (typeof value !== 'string') return false;
+                    const checks = [
+                        value.length >= minLength,
+                        value.length <= maxLength,
+                        !requireUppercase || /[A-Z]/.test(value),
+                        !requireLowercase || /[a-z]/.test(value),
+                        !requireNumber || /[0-9]/.test(value),
+                        !requireSpecialChar || /[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?~`]/.test(value)
+                    ];
+                    return checks.every(Boolean);
+                },
+                defaultMessage (args) {
+                    const requirements = [];
+                    if (minLength > 0) requirements.push(`at least ${minLength} characters`);
+                    if (requireUppercase) requirements.push('one uppercase letter');
+                    if (requireLowercase) requirements.push('one lowercase letter');
+                    if (requireNumber) requirements.push('one number');
+                    if (requireSpecialChar) requirements.push('one special character (!@#$%^&*...)');
+                    return `Password must contain ${requirements.join(', ')}`;
+                }
+            }
+        });
+    };
+}

package/config/auth.constants.d.ts

@@ -1,5 +1,7 @@
 export declare const AUTH_MODULE_OPTIONS = "AUTH_MODULE_OPTIONS";
 export declare const USER_ENRICHER = "USER_ENRICHER";
 export declare const BCRYPT_SALT_ROUNDS = 12;
+export declare const DEFAULT_COOKIE_NAME = "fsn_refresh_token";
+export declare const MAX_COOKIE_BYTES = 3500;
 export declare const SESSION_CACHE_PREFIX = "auth:session";
 export declare const TOKEN_REVOKED_PREFIX = "auth:revoked";

package/controllers/authentication.controller.d.ts

@@ -1,7 +1,7 @@
+import { MessageResponseDto } from '@flusys/nestjs-shared/dtos';
 import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
 import { Request } from 'express';
-import { ChangePasswordDto, CompanySelectionResponseDto, ForgotPasswordDto, LoginDto, LoginResponseDto, MeResponseDto, RefreshTokenDto, RegistrationDto, RegistrationResponseDto, ResendVerificationDto, ResetPasswordDto, VerifyEmailDto } from '../dtos/authentication.dto';
-import { MessageResponseDto } from '@flusys/nestjs-shared/dtos';
+import { ChangePasswordDto, CompanySelectionResponseDto, ForgotPasswordDto, LoginDto, LoginResponseDto, LoginResponseRequiresEmailVerificationDto, MeResponseDto, RefreshTokenDto, RegistrationDto, RegistrationResponseDto, ResendVerificationDto, ResetPasswordDto, VerifyEmailDto } from '../dtos/authentication.dto';
 import { AuthConfigService } from '../services/auth-config.service';
 import { AuthEmailService } from '../services/auth-email.service';
 import { AuthenticationService } from '../services/authentication.service';
@@ -11,7 +11,9 @@ export declare class AuthenticationController {
     private readonly authEmailService?;
     constructor(authService: AuthenticationService, authConfig?: AuthConfigService, authEmailService?: AuthEmailService);
     private buildAuthUrl;
-    login(loginDto: LoginDto): Promise<LoginResponseDto | CompanySelectionResponseDto>;
+    private get emailService();
+    private get isEmailEnabled();
+    login(loginDto: LoginDto): Promise<LoginResponseDto | CompanySelectionResponseDto | LoginResponseRequiresEmailVerificationDto>;
     register(req: Request, registrationDto: RegistrationDto): Promise<RegistrationResponseDto>;
     refreshToken(req: Request, refreshTokenDto: RefreshTokenDto): Promise<{
         accessToken: string;

package/controllers/company-selection.controller.d.ts

@@ -6,9 +6,13 @@ export declare class CompanySelectionController {
     select(dto: SelectDto): Promise<LoginResponseDto>;
     switchCompany(userId: string, dto: SwitchCompanyDto): Promise<LoginResponseDto>;
     getUserCompanies(userId: string): Promise<{
-        companies: import("..").Company[];
+        success: boolean;
+        message: string;
+        data: import("..").Company[];
     }>;
     getUserBranches(userId: string, companyId: string): Promise<{
-        branches: import("..").CompanyBranch[];
+        success: boolean;
+        message: string;
+        data: import("..").CompanyBranch[];
     }>;
 }

package/controllers/user-permission.controller.d.ts

@@ -1,8 +1,8 @@
-import { AssignUserCompanyDto, AssignUserBranchDto, UserCompaniesResponseDto, UserBranchesResponseDto } from '../dtos/user-permission.dto';
+import { AssignUserBranchDto, AssignUserCompanyDto, UserBranchesResponseDto, UserCompaniesResponseDto } from '../dtos/user-permission.dto';
 import { UserPermissionService } from '../services/user-permission.service';
 export declare class UserPermissionController {
-    private readonly userPermissionService;
-    constructor(userPermissionService: UserPermissionService);
+    private readonly permissionService;
+    constructor(permissionService: UserPermissionService);
     assignUserCompany(dto: AssignUserCompanyDto): Promise<{
         success: boolean;
         message: string;
@@ -12,5 +12,6 @@ export declare class UserPermissionController {
         success: boolean;
         message: string;
     }>;
-    getUserBranches(userId: string): Promise<UserBranchesResponseDto>;
+    getUserBranches(userId: string, companyId?: string): Promise<UserBranchesResponseDto>;
+    private processBatchPermissions;
 }