import type { ManagedActor, ReadinessSignal, ReadyState } from './ManagedActor.ts';
export type ActorSupervisorState = 'failed' | 'idle' | 'started' | 'starting' | 'stopped' | 'stopping';
export declare class ActorRegistrationError extends Error {
    constructor(message: string);
}
export declare class ActorSupervisorStateError extends Error {
    readonly state: ActorSupervisorState;
    constructor(operation: string, state: ActorSupervisorState);
}
export declare class ActorStartupError extends Error {
    readonly actorName: string;
    readonly rollbackErrors: readonly Error[];
    constructor(actorName: string, cause: unknown, rollbackErrors: readonly Error[]);
}
export declare class ActorReadinessError extends Error {
    readonly actorName: string;
    constructor(actorName: string, cause: unknown);
}
export declare class ActorReadinessTimeoutError extends Error {
    readonly timeoutMs: number;
    constructor(timeoutMs: number);
}
export declare class ActorShutdownError extends AggregateError {
    constructor(errors: readonly Error[]);
}
/**
 * Instance-scoped coordinator for structural managed actors.
 *
 * Startup and readiness follow registration order. Rollback and ordinary shutdown
 * follow reverse startup order. A supervisor is single-use after it has stopped or
 * failed; construct a new instance for a new lifecycle.
 */
export declare class ActorSupervisor implements ReadinessSignal {
    private readonly _actorNames;
    private readonly _actors;
    private _readyError?;
    private _startPromise?;
    private readonly _startedActors;
    private _state;
    private _stopPromise?;
    constructor(actors?: readonly ManagedActor[]);
    get actors(): readonly ManagedActor[];
    get readyError(): Error | undefined;
    get readyState(): ReadyState;
    get state(): ActorSupervisorState;
    isReady(): boolean;
    register(actor: ManagedActor): void;
    start(): Promise<void>;
    stop(): Promise<void>;
    whenReady(timeoutMs?: number): Promise<void>;
    private startActors;
    private stopActors;
    private stopStartedActors;
}
//# sourceMappingURL=ActorSupervisor.d.ts.map