import { DataSource, Repository } from 'typeorm';
import { UserRole } from '../../common/enums/user-role.enum';
import { AuthenticatedUser } from '../../common/interfaces/authenticated-user.interface';
import { Company } from '../companies/entities/company.entity';
import { UserCompany } from '../companies/entities/user-company.entity';
import { Site } from '../sites/entities/site.entity';
import { UserSite } from '../sites/entities/user-site.entity';
import { CreateUserDto } from './dto/create-user.dto';
import { UpdateUserDto } from './dto/update-user.dto';
import { UsersQueryDto } from './dto/users-query.dto';
import { User } from './entities/user.entity';
export interface PublicUser {
    id: number;
    email: string;
    role: UserRole;
    firstName: string;
    lastName: string;
    isActive: boolean;
    lastLoginAt: Date | null;
    createdAt: Date;
    updatedAt: Date;
    companies?: Pick<Company, 'id' | 'name' | 'code'>[];
    sites?: Pick<Site, 'id' | 'name' | 'code' | 'companyId'>[];
}
export declare class UsersService {
    private readonly usersRepository;
    private readonly userCompaniesRepository;
    private readonly companiesRepository;
    private readonly userSitesRepository;
    private readonly sitesRepository;
    private readonly dataSource;
    constructor(usersRepository: Repository<User>, userCompaniesRepository: Repository<UserCompany>, companiesRepository: Repository<Company>, userSitesRepository: Repository<UserSite>, sitesRepository: Repository<Site>, dataSource: DataSource);
    findById(id: number): Promise<User | null>;
    findByEmail(email: string): Promise<User | null>;
    findAll(query: UsersQueryDto, actor: AuthenticatedUser): Promise<{
        items: PublicUser[];
        total: number;
    }>;
    private allowedRolesForActor;
    assertActorCanTarget(actor: AuthenticatedUser, targetUserId: number): Promise<User>;
    assertActorCanAssignRole(actor: AuthenticatedUser, role: UserRole | undefined): void;
    assertActorCanAssignCompanies(actor: AuthenticatedUser, companyIds: number[]): Promise<void>;
    assertActorCanAssignSites(actor: AuthenticatedUser, siteIds: number[]): Promise<void>;
    getOne(id: number): Promise<PublicUser>;
    create(dto: CreateUserDto): Promise<PublicUser>;
    update(id: number, dto: UpdateUserDto): Promise<PublicUser>;
    updateMyProfile(id: number, dto: {
        email?: string;
        firstName?: string;
        lastName?: string;
    }): Promise<PublicUser>;
    deactivate(id: number): Promise<void>;
    assignCompanies(userId: number, companyIds: number[]): Promise<PublicUser>;
    assignSites(userId: number, siteIds: number[]): Promise<PublicUser>;
    getUserCompanies(userId: number): Promise<Company[]>;
    getUserSites(userId: number): Promise<Site[]>;
    save(user: User): Promise<User>;
    setPasswordHash(userId: number, hash: string): Promise<void>;
    resetPassword(userId: number): Promise<{
        tempPassword: string;
    }>;
    private generateTempPassword;
    incrementFailedAttempts(userId: number): Promise<void>;
    resetFailedAttempts(userId: number): Promise<void>;
    lockUser(userId: number, lockedUntil: Date): Promise<void>;
    updateLastLogin(userId: number): Promise<void>;
    updateRefreshTokenHash(userId: number, hash: string | null): Promise<void>;
    private replaceUserCompanies;
    private replaceUserSites;
    private toPublic;
}