import type { FactoryGithubEventName, FactoryGithubRuleContext, FactoryGitLabEventName, FactoryGitLabRuleContext, FactoryIncidentioEventName, FactoryIncidentioRuleContext, FactoryJiraEventName, FactoryJiraRuleContext, FactoryLinearEventName, FactoryLinearRuleContext, FactoryRuleHandler, FactoryRuleSource, FactoryStageRuleContext, FactoryToolResultRuleContext } from '../rules/types.js';
import type { BoardTransitionPolicy } from './transition-policy.js';
type BoardPhaseHandlers = Partial<Record<FactoryRuleSource, FactoryRuleHandler<FactoryStageRuleContext>>>;
type ReadonlyBoardPhaseHandlers = Readonly<BoardPhaseHandlers>;
/** Runs when an agent seated on this board completes the named tool. */
export type BoardToolResultRuleHandler = FactoryRuleHandler<FactoryToolResultRuleContext>;
export type BoardToolRule = {
    readonly onResult: BoardToolResultRuleHandler;
};
export type BoardToolRules = Readonly<Record<string, BoardToolRule>>;
/**
 * A board's handler for one integration event. `null` switches the integration default off
 * for cards on this board only.
 */
type BoardEventHandlerMap<EventName extends string, Context> = Readonly<Partial<Record<EventName, FactoryRuleHandler<Context> | null>>>;
/**
 * How cards on this board react to integration events, keyed by integration then event.
 * Consulted for events bound to a card on this board, after any handler the deployment set
 * explicitly on the integration and before the integration default.
 */
export interface BoardEventRules {
    readonly github?: BoardEventHandlerMap<FactoryGithubEventName, FactoryGithubRuleContext>;
    readonly gitlab?: BoardEventHandlerMap<FactoryGitLabEventName, FactoryGitLabRuleContext>;
    readonly linear?: BoardEventHandlerMap<FactoryLinearEventName, FactoryLinearRuleContext>;
    readonly jira?: BoardEventHandlerMap<FactoryJiraEventName, FactoryJiraRuleContext>;
    readonly incidentio?: BoardEventHandlerMap<FactoryIncidentioEventName, FactoryIncidentioRuleContext>;
}
export type BoardEventIntegration = keyof BoardEventRules;
type ReadonlyFactoryBoardRules = Readonly<Record<string, Readonly<Partial<Record<FactoryRuleSource, Readonly<{
    onEnter?: FactoryRuleHandler<FactoryStageRuleContext>;
    onExit?: FactoryRuleHandler<FactoryStageRuleContext>;
}>>>>>>;
/**
 * What a phase means to the runtime.
 * - `resting`: nobody is seated; a card waits for a person or an event.
 * - `working`: an agent in `role` carries the card; a person's move in arms autonomy.
 * - `terminal`: the card is finished; sessions stop and held resources are released.
 */
export type BoardPhaseKind = 'resting' | 'working' | 'terminal';
type BoardPhaseBase<PhaseId extends string> = {
    readonly title: string;
    readonly next?: PhaseId;
    readonly outcomes?: Readonly<Record<string, PhaseId>>;
    readonly onEnter?: ReadonlyBoardPhaseHandlers;
    readonly onExit?: ReadonlyBoardPhaseHandlers;
};
export type BoardPhaseDefinition<PhaseId extends string> = (BoardPhaseBase<PhaseId> & {
    readonly kind: 'resting';
    readonly role?: never;
}) | (BoardPhaseBase<PhaseId> & {
    readonly kind: 'working';
    readonly role: string;
}) | (BoardPhaseBase<PhaseId> & {
    readonly kind: 'terminal';
    readonly role?: never;
});
export interface BoardTransition<PhaseId extends string> {
    readonly outcome: string | null;
    readonly to: PhaseId;
}
/**
 * Terminal phases a card moves to when its tracked source (issue or follow-up) closes.
 * `completed` is used when the source was completed, `canceled` when it was canceled or not planned.
 */
export type BoardSourceClosed<PhaseId extends string> = Readonly<{
    completed: PhaseId;
    canceled: PhaseId;
}>;
export interface BoardDefinition<BoardId extends string, PhaseId extends string> {
    readonly id: BoardId;
    readonly title: string;
    readonly initialPhase: PhaseId;
    readonly phases: Readonly<Record<PhaseId, BoardPhaseDefinition<PhaseId>>>;
    readonly transitions: Readonly<Record<PhaseId, readonly BoardTransition<PhaseId>[]>>;
    readonly rules: ReadonlyFactoryBoardRules;
    /** Tool-result rules keyed by tool name; empty when the board declares none. */
    readonly tools: BoardToolRules;
    /** Integration event handlers for cards on this board; empty when the board declares none. */
    readonly events: BoardEventRules;
    readonly transitionPolicy?: BoardTransitionPolicy;
    /** Where source-closed rules move a card; absent when the board opts out of auto-closing. */
    readonly sourceClosed?: BoardSourceClosed<PhaseId>;
    allowsTransition(from: PhaseId, to: PhaseId): boolean;
    /** Declared kind of a phase, or undefined when the board has no such phase. */
    phaseKind(phase: string): BoardPhaseKind | undefined;
    isWorking(phase: string): boolean;
    isTerminal(phase: string): boolean;
    /** Role seated in a working phase; undefined for resting/terminal/unknown phases. */
    roleForPhase(phase: string): string | undefined;
    /** First working phase, in declaration order, carried by `role`. */
    phaseForRole(role: string): PhaseId | undefined;
}
type BoardConfig<BoardId extends string, Phases extends Record<string, BoardPhaseDefinition<keyof Phases & string>>> = {
    id: BoardId;
    title: string;
    initialPhase: keyof Phases & string;
    phases: Phases;
    tools?: Record<string, BoardToolRule>;
    events?: BoardEventRules;
    transitionPolicy?: BoardTransitionPolicy;
    sourceClosed?: {
        completed: keyof Phases & string;
        canceled: keyof Phases & string;
    };
};
export declare class BoardDefinitionError extends Error {
    name: string;
}
export declare function defineBoard<const BoardId extends string, const Phases extends Record<string, BoardPhaseDefinition<keyof Phases & string>>>(config: BoardConfig<BoardId, Phases>): BoardDefinition<BoardId, keyof Phases & string>;
export {};
//# sourceMappingURL=define-board.d.ts.map