@flusys/nestjs-auth 1.1.0-beta → 1.1.0

package/controllers/index.d.ts

@@ -1,5 +1,6 @@
 export * from './authentication.controller';
 export * from './company-selection.controller';
+export * from './email-verification.controller';
 export * from './user.controller';
 export * from './company.controller';
 export * from './branch.controller';

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;
 }

package/controllers/user.controller.d.ts

@@ -23,12 +23,15 @@ export declare class UserController extends UserController_base {
         };
     }>;
     verifyEmail(id: string): Promise<{
+        success: boolean;
         message: string;
     }>;
     verifyPhone(id: string): Promise<{
+        success: boolean;
         message: string;
     }>;
     updateStatus(id: string, isActive: boolean, user: ILoggedUserInfo): Promise<{
+        success: boolean;
         message: string;
     }>;
     profile(dto: UpdateUserDto, user: ILoggedUserInfo): Promise<{
@@ -38,10 +41,12 @@ export declare class UserController extends UserController_base {
     }>;
     getProfileSections(): Promise<{
         success: boolean;
+        message: string;
         data: import("..").IProfileSection[];
     }>;
     getProfileSectionData(id: string, sectionId: string, user: ILoggedUserInfo): Promise<{
         success: boolean;
+        message: string;
         data: import("..").IProfileSectionData;
     }>;
     updateProfileSection(id: string, sectionId: string, data: Record<string, any>, user: ILoggedUserInfo): Promise<{
@@ -50,6 +55,7 @@ export declare class UserController extends UserController_base {
     }>;
     getProfileCompletion(id: string, user: ILoggedUserInfo): Promise<{
         success: boolean;
+        message: string;
         data: {
             completionPercentage: number;
         };

package/dtos/authentication.dto.d.ts

@@ -51,14 +51,12 @@ export declare class BranchSelectionInfoDto {
     id: string;
     name: string;
     slug: string;
-    isActive: boolean;
     logoId?: string | null;
 }
 export declare class CompanyWithBranchesDto {
     id: string;
     name: string;
     slug: string;
-    isActive: boolean;
     logoId?: string | null;
     branches: BranchSelectionInfoDto[];
 }
@@ -68,7 +66,6 @@ export declare class LoginResponseDto {
     user: UserInfoDto;
     company?: CompanyInfoDto;
     branch?: BranchInfoDto;
-    companyFeatureEnabled?: boolean;
 }
 export declare class RegistrationResponseDto {
     accessToken?: string;
@@ -76,7 +73,6 @@ export declare class RegistrationResponseDto {
     user: UserInfoDto;
     company?: CompanyInfoDto;
     branch?: BranchInfoDto;
-    companyFeatureEnabled?: boolean;
     requiresEmailVerification?: boolean;
 }
 export declare class MeResponseDto {

package/dtos/company-branch.dto.d.ts

@@ -1,5 +1,4 @@
 export declare class CreateCompanyBranchDto {
-    [key: string]: unknown;
     name: string;
     slug: string;
     companyId: string;

package/dtos/company.dto.d.ts

@@ -1,5 +1,4 @@
 export declare class CreateCompanyDto {
-    [key: string]: unknown;
     name: string;
     slug: string;
     logoId?: string;

package/dtos/index.d.ts

@@ -1,6 +1,5 @@
 export * from './authentication.dto';
 export * from './company-branch.dto';
 export * from './company.dto';
-export * from './user-company-permission.dto';
 export * from './user.dto';
 export * from './user-permission.dto';

package/dtos/user-permission.dto.d.ts

@@ -26,8 +26,12 @@ export declare class UserBranchPermissionDto {
     companyId: string;
 }
 export declare class UserCompaniesResponseDto {
+    success: boolean;
+    message: string;
     data: UserCompanyPermissionDto[];
 }
 export declare class UserBranchesResponseDto {
+    success: boolean;
+    message: string;
     data: UserBranchPermissionDto[];
 }

package/dtos/user.dto.d.ts

@@ -1,5 +1,4 @@
 export declare class CreateUserDto {
-    [key: string]: unknown;
     name: string;
     phone?: string;
     email: string;
@@ -11,12 +10,12 @@ export declare class CreateUserDto {
     additionalFields?: Record<string, any>;
 }
 export declare class UpdateUserDto {
-    [key: string]: unknown;
     id: string;
     name?: string;
     phone?: string;
     email?: string;
     password?: string;
+    oldPassword?: string;
     profilePictureId?: string;
     isActive?: boolean;
     emailVerified?: boolean;
@@ -24,7 +23,6 @@ export declare class UpdateUserDto {
     additionalFields?: Record<string, any>;
 }
 export declare class UserResponseDto {
-    [key: string]: unknown;
     id: string;
     name: string;
     phone?: string | null;

package/entities/index.d.ts

@@ -4,13 +4,8 @@ export * from './pending-registration.entity';
 export { PermissionType, UserCompanyPermission } from './user-company-permission.entity';
 export * from './user.entity';
 export * from './user-token.entity';
-import { CompanyBranch } from './company-branch.entity';
-import { Company } from './company.entity';
-import { PendingRegistration } from './pending-registration.entity';
-import { UserCompanyPermission } from './user-company-permission.entity';
-import { User } from './user.entity';
-import { UserToken } from './user-token.entity';
-export declare const CoreEntities: (typeof PendingRegistration | typeof User | typeof UserToken)[];
-export declare const CompanyEntities: (typeof Company | typeof CompanyBranch | typeof UserCompanyPermission)[];
-export declare const AllEntities: (typeof Company | typeof CompanyBranch | typeof PendingRegistration | typeof User | typeof UserCompanyPermission | typeof UserToken)[];
-export declare function getEntitiesByConfig(enableCompanyFeature: boolean): (typeof Company | typeof CompanyBranch | typeof PendingRegistration | typeof User | typeof UserCompanyPermission | typeof UserToken)[];
+export interface IAuthEntitiesConfig {
+    enableCompanyFeature?: boolean;
+    enableEmailVerification?: boolean;
+}
+export declare function getEntitiesByConfig(config: IAuthEntitiesConfig): any[];

package/entities/user-company-permission.entity.d.ts

@@ -7,7 +7,7 @@ export declare class UserCompanyPermission {
     id: string;
     userId: string;
     user?: User;
-    permissionType: PermissionType;
+    permissionType: string;
     targetId: string;
     metadata?: Record<string, any>;
     isActive: boolean;
@@ -15,6 +15,4 @@ export declare class UserCompanyPermission {
     branch?: CompanyBranch;
     createdAt: Date;
     updatedAt: Date;
-    isCompanyPermission(): boolean;
-    isBranchPermission(): boolean;
 }

package/fesm/config/auth.constants.js

@@ -1,18 +1,11 @@
 // Injection Tokens
 export const AUTH_MODULE_OPTIONS = 'AUTH_MODULE_OPTIONS';
-/**
- * User Enricher Provider Token
- *
- * Optional provider for extending user list and profile.
- * Consuming apps can provide their own implementation.
- *
- * @example
- * providers: [
- *   { provide: USER_ENRICHER, useClass: MyUserEnricher },
- * ]
- */ export const USER_ENRICHER = 'USER_ENRICHER';
-// Security Configuration
-/** Bcrypt salt rounds (12 = ~250ms hashing time) */ export const BCRYPT_SALT_ROUNDS = 12;
+export const USER_ENRICHER = 'USER_ENRICHER';
+// Security
+export const BCRYPT_SALT_ROUNDS = 12;
+// Cookie
+export const DEFAULT_COOKIE_NAME = 'fsn_refresh_token';
+export const MAX_COOKIE_BYTES = 3500;
 // Cache Key Prefixes
 export const SESSION_CACHE_PREFIX = 'auth:session';
 export const TOKEN_REVOKED_PREFIX = 'auth:revoked';

package/fesm/controllers/authentication.controller.js

@@ -26,26 +26,29 @@ function _ts_param(paramIndex, decorator) {
     };
 }
 import { CurrentUser } from '@flusys/nestjs-shared/decorators';
+import { MessageResponseDto } from '@flusys/nestjs-shared/dtos';
 import { JwtAuthGuard } from '@flusys/nestjs-shared/guards';
 import { ILoggedUserInfo } from '@flusys/nestjs-shared/interfaces';
-import { Body, Controller, Get, HttpCode, HttpStatus, Inject, Optional, Post, Req, UnauthorizedException, UseGuards, UseInterceptors } from '@nestjs/common';
-import { ApiBearerAuth, ApiBody, ApiOperation, ApiResponse, ApiTags } from '@nestjs/swagger';
+import { Body, Controller, HttpCode, HttpStatus, Inject, Optional, Post, Req, UnauthorizedException, UseGuards, UseInterceptors } from '@nestjs/common';
+import { ApiBearerAuth, ApiBody, ApiExtraModels, ApiHeader, ApiOperation, ApiResponse, ApiTags, getSchemaPath } from '@nestjs/swagger';
+import { SkipThrottle, Throttle } from '@nestjs/throttler';
 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 { DEFAULT_COOKIE_NAME } from '../config';
+import { ChangePasswordDto, CompanySelectionResponseDto, LoginDto, LoginResponseDto, LoginResponseRequiresEmailVerificationDto, MeResponseDto, RefreshTokenDto, RegistrationDto, RegistrationResponseDto } from '../dtos/authentication.dto';
 import { ClearToken } from '../interceptors/clear-token.interceptor';
 import { SetToken } from '../interceptors/set-token.interceptor';
 import { AuthConfigService } from '../services/auth-config.service';
-import { AuthEmailService } from '../services/auth-email.service';
 import { AuthenticationService } from '../services/authentication.service';
 export class AuthenticationController {
-    /** Build auth URL for email links */ buildAuthUrl(req, path) {
+    buildAuthUrl(req, path) {
         const frontendUrl = this.authConfig?.getFrontendUrl();
         return frontendUrl ? `${frontendUrl}${path}` : `${req.protocol}://${req.get('host')}${path}`;
     }
-    // Core Endpoints
-    /** Login - Returns tokens or company/branch selection requirement */ async login(loginDto) {
+    async login(loginDto) {
         const result = await this.authService.login(loginDto.email, loginDto.password);
+        if ('requiresEmailVerification' in result) {
+            return result;
+        }
         if ('requiresSelection' in result) {
             return result;
         }
@@ -54,14 +57,15 @@ export class AuthenticationController {
     /** Register new user. If company feature enabled, can join/create company. */ async register(req, registrationDto) {
         const verifyUrlBase = this.buildAuthUrl(req, '/auth/verify-email');
         const result = await this.authService.register(registrationDto, verifyUrlBase);
-        return {
-            ...result,
-            companyFeatureEnabled: this.authConfig?.isCompanyFeatureEnabled() ?? false
-        };
+        return result;
     }
-    /** Refresh access token. Browser uses HTTP-only cookie, API/Mobile uses request body. */ async refreshToken(req, refreshTokenDto) {
-        // Get refresh token from cookie (browser) or body (API/mobile)
-        const cookieName = this.authConfig?.getRefreshTokenCookieName() ?? 'fsn_refresh_token';
+    /**
+   * Refresh access token.
+   * - **Browser**: Prefers HTTP-only cookie, falls back to body if cookie missing.
+   * - **API/Mobile**: Must send `refreshToken` in request body. Set header `x-client-type: mobile` or `x-client-type: api`.
+   */ async refreshToken(req, refreshTokenDto) {
+        const cookieName = this.authConfig?.getRefreshTokenCookieName() ?? DEFAULT_COOKIE_NAME;
+        // Always check cookie first, then body - handles Browser, SSR, and Mobile/API
         const refreshToken = req.cookies?.[cookieName] || refreshTokenDto.refreshToken;
         if (!refreshToken) {
             throw new UnauthorizedException('Refresh token is required');
@@ -78,75 +82,29 @@ export class AuthenticationController {
             message: 'Logged out successfully'
         };
     }
-    /** Change password */ async changePassword(userId, dto) {
+    async changePassword(userId, dto) {
         await this.authService.changePassword(userId, dto.currentPassword, dto.newPassword);
         return {
             success: true,
             message: 'Password changed successfully'
         };
     }
-    // Email Auth Endpoints
-    /** Forgot password - Request password reset email */ async forgotPassword(req, dto) {
-        if (!this.authEmailService) {
-            return {
-                success: false,
-                message: 'Email service is not configured'
-            };
-        }
-        return this.authEmailService.forgotPassword(dto.email, this.buildAuthUrl(req, '/auth/reset-password'));
-    }
-    /** Reset password - Reset password using token */ async resetPassword(dto) {
-        if (!this.authEmailService) {
-            return {
-                success: false,
-                message: 'Email service is not configured'
-            };
-        }
-        return this.authEmailService.resetPassword(dto.token, dto.newPassword);
-    }
-    /** Resend verification email - For unauthenticated users (handles both pending registration and existing users) */ async resendVerification(req, dto) {
-        if (!this.authEmailService) {
-            return {
-                success: false,
-                message: 'Email service is not configured'
-            };
-        }
-        return this.authEmailService.resendVerificationEmail(dto.email, this.buildAuthUrl(req, '/auth/verify-email'));
-    }
-    /** Verify email - Verify email using token. Handles both pending registration and existing user verification. */ async verifyEmail(dto) {
-        if (!this.authEmailService) {
-            return {
-                success: false,
-                message: 'Email service is not configured'
-            };
-        }
-        const result = await this.authEmailService.verifyEmail(dto.token);
-        if (result.type === 'pending') {
-            // Create user from pending registration
-            const registrationResult = await this.authService.createUserFromPendingRegistration(result.pending);
-            return {
-                ...registrationResult,
-                companyFeatureEnabled: this.authConfig?.isCompanyFeatureEnabled() ?? false
-            };
-        }
-        return {
-            success: true,
-            message: result.message
-        };
-    }
-    // NOTE: @Inject() required for bundled code - type metadata may be lost during esbuild
-    constructor(authService, authConfig, authEmailService){
+    constructor(authService, authConfig){
         _define_property(this, "authService", void 0);
         _define_property(this, "authConfig", void 0);
-        _define_property(this, "authEmailService", void 0);
         this.authService = authService;
         this.authConfig = authConfig;
-        this.authEmailService = authEmailService;
     }
 }
 _ts_decorate([
     Post('login'),
     HttpCode(HttpStatus.OK),
+    Throttle({
+        default: {
+            limit: 5,
+            ttl: 60000
+        }
+    }),
     UseInterceptors(SetToken),
     ApiOperation({
         summary: 'User login'
@@ -154,13 +112,102 @@ _ts_decorate([
     ApiBody({
         type: LoginDto
     }),
+    ApiExtraModels(LoginResponseDto, CompanySelectionResponseDto, LoginResponseRequiresEmailVerificationDto),
     ApiResponse({
         status: 200,
-        type: LoginResponseDto
-    }),
-    ApiResponse({
-        status: 200,
-        type: CompanySelectionResponseDto
+        description: 'Login successful, requires company selection, or requires email verification',
+        content: {
+            'application/json': {
+                schema: {
+                    oneOf: [
+                        {
+                            $ref: getSchemaPath(LoginResponseDto)
+                        },
+                        {
+                            $ref: getSchemaPath(CompanySelectionResponseDto)
+                        },
+                        {
+                            $ref: getSchemaPath(LoginResponseRequiresEmailVerificationDto)
+                        }
+                    ]
+                },
+                examples: {
+                    loginSuccess: {
+                        summary: 'Login Success',
+                        description: 'Successful login with tokens (company/branch included when company feature enabled)',
+                        value: {
+                            accessToken: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',
+                            refreshToken: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',
+                            user: {
+                                id: '550e8400-e29b-41d4-a716-446655440000',
+                                email: 'john@example.com',
+                                name: 'John Doe'
+                            }
+                        }
+                    },
+                    loginSuccessWithCompany: {
+                        summary: 'Login Success (Company Feature)',
+                        description: 'Login with company/branch - only when company feature is enabled',
+                        value: {
+                            accessToken: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',
+                            refreshToken: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',
+                            user: {
+                                id: '550e8400-e29b-41d4-a716-446655440000',
+                                email: 'john@example.com',
+                                name: 'John Doe'
+                            },
+                            company: {
+                                id: '550e8400-e29b-41d4-a716-446655440001',
+                                name: 'Acme Corporation',
+                                slug: 'acme-corp'
+                            },
+                            branch: {
+                                id: '550e8400-e29b-41d4-a716-446655440002',
+                                name: 'Main Branch',
+                                slug: 'main-branch'
+                            }
+                        }
+                    },
+                    companySelection: {
+                        summary: 'Company Selection Required (Company Feature)',
+                        description: 'User has multiple companies/branches - only when company feature is enabled',
+                        value: {
+                            requiresSelection: true,
+                            sessionId: 'sess_abc123def456',
+                            expiresAt: '2024-12-18T15:30:00.000Z',
+                            user: {
+                                id: '550e8400-e29b-41d4-a716-446655440000',
+                                email: 'john@example.com',
+                                name: 'John Doe'
+                            },
+                            companies: [
+                                {
+                                    id: '550e8400-e29b-41d4-a716-446655440001',
+                                    name: 'Company A',
+                                    slug: 'company-a',
+                                    branches: [
+                                        {
+                                            id: '550e8400-e29b-41d4-a716-446655440010',
+                                            name: 'Branch 1',
+                                            slug: 'branch-1'
+                                        }
+                                    ]
+                                }
+                            ]
+                        }
+                    },
+                    emailVerification: {
+                        summary: 'Email Verification Required',
+                        description: 'User must verify email before logging in',
+                        value: {
+                            requiresEmailVerification: true,
+                            email: 'john@example.com',
+                            message: 'Please verify your email address before logging in.'
+                        }
+                    }
+                }
+            }
+        }
     }),
     _ts_param(0, Body()),
     _ts_metadata("design:type", Function),
@@ -172,6 +219,12 @@ _ts_decorate([
 _ts_decorate([
     Post('register'),
     HttpCode(HttpStatus.CREATED),
+    Throttle({
+        default: {
+            limit: 3,
+            ttl: 60000
+        }
+    }),
     UseInterceptors(SetToken),
     ApiOperation({
         summary: 'Register new user'
@@ -195,11 +248,50 @@ _ts_decorate([
 _ts_decorate([
     Post('refresh'),
     HttpCode(HttpStatus.OK),
+    Throttle({
+        default: {
+            limit: 30,
+            ttl: 60000
+        }
+    }),
     ApiOperation({
-        summary: 'Refresh access token'
+        summary: 'Refresh access token',
+        description: `
+**Browser clients**: Refresh token is read from HTTP-only cookie (automatically set on login/register).
+Falls back to request body if cookie is not available.
+
+**API/Mobile clients**: Must send \`refreshToken\` in request body.
+Set header \`x-client-type: mobile\` or \`x-client-type: api\` to identify as non-browser client.
+
+**Client detection**: Uses \`x-client-type\` header first, then falls back to User-Agent detection.
+    `
+    }),
+    ApiHeader({
+        name: 'x-client-type',
+        required: false,
+        description: 'Client type: "browser"/"web" for cookie-based auth, "mobile"/"api" for body-based auth',
+        example: 'mobile'
     }),
     ApiBody({
-        type: RefreshTokenDto
+        type: RefreshTokenDto,
+        description: 'Required for API/Mobile clients. Browser clients prefer HTTP-only cookie with body fallback.'
+    }),
+    ApiResponse({
+        status: 200,
+        description: 'New access token',
+        schema: {
+            type: 'object',
+            properties: {
+                accessToken: {
+                    type: 'string',
+                    example: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...'
+                }
+            }
+        }
+    }),
+    ApiResponse({
+        status: 401,
+        description: 'Invalid or missing refresh token'
     }),
     _ts_param(0, Req()),
     _ts_param(1, Body()),
@@ -212,7 +304,8 @@ _ts_decorate([
 ], AuthenticationController.prototype, "refreshToken", null);
 _ts_decorate([
     UseGuards(JwtAuthGuard),
-    Get('me'),
+    Post('me'),
+    SkipThrottle(),
     ApiBearerAuth(),
     ApiOperation({
         summary: 'Get current user info'
@@ -232,6 +325,7 @@ _ts_decorate([
     UseGuards(JwtAuthGuard),
     Post('logout'),
     HttpCode(HttpStatus.OK),
+    SkipThrottle(),
     UseInterceptors(ClearToken),
     ApiBearerAuth(),
     ApiOperation({
@@ -252,6 +346,12 @@ _ts_decorate([
     UseGuards(JwtAuthGuard),
     Post('change-password'),
     HttpCode(HttpStatus.OK),
+    Throttle({
+        default: {
+            limit: 5,
+            ttl: 60000
+        }
+    }),
     ApiBearerAuth(),
     ApiOperation({
         summary: 'Change password'
@@ -272,107 +372,15 @@ _ts_decorate([
     ]),
     _ts_metadata("design:returntype", Promise)
 ], AuthenticationController.prototype, "changePassword", null);
-_ts_decorate([
-    Post('forgot-password'),
-    HttpCode(HttpStatus.OK),
-    ApiOperation({
-        summary: 'Request password reset email'
-    }),
-    ApiBody({
-        type: ForgotPasswordDto
-    }),
-    ApiResponse({
-        status: 200,
-        type: MessageResponseDto
-    }),
-    _ts_param(0, Req()),
-    _ts_param(1, Body()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Request === "undefined" ? Object : Request,
-        typeof ForgotPasswordDto === "undefined" ? Object : ForgotPasswordDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], AuthenticationController.prototype, "forgotPassword", null);
-_ts_decorate([
-    Post('reset-password'),
-    HttpCode(HttpStatus.OK),
-    ApiOperation({
-        summary: 'Reset password using token'
-    }),
-    ApiBody({
-        type: ResetPasswordDto
-    }),
-    ApiResponse({
-        status: 200,
-        type: MessageResponseDto
-    }),
-    _ts_param(0, Body()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof ResetPasswordDto === "undefined" ? Object : ResetPasswordDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], AuthenticationController.prototype, "resetPassword", null);
-_ts_decorate([
-    Post('resend-verification'),
-    HttpCode(HttpStatus.OK),
-    ApiOperation({
-        summary: 'Resend email verification link'
-    }),
-    ApiBody({
-        type: ResendVerificationDto
-    }),
-    ApiResponse({
-        status: 200,
-        type: MessageResponseDto
-    }),
-    _ts_param(0, Req()),
-    _ts_param(1, Body()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof Request === "undefined" ? Object : Request,
-        typeof ResendVerificationDto === "undefined" ? Object : ResendVerificationDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], AuthenticationController.prototype, "resendVerification", null);
-_ts_decorate([
-    Post('verify-email'),
-    HttpCode(HttpStatus.OK),
-    UseInterceptors(SetToken),
-    ApiOperation({
-        summary: 'Verify email using token'
-    }),
-    ApiBody({
-        type: VerifyEmailDto
-    }),
-    ApiResponse({
-        status: 200,
-        type: MessageResponseDto
-    }),
-    ApiResponse({
-        status: 200,
-        type: RegistrationResponseDto
-    }),
-    _ts_param(0, Body()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof VerifyEmailDto === "undefined" ? Object : VerifyEmailDto
-    ]),
-    _ts_metadata("design:returntype", Promise)
-], AuthenticationController.prototype, "verifyEmail", null);
 AuthenticationController = _ts_decorate([
     ApiTags('Authentication'),
     Controller('auth'),
     _ts_param(0, Inject(AuthenticationService)),
     _ts_param(1, Optional()),
     _ts_param(1, Inject(AuthConfigService)),
-    _ts_param(2, Optional()),
-    _ts_param(2, Inject(AuthEmailService)),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof AuthenticationService === "undefined" ? Object : AuthenticationService,
-        typeof AuthConfigService === "undefined" ? Object : AuthConfigService,
-        typeof AuthEmailService === "undefined" ? Object : AuthEmailService
+        typeof AuthConfigService === "undefined" ? Object : AuthConfigService
     ])
 ], AuthenticationController);