import { A as AbstractService, N as NextRef, P as PreviousRef } from './AbstractService-Cew0PD0L.js';
import { F as FeatureInterface } from './feature.interface-BO25VLlx.js';
import { e as RoleInterface, U as UserInterface, f as UserInput, c as CompanyInterface, b as CompanyInput, C as ContentInterface, N as NotificationInterface } from './notification.interface-DYF56CtE.js';
import { A as ApiDataInterface, J as JsonApiHydratedDataInterface } from './ApiDataInterface-BcZeXy5X.js';
import { A as AuthInput, b as AuthInterface } from './auth.interface-B6ZQLGjS.js';

declare class FeatureService extends AbstractService {
    static findMany(params: {
        companyId?: string;
        search?: string;
        next?: NextRef;
    }): Promise<FeatureInterface[]>;
}

declare class RoleService extends AbstractService {
    static findById(params: {
        roleId: string;
    }): Promise<RoleInterface>;
    static findAllRoles(params: {
        search?: string;
        next?: NextRef;
    }): Promise<RoleInterface[]>;
    static findAllRolesByUser(params: {
        userId: string;
        search?: string;
        next?: NextRef;
        prev?: PreviousRef;
    }): Promise<RoleInterface[]>;
    static findAllRolesUserNotIn(params: {
        userId: string;
        search?: string;
        next?: NextRef;
        prev?: PreviousRef;
    }): Promise<RoleInterface[]>;
    static addUserToRole(params: {
        userId: string;
        roleId: string;
    }): Promise<void>;
    static removeUserFromRole(params: {
        userId: string;
        roleId: string;
    }): Promise<void>;
    static create(params: {
        roleId: string;
        name: string;
        description?: string;
    }): Promise<RoleInterface>;
    static update(params: {
        roleId: string;
        name: string;
        description?: string;
    }): Promise<RoleInterface>;
    static delete(params: {
        roleId: string;
    }): Promise<RoleInterface>;
}

declare class UserService extends AbstractService {
    static findFullUser(): Promise<UserInterface>;
    static findById(params: {
        userId: string;
    }): Promise<UserInterface>;
    static findByEmail(params: {
        email: string;
    }): Promise<UserInterface>;
    static findMany(params: {
        roleId?: string;
        search?: string;
        fetchAll?: boolean;
        includeDeleted?: boolean;
        next?: NextRef;
        prev?: PreviousRef;
    }): Promise<UserInterface[]>;
    static findManyByContentIds(params: {
        contentIds: string[];
        search?: string;
        next?: NextRef;
        prev?: PreviousRef;
    }): Promise<UserInterface[]>;
    static findRelevant(params: {
        id: string;
        next?: NextRef;
        prev?: PreviousRef;
    }): Promise<UserInterface[]>;
    static findManyForAmin(params: {
        companyId?: string;
        search?: string;
        next?: NextRef;
        prev?: PreviousRef;
    }): Promise<UserInterface[]>;
    static findAllUsers(params: {
        companyId: string;
        search?: string;
        limitToRoles?: string[];
        isDeleted?: boolean;
        next?: NextRef;
        prev?: PreviousRef;
    }): Promise<UserInterface[]>;
    static findAllUsersByRole(params: {
        roleId: string;
        search?: string;
        next?: NextRef;
        prev?: PreviousRef;
    }): Promise<UserInterface[]>;
    static findAllUsersNotInRole(params: {
        roleId: string;
        search?: string;
        next?: NextRef;
        prev?: PreviousRef;
    }): Promise<UserInterface[]>;
    static create(params: UserInput): Promise<UserInterface>;
    static reactivate(params: {
        userId: string;
    }): Promise<UserInterface>;
    static sendInvitation(params: {
        userId: string;
        companyId?: string;
    }): Promise<void>;
    static update(params: UserInput): Promise<UserInterface>;
    static patch(params: {
        id: string;
    } & Partial<Omit<UserInput, "id">>): Promise<UserInterface>;
    static patchAvatar(params: {
        id: string;
        avatar: string;
    }): Promise<UserInterface>;
    static patchRate(params: UserInput): Promise<UserInterface>;
    static delete(params: {
        userId: string;
        companyId: string;
    }): Promise<void>;
}

interface TwoFactorChallengeInterface extends ApiDataInterface {
    get pendingToken(): string;
    get availableMethods(): ("totp" | "passkey" | "backup")[];
    get expiresAt(): Date;
}

declare class AuthService extends AbstractService {
    static login(params: {
        email: string;
        password: string;
        language?: string;
    }): Promise<UserInterface | TwoFactorChallengeInterface>;
    static logout(params?: {
        language?: string;
    }): Promise<void>;
    static initialiseForgotPassword(params: {
        email: string;
        language?: string;
    }): Promise<void>;
    static register(params: AuthInput): Promise<void>;
    static activate(params: {
        activationCode: string;
    }): Promise<void>;
    static validateCode(params: {
        code: string;
        language?: string;
    }): Promise<void>;
    static resetPassword(params: {
        code: string;
        password: string;
    }): Promise<void>;
    static acceptInvitation(params: {
        code: string;
        password: string;
    }): Promise<void>;
    static findToken(params: {
        tokenCode: string;
    }): Promise<AuthInterface>;
    static saveToken(params: {
        dehydratedAuth: JsonApiHydratedDataInterface;
    }): Promise<void>;
    static completeOAuthRegistration(params: {
        pendingId: string;
        termsAcceptedAt: string;
        marketingConsent: boolean;
        marketingConsentAt: string | null;
    }): Promise<{
        code: string;
    }>;
}

declare class CompanyService extends AbstractService {
    static findOne(params: {
        companyId: string;
    }): Promise<CompanyInterface>;
    static findMany(params: {
        search?: string;
        next?: NextRef;
    }): Promise<CompanyInterface[]>;
    static delete(params: {
        companyId: string;
    }): Promise<void>;
    static selfDelete(params: {
        companyId: string;
    }): Promise<void>;
    static create(params: CompanyInput): Promise<CompanyInterface>;
    static update(params: CompanyInput): Promise<CompanyInterface>;
    static updateConfigurations(params: CompanyInput): Promise<CompanyInterface>;
    static activateLicense(params: CompanyInput): Promise<CompanyInterface>;
}

declare class ContentService extends AbstractService {
    static findMany(params: {
        contentIds?: string[];
        search?: string;
        fetchAll?: boolean;
        next?: NextRef;
        prev?: PreviousRef;
    }): Promise<ContentInterface[]>;
    static findRelevant(params: {
        id: string;
        next?: NextRef;
        prev?: PreviousRef;
    }): Promise<ContentInterface[]>;
    static findManyByAuthor(params: {
        userId: string;
        search?: string;
        fetchAll?: boolean;
        next?: NextRef;
        prev?: PreviousRef;
    }): Promise<ContentInterface[]>;
}

declare class NotificationService extends AbstractService {
    static findMany(params: {
        isArchived?: boolean;
        next?: NextRef;
    }): Promise<NotificationInterface[]>;
    static markAsRead(params: {
        data: any;
    }): Promise<void>;
    static archive(params: {
        id: string;
    }): Promise<void>;
}

declare class PushService extends AbstractService {
    static register(params: {
        data: any;
    }): Promise<void>;
}

type S3Input = {
    key: string;
    contentType?: string;
};
interface S3Interface extends ApiDataInterface {
    get url(): string;
    get headers(): Record<string, string>;
}

declare class S3Service extends AbstractService {
    static getPreSignedUrl(params: {
        key: string;
        contentType: string;
        isPublic?: boolean;
    }): Promise<S3Interface>;
    static getSignedUrl(params: {
        key: string;
        isPublic?: boolean;
    }): Promise<S3Interface>;
    static deleteFile(params: {
        key: string;
    }): Promise<void>;
}

export { AuthService as A, CompanyService as C, FeatureService as F, NotificationService as N, PushService as P, RoleService as R, S3Service as S, type TwoFactorChallengeInterface as T, UserService as U, ContentService as a, type S3Input as b, type S3Interface as c };