import { ConfigService } from "@nestjs/config";
import { EmailService } from "../../../core/email/services/email.service";
import { UserPostDataDTO } from "../../user/dtos/user.post.dto";
import { UserPutDataDTO } from "../../user/dtos/user.put.dto";
import { ClsService } from "nestjs-cls";
import { BaseConfigInterface } from "../../../config/interfaces";
import { JsonApiDataInterface } from "../../../core/jsonapi/interfaces/jsonapi.data.interface";
import { JsonApiService } from "../../../core/jsonapi/services/jsonapi.service";
import { AbstractService } from "../../../core/neo4j/abstracts/abstract.service";
import { UserPatchAvatarDataDTO } from "../../user/dtos/user.patch.avatar.dto";
import { UserPatchRateDataDTO } from "../../user/dtos/user.patch.rate.dto";
import { User, UserDescriptor } from "../../user/entities/user";
import { UserRepository } from "../repositories/user.repository";
/**
 * User service.
 *
 * Extends `AbstractService` so an application can subclass it and have BOTH the
 * inherited generic methods AND every method declared here serialise with the
 * *extended* model. Model resolution is by subclass polymorphism — a subclass
 * re-declares `descriptor` and `model` as initialised class fields — never by a
 * registry lookup (Nest constructs providers before `onModuleInit`, where models
 * are registered).
 *
 * The three domain methods whose names collide with the abstract's generic CRUD
 * (`create` / `put` / `delete`) are named `createUser` / `putUser` /
 * `deleteUser` so the inherited descriptor-driven CRUD stays reachable.
 */
export declare class UserService extends AbstractService<User, typeof UserDescriptor.relationships> {
    protected readonly userRepository: UserRepository;
    protected readonly emailService: EmailService;
    protected readonly configService: ConfigService<BaseConfigInterface>;
    protected readonly descriptor: import("../../..").EntityDescriptor<User, {
        role: {
            model: import("../../..").DataMeta;
            direction: "out";
            relationship: string;
            cardinality: "many";
            dtoKey: string;
            readOnly: true;
        };
        company: {
            model: import("../../..").DataModelInterface<import("../..").Company>;
            direction: "out";
            relationship: string;
            cardinality: "one";
        };
        module: {
            model: import("../../..").DataMeta;
            direction: "out";
            relationship: string;
            cardinality: "many";
            dtoKey: string;
        };
    }>;
    constructor(jsonApiService: JsonApiService, userRepository: UserRepository, emailService: EmailService, configService: ConfigService<BaseConfigInterface>, clsService: ClsService);
    private get appConfig();
    /**
     * Defence in depth: the global Administrator role is platform-level and may
     * only be granted through the dedicated platform path (`addUserToRole`). A
     * company-scoped write (create / put) that carried it would create a
     * company Membership holding Administrator, which the JWT would then surface
     * as platform-admin for that company.
     */
    private companyRoleIds;
    expectNotExists(params: {
        email: string;
    }): Promise<void>;
    findMany(params: {
        query: any;
        isAdmin: boolean;
        term?: string;
        userIds?: string[];
        includeDeleted?: boolean;
    }): Promise<JsonApiDataInterface>;
    findByContentIds(params: {
        contentIds: string[];
        query: any;
        term?: string;
        includeDeleted?: boolean;
    }): Promise<JsonApiDataInterface>;
    findManyByCompany(params: {
        companyId: string;
        query: any;
        isDeleted?: boolean;
        term?: string;
        userIds?: string[];
        includeDeleted?: boolean;
    }): Promise<JsonApiDataInterface>;
    findInRole(params: {
        roleId: string;
        term: string;
        query: any;
        isAdmin: boolean;
    }): Promise<JsonApiDataInterface>;
    findNotInRole(params: {
        roleId: string;
        term: string;
        query: any;
        isAdmin: boolean;
    }): Promise<JsonApiDataInterface>;
    findByUserId(params: {
        userId: string;
    }): Promise<JsonApiDataInterface>;
    findOneForAdmin(params: {
        userId: string;
    }): Promise<JsonApiDataInterface>;
    findByUserIdCompanyId(params: {
        userId: string;
        companyId: string;
    }): Promise<JsonApiDataInterface>;
    putUser(params: {
        data: UserPutDataDTO;
        isAdmin: boolean;
        isCurrentUser: boolean;
    }): Promise<JsonApiDataInterface>;
    findFullUser(params: {
        userId: string;
    }): Promise<JsonApiDataInterface>;
    reactivate(params: {
        userId: string;
    }): Promise<JsonApiDataInterface>;
    patchAvatar(params: {
        data: UserPatchAvatarDataDTO;
    }): Promise<JsonApiDataInterface>;
    patchRate(params: {
        data: UserPatchRateDataDTO;
    }): Promise<JsonApiDataInterface>;
    sendInvitationEmail(params: {
        userId: string;
    }): Promise<void>;
    findByEmail(params: {
        email: string;
    }): Promise<JsonApiDataInterface>;
    createUser(params: {
        data: UserPostDataDTO;
        forceCompanyAdmin?: boolean;
        language: string;
    }): Promise<JsonApiDataInterface | void>;
    createForCompany(params: {
        companyId: string;
        data: UserPostDataDTO;
        language: string;
    }): Promise<JsonApiDataInterface | void>;
    deleteUser(params: {
        userId: string;
    }): Promise<void>;
    addUserToRole(params: {
        userId: string;
        roleId: string;
        returnsFull: boolean;
    }): Promise<JsonApiDataInterface>;
    removeUserFromRole(params: {
        roleId: string;
        userId: string;
        returnsFull: boolean;
    }): Promise<JsonApiDataInterface>;
}
//# sourceMappingURL=user.service.d.ts.map