import { Repository, EntityManager } from 'typeorm';
import { ProgramRegistration, ProgramRegistrationOnlineSession, ProgramSession, BackgroundJob } from 'src/common/entities';
import { AppLoggerService } from 'src/common/services/logger.service';
import { UserTypeFilterValue } from 'src/common/utils/user-type-filter.util';
import { ExportJobStatus } from 'src/common/enum/export-job-status.enum';
import { SessionProviderType } from 'src/common/enum/session-provider.enum';
import { RegistrationOnlineSessionActivationStatus } from 'src/common/enum/registration-online-session-activation-status.enum';
import { RegistrationOnlineSessionActivationSource } from 'src/common/enum/registration-online-session-activation-source.enum';
import { RegistrationWithJoinUrl, EligibleActivationSummary, ProgramEligibleRegistrationRow, ProgramEligibleRegistrationsQuery, ProgramEligibleKpis, RmContactOption, ProgramRegistrationStatusRow } from '../interfaces/zoom-registration.interface';
import { ZoomRegistrationProfile } from '../interfaces/zoom-analytics.interface';
export declare class ZoomRegistrationRepository {
    private readonly registrationRepo;
    private readonly zoomRepo;
    private readonly jobRepo;
    private readonly logger;
    constructor(registrationRepo: Repository<ProgramRegistration>, zoomRepo: Repository<ProgramRegistrationOnlineSession>, jobRepo: Repository<BackgroundJob>, logger: AppLoggerService);
    private zoom;
    withTransaction<T>(work: (manager: EntityManager) => Promise<T>): Promise<T>;
    findRegistrationById(registrationId: number, manager?: EntityManager): Promise<ProgramRegistration | null>;
    findRegistrationsBySession(programSessionId: number, manager?: EntityManager): Promise<ProgramRegistration[]>;
    private applyUserTypeWhere;
    findEligibleRegistrationsByProgram(programId: number, rmContactId?: number, options?: {
        excludeDeactivated?: boolean;
        userType?: UserTypeFilterValue[];
    }): Promise<ProgramRegistration[]>;
    findAllRegistrationsByProgramIncludingDeleted(programId: number, rmContactId?: number, options?: {
        userType?: UserTypeFilterValue[];
    }): Promise<ProgramRegistration[]>;
    findIneligibleRegistrationsByProgram(programId: number): Promise<Array<{
        registrationId: number;
        registrationSeqNumber: string | null;
        registrationStatus: string;
        seatAllocated: boolean;
    }>>;
    findAllRegistrationsByProgram(programId: number): Promise<ProgramRegistrationStatusRow[]>;
    findRegistrationsByIds(ids: number[]): Promise<ProgramRegistration[]>;
    private static readonly LATEST_PAYMENT_STATUS_SQL;
    private static readonly LATEST_PAYMENT_MODE_SQL;
    private static readonly SORT_COLUMNS;
    listSeatAllocatedRegistrationsByProgram(programId: number, options: ProgramEligibleRegistrationsQuery): Promise<{
        data: ProgramEligibleRegistrationRow[];
        total: number;
    }>;
    private static readonly AGE_BUCKETS;
    private applyProgramEligibleFilters;
    private applyAgeFilter;
    private applyPaymentStatusFilter;
    private capitalizeFirst;
    private listProgramSessions;
    private findAttendedSessionIdsByRegistration;
    private computeProgramEligibleBreakdown;
    getProgramEligibleKpis(programId: number, rmContactId?: number): Promise<ProgramEligibleKpis>;
    private resolveProgramEligibleKpiFilterIds;
    private toProgramEligibleRow;
    private buildSessionAttendance;
    private resolveSessionState;
    findProfileByRegistrationId(registrationId: number): Promise<ZoomRegistrationProfile | null>;
    listAllRmContacts(): Promise<RmContactOption[]>;
    listEligibleRegistrationsByProgram(programId: number, options: {
        page: number;
        limit: number;
        search?: string;
    }, onlineSessionId?: number, rmContactId?: number): Promise<{
        data: RegistrationWithJoinUrl[];
        total: number;
    }>;
    findEligibleRegistrationRowsByProgram(programId: number, search?: string, onlineSessionId?: number, rmContactId?: number): Promise<RegistrationWithJoinUrl[]>;
    private eligibleRowsBaseQuery;
    getEligibleActivationSummary(onlineSessionId: number): Promise<EligibleActivationSummary>;
    getEligibleActivationSummaries(sessions: {
        onlineSessionId: number;
        programId: number;
    }[], rmContactId?: number): Promise<Map<number, number>>;
    updateActivationStatus(extensionId: number, updates: {
        activationStatus: RegistrationOnlineSessionActivationStatus;
        activationSource: RegistrationOnlineSessionActivationSource;
        joinUrl: string | null;
        externalRegistrantId?: string | null;
        activationChangedBy: number | null;
        activationReason: string | null;
    }, manager: EntityManager): Promise<void>;
    adjustEligibleActiveCount(onlineSessionId: number, delta: 1 | -1, manager: EntityManager): Promise<void>;
    updateRegistrationActivationStatus(registrationId: number, activationStatus: RegistrationOnlineSessionActivationStatus, manager: EntityManager): Promise<void>;
    createBulkJob(data: Partial<BackgroundJob>): Promise<BackgroundJob>;
    findBulkJobById(id: number): Promise<BackgroundJob | null>;
    findBulkJobsByProgram(programId: number): Promise<BackgroundJob[]>;
    findActiveExtensionKeys(registrationIds: number[], onlineSessionIds: number[]): Promise<Set<string>>;
    findInactiveExtensionKeys(registrationIds: number[], onlineSessionIds: number[]): Promise<Set<string>>;
    findActiveExtensionJoinUrls(registrationIds: number[], onlineSessionId: number): Promise<Map<string, {
        joinUrl: string | null;
        activationStatus: RegistrationOnlineSessionActivationStatus | null;
        activationSource: RegistrationOnlineSessionActivationSource | null;
    }>>;
    findProfileImagesByIds(registrationIds: number[]): Promise<Map<string, string | null>>;
    findActivationStatusesByIds(registrationIds: number[]): Promise<Map<string, RegistrationOnlineSessionActivationStatus | null>>;
    findRmContactsByIds(registrationIds: number[]): Promise<Map<string, string | null>>;
    findExtensionSnapshots(pairs: {
        registrationId: number;
        onlineSessionId: number;
    }[]): Promise<Map<string, {
        joinUrl: string | null;
        activationStatus: RegistrationOnlineSessionActivationStatus | null;
    }>>;
    updateBulkJob(id: number, updates: Partial<BackgroundJob>): Promise<void>;
    updateBulkJobStatus(id: number, status: ExportJobStatus, extra?: Partial<BackgroundJob>): Promise<void>;
    findZoomExtension(registrationId: number, onlineSessionId: number, manager?: EntityManager): Promise<ProgramRegistrationOnlineSession | null>;
    findProvisionedExtensionsFromSession(registrationId: number, programId: number, fromStartsAt: Date): Promise<{
        extension: ProgramRegistrationOnlineSession;
        session: ProgramSession;
    }[]>;
    hasLiveSessionForProgram(programId: number, now: Date): Promise<boolean>;
    findExtensionByRegistrationAndExternalId(registrationId: number, externalId: string, manager?: EntityManager): Promise<ProgramRegistrationOnlineSession | null>;
    findExtensionsByRegistrationAndExternalId(registrationId: number, externalId: string, manager?: EntityManager): Promise<ProgramRegistrationOnlineSession[]>;
    createZoomExtension(data: Partial<ProgramRegistrationOnlineSession>, manager?: EntityManager): Promise<ProgramRegistrationOnlineSession>;
    recordExtensionFailure(data: {
        registrationId: number;
        onlineSessionId: number;
        provider?: SessionProviderType | null;
        reason: string;
        message?: string | null;
        actorUserId?: number;
    }, manager?: EntityManager): Promise<void>;
    saveZoomExtension(entity: ProgramRegistrationOnlineSession, manager?: EntityManager): Promise<ProgramRegistrationOnlineSession>;
    softDeleteZoomExtension(entity: ProgramRegistrationOnlineSession, manager?: EntityManager): Promise<void>;
    listRegisteredExtensionsForSession(onlineSessionId: number, rmContactId?: number): Promise<{
        registration: ProgramRegistration;
        extension: ProgramRegistrationOnlineSession;
    }[]>;
}