servcraft 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,828 @@
+import { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify';
+import pino, { Logger } from 'pino';
+export { Logger } from 'pino';
+import { z, ZodTypeAny } from 'zod';
+
+interface LoggerConfig {
+    level: string;
+    pretty: boolean;
+    name?: string;
+}
+declare function createLogger(config?: Partial<LoggerConfig>): Logger;
+declare const logger: pino.Logger;
+
+interface ServerConfig {
+    port: number;
+    host: string;
+    logger?: Logger;
+    trustProxy?: boolean;
+    bodyLimit?: number;
+    requestTimeout?: number;
+}
+declare class Server {
+    private app;
+    private config;
+    private logger;
+    private isShuttingDown;
+    constructor(config?: Partial<ServerConfig>);
+    get instance(): FastifyInstance;
+    private setupHealthCheck;
+    private setupGracefulShutdown;
+    shutdown(exitCode?: number): Promise<void>;
+    start(): Promise<void>;
+}
+declare function createServer(config?: Partial<ServerConfig>): Server;
+
+declare const envSchema: z.ZodObject<{
+    NODE_ENV: z.ZodDefault<z.ZodEnum<["development", "staging", "production", "test"]>>;
+    PORT: z.ZodDefault<z.ZodEffects<z.ZodString, number, string>>;
+    HOST: z.ZodDefault<z.ZodString>;
+    DATABASE_URL: z.ZodOptional<z.ZodString>;
+    JWT_SECRET: z.ZodOptional<z.ZodString>;
+    JWT_ACCESS_EXPIRES_IN: z.ZodDefault<z.ZodString>;
+    JWT_REFRESH_EXPIRES_IN: z.ZodDefault<z.ZodString>;
+    CORS_ORIGIN: z.ZodDefault<z.ZodString>;
+    RATE_LIMIT_MAX: z.ZodDefault<z.ZodEffects<z.ZodString, number, string>>;
+    RATE_LIMIT_WINDOW_MS: z.ZodDefault<z.ZodEffects<z.ZodString, number, string>>;
+    SMTP_HOST: z.ZodOptional<z.ZodString>;
+    SMTP_PORT: z.ZodOptional<z.ZodEffects<z.ZodString, number, string>>;
+    SMTP_USER: z.ZodOptional<z.ZodString>;
+    SMTP_PASS: z.ZodOptional<z.ZodString>;
+    SMTP_FROM: z.ZodOptional<z.ZodString>;
+    REDIS_URL: z.ZodOptional<z.ZodString>;
+    SWAGGER_ENABLED: z.ZodEffects<z.ZodDefault<z.ZodUnion<[z.ZodLiteral<"true">, z.ZodLiteral<"false">]>>, boolean, "true" | "false" | undefined>;
+    SWAGGER_ROUTE: z.ZodDefault<z.ZodString>;
+    SWAGGER_TITLE: z.ZodDefault<z.ZodString>;
+    SWAGGER_DESCRIPTION: z.ZodDefault<z.ZodString>;
+    SWAGGER_VERSION: z.ZodDefault<z.ZodString>;
+    LOG_LEVEL: z.ZodDefault<z.ZodEnum<["fatal", "error", "warn", "info", "debug", "trace"]>>;
+}, "strip", z.ZodTypeAny, {
+    NODE_ENV: "development" | "staging" | "production" | "test";
+    PORT: number;
+    HOST: string;
+    JWT_ACCESS_EXPIRES_IN: string;
+    JWT_REFRESH_EXPIRES_IN: string;
+    CORS_ORIGIN: string;
+    RATE_LIMIT_MAX: number;
+    RATE_LIMIT_WINDOW_MS: number;
+    SWAGGER_ENABLED: boolean;
+    SWAGGER_ROUTE: string;
+    SWAGGER_TITLE: string;
+    SWAGGER_DESCRIPTION: string;
+    SWAGGER_VERSION: string;
+    LOG_LEVEL: "fatal" | "error" | "warn" | "info" | "debug" | "trace";
+    DATABASE_URL?: string | undefined;
+    JWT_SECRET?: string | undefined;
+    SMTP_HOST?: string | undefined;
+    SMTP_PORT?: number | undefined;
+    SMTP_USER?: string | undefined;
+    SMTP_PASS?: string | undefined;
+    SMTP_FROM?: string | undefined;
+    REDIS_URL?: string | undefined;
+}, {
+    NODE_ENV?: "development" | "staging" | "production" | "test" | undefined;
+    PORT?: string | undefined;
+    HOST?: string | undefined;
+    DATABASE_URL?: string | undefined;
+    JWT_SECRET?: string | undefined;
+    JWT_ACCESS_EXPIRES_IN?: string | undefined;
+    JWT_REFRESH_EXPIRES_IN?: string | undefined;
+    CORS_ORIGIN?: string | undefined;
+    RATE_LIMIT_MAX?: string | undefined;
+    RATE_LIMIT_WINDOW_MS?: string | undefined;
+    SMTP_HOST?: string | undefined;
+    SMTP_PORT?: string | undefined;
+    SMTP_USER?: string | undefined;
+    SMTP_PASS?: string | undefined;
+    SMTP_FROM?: string | undefined;
+    REDIS_URL?: string | undefined;
+    SWAGGER_ENABLED?: "true" | "false" | undefined;
+    SWAGGER_ROUTE?: string | undefined;
+    SWAGGER_TITLE?: string | undefined;
+    SWAGGER_DESCRIPTION?: string | undefined;
+    SWAGGER_VERSION?: string | undefined;
+    LOG_LEVEL?: "fatal" | "error" | "warn" | "info" | "debug" | "trace" | undefined;
+}>;
+type Env = z.infer<typeof envSchema>;
+declare const env: {
+    NODE_ENV: "development" | "staging" | "production" | "test";
+    PORT: number;
+    HOST: string;
+    JWT_ACCESS_EXPIRES_IN: string;
+    JWT_REFRESH_EXPIRES_IN: string;
+    CORS_ORIGIN: string;
+    RATE_LIMIT_MAX: number;
+    RATE_LIMIT_WINDOW_MS: number;
+    SWAGGER_ENABLED: boolean;
+    SWAGGER_ROUTE: string;
+    SWAGGER_TITLE: string;
+    SWAGGER_DESCRIPTION: string;
+    SWAGGER_VERSION: string;
+    LOG_LEVEL: "fatal" | "error" | "warn" | "info" | "debug" | "trace";
+    DATABASE_URL?: string | undefined;
+    JWT_SECRET?: string | undefined;
+    SMTP_HOST?: string | undefined;
+    SMTP_PORT?: number | undefined;
+    SMTP_USER?: string | undefined;
+    SMTP_PASS?: string | undefined;
+    SMTP_FROM?: string | undefined;
+    REDIS_URL?: string | undefined;
+};
+declare function isDevelopment(): boolean;
+declare function isProduction(): boolean;
+declare function isTest(): boolean;
+declare function isStaging(): boolean;
+
+interface AppConfig {
+    env: Env;
+    server: {
+        port: number;
+        host: string;
+    };
+    jwt: {
+        secret: string;
+        accessExpiresIn: string;
+        refreshExpiresIn: string;
+    };
+    security: {
+        corsOrigin: string | string[];
+        rateLimit: {
+            max: number;
+            windowMs: number;
+        };
+    };
+    email: {
+        host?: string;
+        port?: number;
+        user?: string;
+        pass?: string;
+        from?: string;
+    };
+    database: {
+        url?: string;
+    };
+    redis: {
+        url?: string;
+    };
+    swagger: {
+        enabled: boolean;
+        route: string;
+        title: string;
+        description: string;
+        version: string;
+    };
+}
+declare function createConfig(): AppConfig;
+declare const config: AppConfig;
+
+declare function registerErrorHandler(app: FastifyInstance): void;
+
+interface SecurityOptions {
+    helmet?: boolean;
+    cors?: boolean;
+    rateLimit?: boolean;
+}
+declare function registerSecurity(app: FastifyInstance, options?: SecurityOptions): Promise<void>;
+declare function registerBruteForceProtection(app: FastifyInstance, routePrefix: string, options?: {
+    max?: number;
+    timeWindow?: number;
+}): Promise<void>;
+
+declare function success<T>(reply: FastifyReply, data: T, statusCode?: number): FastifyReply;
+declare function created<T>(reply: FastifyReply, data: T): FastifyReply;
+declare function noContent(reply: FastifyReply): FastifyReply;
+declare function error(reply: FastifyReply, message: string, statusCode?: number, errors?: Record<string, string[]>): FastifyReply;
+declare function notFound(reply: FastifyReply, message?: string): FastifyReply;
+declare function unauthorized(reply: FastifyReply, message?: string): FastifyReply;
+declare function forbidden(reply: FastifyReply, message?: string): FastifyReply;
+declare function badRequest(reply: FastifyReply, message?: string, errors?: Record<string, string[]>): FastifyReply;
+declare function conflict(reply: FastifyReply, message?: string): FastifyReply;
+declare function internalError(reply: FastifyReply, message?: string): FastifyReply;
+
+interface BaseEntity {
+    id: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface PaginationParams {
+    page: number;
+    limit: number;
+    sortBy?: string;
+    sortOrder?: 'asc' | 'desc';
+}
+interface PaginatedResult<T> {
+    data: T[];
+    meta: {
+        total: number;
+        page: number;
+        limit: number;
+        totalPages: number;
+        hasNextPage: boolean;
+        hasPrevPage: boolean;
+    };
+}
+interface ApiResponse<T = unknown> {
+    success: boolean;
+    data?: T;
+    message?: string;
+    errors?: Record<string, string[]>;
+}
+type ServiceResult<T, E = Error> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: E;
+    message: string;
+};
+interface Repository<T extends BaseEntity> {
+    findById(id: string): Promise<T | null>;
+    findMany(params?: PaginationParams): Promise<PaginatedResult<T>>;
+    create(data: Omit<T, keyof BaseEntity>): Promise<T>;
+    update(id: string, data: Partial<Omit<T, keyof BaseEntity>>): Promise<T | null>;
+    delete(id: string): Promise<boolean>;
+}
+type ControllerHandler = (request: FastifyRequest, reply: FastifyReply) => Promise<void>;
+interface Module {
+    name: string;
+    register(app: FastifyInstance): Promise<void>;
+}
+
+declare const DEFAULT_PAGE = 1;
+declare const DEFAULT_LIMIT = 20;
+declare const MAX_LIMIT = 100;
+declare function parsePaginationParams(query: Record<string, unknown>): PaginationParams;
+declare function createPaginatedResult<T>(data: T[], total: number, params: PaginationParams): PaginatedResult<T>;
+declare function getSkip(params: PaginationParams): number;
+
+declare class AppError extends Error {
+    readonly statusCode: number;
+    readonly isOperational: boolean;
+    readonly errors?: Record<string, string[]>;
+    constructor(message: string, statusCode?: number, isOperational?: boolean, errors?: Record<string, string[]>);
+}
+declare class NotFoundError extends AppError {
+    constructor(resource?: string);
+}
+declare class UnauthorizedError extends AppError {
+    constructor(message?: string);
+}
+declare class ForbiddenError extends AppError {
+    constructor(message?: string);
+}
+declare class BadRequestError extends AppError {
+    constructor(message?: string, errors?: Record<string, string[]>);
+}
+declare class ConflictError extends AppError {
+    constructor(message?: string);
+}
+declare class ValidationError extends AppError {
+    constructor(errors: Record<string, string[]>);
+}
+declare class TooManyRequestsError extends AppError {
+    constructor(message?: string);
+}
+declare function isAppError(error: unknown): error is AppError;
+
+interface JwtPayload {
+    sub: string;
+    email: string;
+    role: string;
+    type: 'access' | 'refresh';
+    iat?: number;
+    exp?: number;
+}
+interface TokenPair {
+    accessToken: string;
+    refreshToken: string;
+    expiresIn: number;
+}
+interface AuthUser {
+    id: string;
+    email: string;
+    role: string;
+}
+interface AuthenticatedRequest extends FastifyRequest {
+    user: AuthUser;
+}
+interface LoginCredentials {
+    email: string;
+    password: string;
+}
+interface RegisterData {
+    email: string;
+    password: string;
+    name?: string;
+}
+interface RefreshTokenData {
+    refreshToken: string;
+}
+interface PasswordResetRequest {
+    email: string;
+}
+interface PasswordResetConfirm {
+    token: string;
+    password: string;
+}
+interface ChangePasswordData {
+    currentPassword: string;
+    newPassword: string;
+}
+declare module 'fastify' {
+    interface FastifyRequest {
+        user: AuthUser;
+    }
+}
+declare module '@fastify/jwt' {
+    interface FastifyJWT {
+        payload: JwtPayload;
+        user: AuthUser;
+    }
+}
+
+declare class AuthService {
+    private app;
+    private readonly SALT_ROUNDS;
+    constructor(app: FastifyInstance);
+    hashPassword(password: string): Promise<string>;
+    verifyPassword(password: string, hash: string): Promise<boolean>;
+    generateTokenPair(user: AuthUser): TokenPair;
+    private parseExpiration;
+    verifyAccessToken(token: string): Promise<JwtPayload>;
+    verifyRefreshToken(token: string): Promise<JwtPayload>;
+    blacklistToken(token: string): void;
+    isTokenBlacklisted(token: string): boolean;
+    cleanupBlacklist(): void;
+}
+declare function createAuthService(app: FastifyInstance): AuthService;
+
+type UserStatus = 'active' | 'inactive' | 'suspended' | 'banned';
+type UserRole = 'user' | 'admin' | 'moderator' | 'super_admin';
+interface User extends BaseEntity {
+    email: string;
+    password: string;
+    name?: string;
+    role: UserRole;
+    status: UserStatus;
+    emailVerified: boolean;
+    lastLoginAt?: Date;
+    metadata?: Record<string, unknown>;
+}
+interface CreateUserData {
+    email: string;
+    password: string;
+    name?: string;
+    role?: UserRole;
+}
+interface UpdateUserData {
+    email?: string;
+    name?: string;
+    role?: UserRole;
+    status?: UserStatus;
+    emailVerified?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface UserFilters {
+    status?: UserStatus;
+    role?: UserRole;
+    search?: string;
+    emailVerified?: boolean;
+}
+interface Permission {
+    id: string;
+    name: string;
+    description?: string;
+    resource: string;
+    action: 'create' | 'read' | 'update' | 'delete' | 'manage';
+}
+interface Role {
+    id: string;
+    name: UserRole;
+    description?: string;
+    permissions: Permission[];
+}
+declare const DEFAULT_ROLE_PERMISSIONS: Record<UserRole, string[]>;
+
+declare class UserRepository {
+    findById(id: string): Promise<User | null>;
+    findByEmail(email: string): Promise<User | null>;
+    findMany(params: PaginationParams, filters?: UserFilters): Promise<PaginatedResult<User>>;
+    create(data: CreateUserData): Promise<User>;
+    update(id: string, data: UpdateUserData): Promise<User | null>;
+    updatePassword(id: string, password: string): Promise<User | null>;
+    updateLastLogin(id: string): Promise<User | null>;
+    delete(id: string): Promise<boolean>;
+    count(filters?: UserFilters): Promise<number>;
+    clear(): Promise<void>;
+}
+declare function createUserRepository(): UserRepository;
+
+declare class UserService {
+    private repository;
+    constructor(repository: UserRepository);
+    findById(id: string): Promise<User | null>;
+    findByEmail(email: string): Promise<User | null>;
+    findMany(params: PaginationParams, filters?: UserFilters): Promise<PaginatedResult<Omit<User, 'password'>>>;
+    create(data: CreateUserData): Promise<User>;
+    update(id: string, data: UpdateUserData): Promise<User>;
+    updatePassword(id: string, hashedPassword: string): Promise<User>;
+    updateLastLogin(id: string): Promise<User>;
+    delete(id: string): Promise<void>;
+    suspend(id: string): Promise<User>;
+    ban(id: string): Promise<User>;
+    activate(id: string): Promise<User>;
+    verifyEmail(id: string): Promise<User>;
+    changeRole(id: string, role: UserRole): Promise<User>;
+    hasPermission(role: UserRole, permission: string): boolean;
+    getPermissions(role: UserRole): string[];
+}
+declare function createUserService(repository?: UserRepository): UserService;
+
+declare class AuthController {
+    private authService;
+    private userService;
+    constructor(authService: AuthService, userService: UserService);
+    register(request: FastifyRequest, reply: FastifyReply): Promise<void>;
+    login(request: FastifyRequest, reply: FastifyReply): Promise<void>;
+    refresh(request: FastifyRequest, reply: FastifyReply): Promise<void>;
+    logout(request: FastifyRequest, reply: FastifyReply): Promise<void>;
+    me(request: FastifyRequest, reply: FastifyReply): Promise<void>;
+    changePassword(request: FastifyRequest, reply: FastifyReply): Promise<void>;
+}
+declare function createAuthController(authService: AuthService, userService: UserService): AuthController;
+
+declare function createAuthMiddleware(authService: AuthService): (request: FastifyRequest, reply: FastifyReply) => Promise<void>;
+declare function createRoleMiddleware(allowedRoles: string[]): (request: FastifyRequest, _reply: FastifyReply) => Promise<void>;
+declare function createPermissionMiddleware(requiredPermissions: string[]): (request: FastifyRequest, _reply: FastifyReply) => Promise<void>;
+declare function createOptionalAuthMiddleware(authService: AuthService): (request: FastifyRequest, _reply: FastifyReply) => Promise<void>;
+
+declare const loginSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    password: string;
+}, {
+    email: string;
+    password: string;
+}>;
+declare const registerSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    password: string;
+    name?: string | undefined;
+}, {
+    email: string;
+    password: string;
+    name?: string | undefined;
+}>;
+declare const refreshTokenSchema: z.ZodObject<{
+    refreshToken: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    refreshToken: string;
+}, {
+    refreshToken: string;
+}>;
+declare const passwordResetRequestSchema: z.ZodObject<{
+    email: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+}, {
+    email: string;
+}>;
+declare const passwordResetConfirmSchema: z.ZodObject<{
+    token: z.ZodString;
+    password: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    password: string;
+    token: string;
+}, {
+    password: string;
+    token: string;
+}>;
+declare const changePasswordSchema: z.ZodObject<{
+    currentPassword: z.ZodString;
+    newPassword: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    currentPassword: string;
+    newPassword: string;
+}, {
+    currentPassword: string;
+    newPassword: string;
+}>;
+type LoginInput = z.infer<typeof loginSchema>;
+type RegisterInput = z.infer<typeof registerSchema>;
+type RefreshTokenInput = z.infer<typeof refreshTokenSchema>;
+type PasswordResetRequestInput = z.infer<typeof passwordResetRequestSchema>;
+type PasswordResetConfirmInput = z.infer<typeof passwordResetConfirmSchema>;
+type ChangePasswordInput = z.infer<typeof changePasswordSchema>;
+
+declare function registerAuthModule(app: FastifyInstance): Promise<AuthService>;
+
+declare class UserController {
+    private userService;
+    constructor(userService: UserService);
+    list(request: FastifyRequest, reply: FastifyReply): Promise<void>;
+    getById(request: FastifyRequest<{
+        Params: {
+            id: string;
+        };
+    }>, reply: FastifyReply): Promise<void>;
+    update(request: FastifyRequest<{
+        Params: {
+            id: string;
+        };
+    }>, reply: FastifyReply): Promise<void>;
+    delete(request: FastifyRequest<{
+        Params: {
+            id: string;
+        };
+    }>, reply: FastifyReply): Promise<void>;
+    suspend(request: FastifyRequest<{
+        Params: {
+            id: string;
+        };
+    }>, reply: FastifyReply): Promise<void>;
+    ban(request: FastifyRequest<{
+        Params: {
+            id: string;
+        };
+    }>, reply: FastifyReply): Promise<void>;
+    activate(request: FastifyRequest<{
+        Params: {
+            id: string;
+        };
+    }>, reply: FastifyReply): Promise<void>;
+    getProfile(request: FastifyRequest, reply: FastifyReply): Promise<void>;
+    updateProfile(request: FastifyRequest, reply: FastifyReply): Promise<void>;
+}
+declare function createUserController(userService: UserService): UserController;
+
+declare const userStatusEnum: z.ZodEnum<["active", "inactive", "suspended", "banned"]>;
+declare const userRoleEnum: z.ZodEnum<["user", "admin", "moderator", "super_admin"]>;
+declare const createUserSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    role: z.ZodDefault<z.ZodOptional<z.ZodEnum<["user", "admin", "moderator", "super_admin"]>>>;
+}, "strip", z.ZodTypeAny, {
+    email: string;
+    password: string;
+    role: "user" | "admin" | "moderator" | "super_admin";
+    name?: string | undefined;
+}, {
+    email: string;
+    password: string;
+    name?: string | undefined;
+    role?: "user" | "admin" | "moderator" | "super_admin" | undefined;
+}>;
+declare const updateUserSchema: z.ZodObject<{
+    email: z.ZodOptional<z.ZodString>;
+    name: z.ZodOptional<z.ZodString>;
+    role: z.ZodOptional<z.ZodEnum<["user", "admin", "moderator", "super_admin"]>>;
+    status: z.ZodOptional<z.ZodEnum<["active", "inactive", "suspended", "banned"]>>;
+    emailVerified: z.ZodOptional<z.ZodBoolean>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    status?: "active" | "inactive" | "suspended" | "banned" | undefined;
+    name?: string | undefined;
+    email?: string | undefined;
+    role?: "user" | "admin" | "moderator" | "super_admin" | undefined;
+    emailVerified?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    status?: "active" | "inactive" | "suspended" | "banned" | undefined;
+    name?: string | undefined;
+    email?: string | undefined;
+    role?: "user" | "admin" | "moderator" | "super_admin" | undefined;
+    emailVerified?: boolean | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+declare const updateProfileSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    name?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}, {
+    name?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}>;
+declare const userQuerySchema: z.ZodObject<{
+    page: z.ZodOptional<z.ZodEffects<z.ZodString, number, string>>;
+    limit: z.ZodOptional<z.ZodEffects<z.ZodString, number, string>>;
+    sortBy: z.ZodOptional<z.ZodString>;
+    sortOrder: z.ZodOptional<z.ZodEnum<["asc", "desc"]>>;
+    status: z.ZodOptional<z.ZodEnum<["active", "inactive", "suspended", "banned"]>>;
+    role: z.ZodOptional<z.ZodEnum<["user", "admin", "moderator", "super_admin"]>>;
+    search: z.ZodOptional<z.ZodString>;
+    emailVerified: z.ZodOptional<z.ZodEffects<z.ZodString, boolean, string>>;
+}, "strip", z.ZodTypeAny, {
+    status?: "active" | "inactive" | "suspended" | "banned" | undefined;
+    search?: string | undefined;
+    role?: "user" | "admin" | "moderator" | "super_admin" | undefined;
+    page?: number | undefined;
+    limit?: number | undefined;
+    sortBy?: string | undefined;
+    sortOrder?: "asc" | "desc" | undefined;
+    emailVerified?: boolean | undefined;
+}, {
+    status?: "active" | "inactive" | "suspended" | "banned" | undefined;
+    search?: string | undefined;
+    role?: "user" | "admin" | "moderator" | "super_admin" | undefined;
+    page?: string | undefined;
+    limit?: string | undefined;
+    sortBy?: string | undefined;
+    sortOrder?: "asc" | "desc" | undefined;
+    emailVerified?: string | undefined;
+}>;
+type CreateUserInput = z.infer<typeof createUserSchema>;
+type UpdateUserInput = z.infer<typeof updateUserSchema>;
+type UpdateProfileInput = z.infer<typeof updateProfileSchema>;
+type UserQueryInput = z.infer<typeof userQuerySchema>;
+
+declare function registerUserModule(app: FastifyInstance, authService: AuthService): Promise<void>;
+
+interface EmailConfig {
+    host: string;
+    port: number;
+    secure?: boolean;
+    auth: {
+        user: string;
+        pass: string;
+    };
+    from: string;
+}
+interface EmailOptions {
+    to: string | string[];
+    subject: string;
+    html?: string;
+    text?: string;
+    template?: string;
+    data?: Record<string, unknown>;
+    attachments?: EmailAttachment[];
+    replyTo?: string;
+    cc?: string | string[];
+    bcc?: string | string[];
+}
+interface EmailAttachment {
+    filename: string;
+    content?: string | Buffer;
+    path?: string;
+    contentType?: string;
+}
+interface EmailResult {
+    success: boolean;
+    messageId?: string;
+    error?: string;
+}
+type EmailTemplate = 'welcome' | 'verify-email' | 'password-reset' | 'password-changed' | 'login-alert' | 'account-suspended' | 'custom';
+interface TemplateData {
+    appName?: string;
+    userName?: string;
+    userEmail?: string;
+    actionUrl?: string;
+    token?: string;
+    expiresIn?: string;
+    ipAddress?: string;
+    userAgent?: string;
+    [key: string]: unknown;
+}
+
+declare class EmailService {
+    private transporter;
+    private config;
+    constructor(emailConfig?: Partial<EmailConfig>);
+    send(options: EmailOptions): Promise<EmailResult>;
+    sendTemplate(to: string, template: string, data: TemplateData): Promise<EmailResult>;
+    sendWelcome(email: string, name: string, verifyUrl?: string): Promise<EmailResult>;
+    sendVerifyEmail(email: string, name: string, verifyUrl: string): Promise<EmailResult>;
+    sendPasswordReset(email: string, name: string, resetUrl: string): Promise<EmailResult>;
+    sendPasswordChanged(email: string, name: string, ipAddress?: string, userAgent?: string): Promise<EmailResult>;
+    sendLoginAlert(email: string, name: string, ipAddress: string, userAgent: string, location?: string): Promise<EmailResult>;
+    verify(): Promise<boolean>;
+    private htmlToText;
+}
+declare function getEmailService(): EmailService;
+declare function createEmailService(config?: Partial<EmailConfig>): EmailService;
+
+declare function renderTemplate(templateName: string, data: Record<string, unknown>): string;
+declare function renderCustomTemplate(htmlTemplate: string, data: Record<string, unknown>): string;
+
+declare function validateBody<T extends ZodTypeAny>(schema: T, data: unknown): z.infer<T>;
+declare function validateQuery<T extends ZodTypeAny>(schema: T, data: unknown): z.infer<T>;
+declare function validateParams<T extends ZodTypeAny>(schema: T, data: unknown): z.infer<T>;
+declare function validate<T extends ZodTypeAny>(schema: T, data: unknown): z.infer<T>;
+declare const idParamSchema: z.ZodObject<{
+    id: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+}, {
+    id: string;
+}>;
+declare const paginationSchema: z.ZodObject<{
+    page: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodString, number, string>>>;
+    limit: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodString, number, string>>>;
+    sortBy: z.ZodOptional<z.ZodString>;
+    sortOrder: z.ZodDefault<z.ZodOptional<z.ZodEnum<["asc", "desc"]>>>;
+}, "strip", z.ZodTypeAny, {
+    page: number;
+    limit: number;
+    sortOrder: "asc" | "desc";
+    sortBy?: string | undefined;
+}, {
+    page?: string | undefined;
+    limit?: string | undefined;
+    sortBy?: string | undefined;
+    sortOrder?: "asc" | "desc" | undefined;
+}>;
+declare const searchSchema: z.ZodObject<{
+    q: z.ZodOptional<z.ZodString>;
+    search: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    search?: string | undefined;
+    q?: string | undefined;
+}, {
+    search?: string | undefined;
+    q?: string | undefined;
+}>;
+declare const emailSchema: z.ZodString;
+declare const passwordSchema: z.ZodString;
+declare const urlSchema: z.ZodString;
+declare const phoneSchema: z.ZodString;
+declare const dateSchema: z.ZodDate;
+declare const futureDateSchema: z.ZodEffects<z.ZodDate, Date, Date>;
+declare const pastDateSchema: z.ZodEffects<z.ZodDate, Date, Date>;
+type IdParam = z.infer<typeof idParamSchema>;
+type PaginationInput = z.infer<typeof paginationSchema>;
+
+type AuditAction = 'create' | 'read' | 'update' | 'delete' | 'login' | 'logout' | 'register' | 'password_change' | 'password_reset' | 'email_verify' | 'role_change' | 'status_change' | 'settings_change';
+interface AuditLogEntry {
+    userId?: string;
+    action: AuditAction | string;
+    resource: string;
+    resourceId?: string;
+    oldValue?: Record<string, unknown>;
+    newValue?: Record<string, unknown>;
+    ipAddress?: string;
+    userAgent?: string;
+    metadata?: Record<string, unknown>;
+}
+interface AuditLogQuery {
+    userId?: string;
+    action?: string;
+    resource?: string;
+    resourceId?: string;
+    startDate?: Date;
+    endDate?: Date;
+    page?: number;
+    limit?: number;
+}
+
+declare class AuditService {
+    log(entry: AuditLogEntry): Promise<void>;
+    query(params: AuditLogQuery): Promise<PaginatedResult<AuditLogEntry & {
+        id: string;
+        createdAt: Date;
+    }>>;
+    findByUser(userId: string, limit?: number): Promise<(AuditLogEntry & {
+        id: string;
+        createdAt: Date;
+    })[]>;
+    findByResource(resource: string, resourceId: string, limit?: number): Promise<(AuditLogEntry & {
+        id: string;
+        createdAt: Date;
+    })[]>;
+    logCreate(resource: string, resourceId: string, userId?: string, newValue?: Record<string, unknown>, meta?: {
+        ipAddress?: string;
+        userAgent?: string;
+    }): Promise<void>;
+    logUpdate(resource: string, resourceId: string, userId?: string, oldValue?: Record<string, unknown>, newValue?: Record<string, unknown>, meta?: {
+        ipAddress?: string;
+        userAgent?: string;
+    }): Promise<void>;
+    logDelete(resource: string, resourceId: string, userId?: string, oldValue?: Record<string, unknown>, meta?: {
+        ipAddress?: string;
+        userAgent?: string;
+    }): Promise<void>;
+    logLogin(userId: string, meta?: {
+        ipAddress?: string;
+        userAgent?: string;
+    }): Promise<void>;
+    logLogout(userId: string, meta?: {
+        ipAddress?: string;
+        userAgent?: string;
+    }): Promise<void>;
+    logPasswordChange(userId: string, meta?: {
+        ipAddress?: string;
+        userAgent?: string;
+    }): Promise<void>;
+    clear(): Promise<void>;
+}
+declare function getAuditService(): AuditService;
+declare function createAuditService(): AuditService;
+
+export { type ApiResponse, type AppConfig, AppError, type AuditAction, type AuditLogEntry, type AuditLogQuery, AuditService, AuthController, AuthService, type AuthUser, type AuthenticatedRequest, BadRequestError, type BaseEntity, type ChangePasswordData, type ChangePasswordInput, ConflictError, type ControllerHandler, type CreateUserData, type CreateUserInput, DEFAULT_LIMIT, DEFAULT_PAGE, DEFAULT_ROLE_PERMISSIONS, type EmailAttachment, type EmailConfig, type EmailOptions, type EmailResult, EmailService, type EmailTemplate, type Env, ForbiddenError, type IdParam, type JwtPayload, type LoggerConfig, type LoginCredentials, type LoginInput, MAX_LIMIT, type Module, NotFoundError, type PaginatedResult, type PaginationInput, type PaginationParams, type PasswordResetConfirm, type PasswordResetConfirmInput, type PasswordResetRequest, type PasswordResetRequestInput, type Permission, type RefreshTokenData, type RefreshTokenInput, type RegisterData, type RegisterInput, type Repository, type Role, type SecurityOptions, Server, type ServerConfig, type ServiceResult, type TemplateData, type TokenPair, TooManyRequestsError, UnauthorizedError, type UpdateProfileInput, type UpdateUserData, type UpdateUserInput, type User, UserController, type UserFilters, type UserQueryInput, UserRepository, type UserRole, UserService, type UserStatus, ValidationError, badRequest, changePasswordSchema, config, conflict, createAuditService, createAuthController, createAuthMiddleware, createAuthService, createConfig, createEmailService, createLogger, createOptionalAuthMiddleware, createPaginatedResult, createPermissionMiddleware, createRoleMiddleware, createServer, createUserController, createUserRepository, createUserSchema, createUserService, created, dateSchema, emailSchema, env, error, forbidden, futureDateSchema, getAuditService, getEmailService, getSkip, idParamSchema, internalError, isAppError, isDevelopment, isProduction, isStaging, isTest, logger, loginSchema, noContent, notFound, paginationSchema, parsePaginationParams, passwordResetConfirmSchema, passwordResetRequestSchema, passwordSchema, pastDateSchema, phoneSchema, refreshTokenSchema, registerAuthModule, registerBruteForceProtection, registerErrorHandler, registerSchema, registerSecurity, registerUserModule, renderCustomTemplate, renderTemplate, searchSchema, success, unauthorized, updateProfileSchema, updateUserSchema, urlSchema, userQuerySchema, userRoleEnum, userStatusEnum, validate, validateBody, validateParams, validateQuery };