export declare const BULK_CANDIDATE_REQUEST_LIMIT = 100;
export interface CandidateRoundPreview {
    id: string;
    roundConfigId: string | null;
    name: string;
    roundType: string;
    emailLogs: ReadonlyArray<{
        emailType: string;
    }>;
}
export interface BulkCandidateTarget {
    id: string;
    jobPostingId: string | null;
    interviewRounds: ReadonlyArray<CandidateRoundPreview>;
}
export interface CandidateTargetPage<TTarget extends {
    id: string;
}> {
    items: ReadonlyArray<TTarget>;
    total: number;
    hasMore: boolean;
}
export type CandidateMaterializationErrorCode = 'STALE_SCOPE' | 'TOTAL_DRIFT' | 'EMPTY_PAGE_WITH_MORE' | 'INVALID_PAGE_LENGTH' | 'UNIQUE_COUNT_MISMATCH' | 'MEMBERSHIP_DRIFT';
export declare class CandidateMaterializationError extends Error {
    readonly code: CandidateMaterializationErrorCode;
    constructor(code: CandidateMaterializationErrorCode, message: string);
}
interface MaterializeCandidateTargetsOptions<TTarget extends {
    id: string;
}> {
    scopeKey: string;
    expectedTotal: number;
    fetchPage: (limit: number, offset: number) => Promise<CandidateTargetPage<TTarget>>;
    getCurrentScopeKey: () => string;
    pageSize?: number;
}
/**
 * Materializes a frozen application-filter scope without trusting cached pages.
 * Two independent passes must return the same ordered target snapshots. This
 * catches offset-page membership shifts while preserving the 100-item page cap.
 */
export declare function materializeCandidateTargets<TTarget extends {
    id: string;
}>({ scopeKey, expectedTotal, fetchPage, getCurrentScopeKey, pageSize, }: MaterializeCandidateTargetsOptions<TTarget>): Promise<TTarget[]>;
interface MaterializeCandidateTargetsByIdsOptions<TTarget extends {
    id: string;
}> {
    scopeKey: string;
    applicationIds: ReadonlyArray<string>;
    fetchChunkPage: (applicationIds: ReadonlyArray<string>, limit: number, offset: number) => Promise<CandidateTargetPage<TTarget>>;
    getCurrentScopeKey: () => string;
}
/**
 * Revalidates selected candidates in bounded ID chunks. Each chunk is filtered
 * by both its IDs and the frozen list filter, so earlier mutations cannot make
 * later validation rescan or reinterpret the full result set.
 */
export declare function materializeCandidateTargetsByIds<TTarget extends {
    id: string;
}>({ scopeKey, applicationIds, fetchChunkPage, getCurrentScopeKey, }: MaterializeCandidateTargetsByIdsOptions<TTarget>): Promise<TTarget[]>;
export interface CandidateSelectionState {
    mode: 'explicit' | 'all';
    explicitIds: ReadonlySet<string>;
    allTargetIds: ReadonlySet<string>;
    excludedIds: ReadonlySet<string>;
}
export declare function createEmptyCandidateSelection(): CandidateSelectionState;
export declare function selectAllMaterializedCandidates(applicationIds: ReadonlyArray<string>): CandidateSelectionState;
export declare function getSelectedCandidateIds(selection: CandidateSelectionState): Set<string>;
export declare function getCandidateSelectionCount(selection: CandidateSelectionState): number;
export declare function toggleCandidateSelection(selection: CandidateSelectionState, applicationId: string): CandidateSelectionState;
export declare function setVisibleCandidateSelection(selection: CandidateSelectionState, visibleApplicationIds: ReadonlyArray<string>, selected: boolean): CandidateSelectionState;
export declare function getCandidateSelectionSummary(selection: CandidateSelectionState): string | null;
export interface ExactRoundPair {
    applicationId: string;
    roundId: string;
    target: BulkCandidateTarget;
    round: CandidateRoundPreview;
}
export interface UnresolvedCandidateRound {
    target: BulkCandidateTarget;
    reason: 'MISSING' | 'AMBIGUOUS';
}
export interface ExactRoundResolution {
    pairs: ExactRoundPair[];
    unresolved: UnresolvedCandidateRound[];
}
/** Resolve only concrete rounds with the requested config ID; never guess by name or type. */
export declare function resolveExactCandidateRounds(targets: ReadonlyArray<BulkCandidateTarget>, roundConfigId: string): ExactRoundResolution;
export declare class CandidateChunkPreconditionError extends Error {
    constructor(message: string);
}
export declare function assertCandidateChunkMatchesCurrentScope(applicationIds: ReadonlyArray<string>, currentTargets: ReadonlyArray<BulkCandidateTarget>, jobPostingId: string): void;
export declare function assertCandidateEmailChunkMatchesCurrentScope(items: ReadonlyArray<{
    applicationId: string;
    roundId: string;
}>, currentTargets: ReadonlyArray<BulkCandidateTarget>, jobPostingId: string, roundConfigId: string): void;
export declare function chunkCandidateRequests<T>(items: ReadonlyArray<T>, chunkSize?: number): T[][];
export interface SequentialExecutionProgress {
    processed: number;
    total: number;
}
export interface SequentialExecutionResult<TItem, TAggregate> {
    aggregate: TAggregate;
    processedItems: TItem[];
    ambiguousItems: TItem[];
    notStartedItems: TItem[];
    error: unknown | null;
}
interface ExecuteSequentialCandidateChunksOptions<TItem, TBatchResult, TAggregate> {
    items: ReadonlyArray<TItem>;
    initialAggregate: TAggregate;
    executeChunk: (chunk: ReadonlyArray<TItem>, chunkIndex: number) => Promise<TBatchResult>;
    mergeResult: (aggregate: TAggregate, result: TBatchResult) => TAggregate;
    onProgress?: (progress: SequentialExecutionProgress) => void;
    chunkSize?: number;
}
/**
 * Executes each request once and in order. A thrown transport/missing-data error
 * makes the current chunk ambiguous and prevents every later chunk from starting.
 */
export declare function executeSequentialCandidateChunks<TItem, TBatchResult, TAggregate>({ items, initialAggregate, executeChunk, mergeResult, onProgress, chunkSize, }: ExecuteSequentialCandidateChunksOptions<TItem, TBatchResult, TAggregate>): Promise<SequentialExecutionResult<TItem, TAggregate>>;
export type BulkOperationNotificationSeverity = 'success' | 'warning' | 'error';
export declare function getBulkOperationNotificationSeverity({ succeeded, skipped, failed, ambiguous, }: {
    succeeded: number;
    skipped: number;
    failed: number;
    ambiguous?: boolean;
}): BulkOperationNotificationSeverity;
export interface CandidateEmailSuccess {
    applicationId: string;
    roundId: string;
}
export interface CandidateEmailSkip {
    applicationId: string;
    roundId: string;
    reason: string;
    message: string;
}
export interface CandidateEmailFailure {
    applicationId: string;
    roundId: string;
    message: string;
}
export interface CandidateEmailAggregate {
    succeeded: CandidateEmailSuccess[];
    skipped: CandidateEmailSkip[];
    failed: CandidateEmailFailure[];
}
export declare function createEmptyCandidateEmailAggregate(): CandidateEmailAggregate;
export declare function assertCompleteCandidateEmailChunkResult(requested: ReadonlyArray<{
    applicationId: string;
    roundId: string;
}>, result: CandidateEmailAggregate): void;
export declare function aggregateCandidateEmailResult(aggregate: CandidateEmailAggregate, result: CandidateEmailAggregate): CandidateEmailAggregate;
export interface EnsuredRoundSummary {
    id: string;
    applicationId: string;
}
export interface EnsureRoundFailure {
    applicationId: string;
    code: string;
    message: string;
}
export interface EnsureRoundAggregate {
    created: EnsuredRoundSummary[];
    alreadyPresent: EnsuredRoundSummary[];
    failed: EnsureRoundFailure[];
}
export declare function createEmptyEnsureRoundAggregate(): EnsureRoundAggregate;
export declare function assertCompleteEnsureRoundChunkResult(requestedApplicationIds: ReadonlyArray<string>, result: EnsureRoundAggregate): void;
export declare function aggregateEnsureRoundResult(aggregate: EnsureRoundAggregate, result: EnsureRoundAggregate): EnsureRoundAggregate;
export interface BulkCustomEmailSuccess {
    applicationId: string;
    email: string;
}
export interface BulkCustomEmailFailureItem {
    applicationId: string;
    message: string;
}
export interface BulkCustomEmailAggregate {
    succeeded: BulkCustomEmailSuccess[];
    failed: BulkCustomEmailFailureItem[];
}
export declare function createEmptyBulkCustomEmailAggregate(): BulkCustomEmailAggregate;
export declare function assertCompleteBulkCustomEmailChunkResult(requestedApplicationIds: ReadonlyArray<string>, result: BulkCustomEmailAggregate): void;
export declare function aggregateBulkCustomEmailResult(aggregate: BulkCustomEmailAggregate, result: BulkCustomEmailAggregate): BulkCustomEmailAggregate;
export interface BulkStatusUpdateSuccess {
    applicationId: string;
    status: string;
}
export interface BulkStatusUpdateFailureItem {
    applicationId: string;
    message: string;
}
export interface BulkStatusUpdateAggregate {
    succeeded: BulkStatusUpdateSuccess[];
    failed: BulkStatusUpdateFailureItem[];
}
export declare function createEmptyBulkStatusUpdateAggregate(): BulkStatusUpdateAggregate;
export declare function assertCompleteBulkStatusUpdateChunkResult(requestedApplicationIds: ReadonlyArray<string>, result: BulkStatusUpdateAggregate): void;
export declare function aggregateBulkStatusUpdateResult(aggregate: BulkStatusUpdateAggregate, result: BulkStatusUpdateAggregate): BulkStatusUpdateAggregate;
export declare function hasCandidateEmailType(round: CandidateRoundPreview, emailType: string): boolean;
export interface DuplicateNoticeSuccess {
    email: string;
}
export interface DuplicateNoticeSkip {
    email: string;
    reason: string;
    message: string;
}
export interface DuplicateNoticeFailure {
    email: string;
    message: string;
}
export interface DuplicateNoticeAggregate {
    succeeded: DuplicateNoticeSuccess[];
    skipped: DuplicateNoticeSkip[];
    failed: DuplicateNoticeFailure[];
}
export declare function createEmptyDuplicateNoticeAggregate(): DuplicateNoticeAggregate;
export declare function aggregateDuplicateNoticeResult(aggregate: DuplicateNoticeAggregate, result: DuplicateNoticeAggregate): DuplicateNoticeAggregate;
export {};