import { type RoadmapDefinition, type RoadmapSprint } from '../core/index.js';
import type { ResolvedActor } from './actor.js';
import { type SprintState } from './sprint-state.js';
export type SprintRolloverIssueCode = 'state_missing' | 'from_state_mismatch' | 'from_roadmap_missing' | 'from_roadmap_ambiguous' | 'target_roadmap_missing' | 'target_roadmap_ambiguous' | 'target_not_later' | 'target_not_pending' | 'from_not_terminal' | 'force_reason_required' | 'reason_without_force' | 'target_dependency_blocked' | 'no_eligible_successor' | 'target_not_next_eligible';
export interface SprintRolloverIssue {
    code: SprintRolloverIssueCode;
    message: string;
}
export interface SprintRolloverAssessment {
    valid: boolean;
    from: number;
    to: number;
    from_label: string;
    to_label: string;
    from_terminal: boolean;
    forced: boolean;
    reason?: string;
    expected_next?: number;
    expected_next_label?: string;
    blocking_dependencies: number[];
    blocking_dependency_labels: string[];
    completion_evidence: {
        roadmap_complete: number[];
        scorecards: number[];
        local_terminal: number[];
    };
    issues: SprintRolloverIssue[];
    roadmap: RoadmapDefinition;
    roadmap_path: string;
    roadmap_sha256: string;
    from_sprint?: RoadmapSprint;
    to_sprint?: RoadmapSprint;
}
export interface SprintRolloverScorecardEvidence {
    sprint: number;
    path: string;
    sha256: string;
}
export interface SprintRolloverInput {
    from: number;
    to: number;
    force?: boolean;
    reason?: string;
}
export interface SprintRolloverAuditRecord {
    version: 1;
    kind: 'sprint_rollover';
    transition_id: string;
    from_sprint: number;
    to_sprint: number;
    from_label: string;
    to_label: string;
    recorded_at: string;
    actor: {
        name: string;
        source: string;
    };
    request: {
        from: number;
        to: number;
        force: boolean;
        reason?: string;
    };
    forced: boolean;
    reason?: string;
    eligibility: {
        from_terminal: boolean;
        target_dependency_eligible: boolean;
        blocking_dependencies: number[];
        target_dependencies: number[];
        completion_evidence: SprintRolloverAssessment['completion_evidence'];
        scorecard_artifacts: SprintRolloverScorecardEvidence[];
        /** Absent when no pending successor exists — e.g. an explicit rollover into
         *  the last sprint of a phase that closeout already marked complete. */
        expected_next?: number;
    };
    roadmap: {
        path: string;
        sha256: string;
        from_status?: string;
        to_status?: string;
    };
    prior_state_sha256: string;
    prior_state: SprintState;
    next_state: SprintState;
    claims_policy: 'unchanged';
    sessions_policy: 'unchanged';
}
export interface SprintRolloverResult {
    audit_path: string;
    record: SprintRolloverAuditRecord;
    state: SprintState;
    already_applied: boolean;
}
export declare class SprintRolloverError extends Error {
    readonly assessment?: SprintRolloverAssessment | undefined;
    constructor(message: string, assessment?: SprintRolloverAssessment | undefined);
}
/**
 * Hash a tracked text file's content with line endings normalized to LF.
 *
 * Raw-byte hashing made every rollover audit single-use on Windows: with
 * `core.autocrlf` any checkout, merge or branch switch renormalizes tracked text
 * to CRLF, changing the bytes without changing the content, so verification
 * reported "scorecard evidence changed" for a file nobody had touched — and the
 * lifecycle could not advance (GH #649). Normalizing matches what git stores, so
 * the digest is reproducible across platforms and checkouts.
 */
export declare function hashTrackedContent(content: Buffer | string): string;
/** True when a digest matches, accepting legacy raw-byte digests written before
 *  normalization so existing audits keep verifying. */
export declare function trackedContentMatches(content: Buffer, expected: string): boolean;
export declare function assessSprintRollover(state: SprintState | null, roadmap: RoadmapDefinition, roadmapPath: string, input: SprintRolloverInput, completionEvidence?: number[], roadmapSha256?: string): SprintRolloverAssessment;
export declare function inspectSprintRollover(cwd: string, input: SprintRolloverInput): SprintRolloverAssessment;
export declare function verifySprintRolloverLineage(cwd: string, state: SprintState): SprintRolloverAuditRecord | null;
export declare function performSprintRollover(cwd: string, input: SprintRolloverInput, actor: ResolvedActor): SprintRolloverResult;
//# sourceMappingURL=sprint-rollover.d.ts.map