import type { EffectLifecycleObserver } from "../effect-lifecycle.js";
import type { EffectCost } from "../ledger.js";
export declare const CAPABILITY_GUARD: unique symbol;
export declare function validCapabilityId(value: string): boolean;
export interface CapabilityUseEvent {
    readonly capability: string;
    readonly method: string;
    readonly path: string;
}
/** Token-only metadata supplied to an asynchronous capability admission interceptor. */
export interface CapabilityInterceptorEvent extends CapabilityUseEvent {
    readonly effectId: string;
    readonly signal: AbortSignal;
    readonly target?: string;
    readonly cost?: EffectCost;
    readonly digest?: string;
}
/** Server-owned identity binding for durable admission. Values are opaque tokens, never payloads. */
export interface CapabilityExecutionIdentity {
    readonly tenantId: string;
    readonly principalId: string;
}
export interface CapabilityApprovalInput extends CapabilityExecutionIdentity {
    /** Signed token returned by the approval coordinator after the first suspended attempt. */
    readonly resumeToken?: string;
}
export interface CapabilityApprovalGate {
    authorize(input: {
        readonly effectId: string;
        readonly capability: string;
        readonly target?: string;
        readonly digest?: string;
        readonly identity: CapabilityExecutionIdentity;
        readonly resumeToken?: string;
        readonly signal: AbortSignal;
    }): void | PromiseLike<void>;
}
/** Durable, token-only journal seam. Implementations must fail closed on transition failure. */
export interface CapabilityExecutionJournal {
    intent(input: {
        readonly effectId: string;
        readonly capability: string;
        readonly target?: string;
        readonly digest?: string;
        readonly identity?: CapabilityExecutionIdentity;
    }): void | PromiseLike<void>;
    executing(effectId: string): void | PromiseLike<void>;
    committed(effectId: string): void | PromiseLike<void>;
    failed(effectId: string, input: {
        readonly began: boolean;
        readonly errorCode: string;
    }): void | PromiseLike<void>;
}
/** Continue to the next admission policy. The owned effect runs only after the full chain admits. */
export type CapabilityInterceptorNext = () => Promise<void>;
export type CapabilityInterceptor = (event: CapabilityInterceptorEvent, next: CapabilityInterceptorNext) => void | PromiseLike<void>;
export interface AroundCapabilityOptions {
    /** Maximum admission time in milliseconds. Default 30_000. */
    readonly timeoutMs?: number;
}
export interface RegisteredCapabilityInterceptor {
    readonly interceptor: CapabilityInterceptor;
    readonly timeoutMs: number;
}
export declare const DEFAULT_CAPABILITY_INTERCEPTOR_TIMEOUT_MS = 30000;
export interface CapabilityGuard {
    readonly allowed: readonly string[];
    readonly method: string;
    readonly path: string;
    readonly onUse?: (event: CapabilityUseEvent) => void;
    readonly trackEffect?: (context: object, committed: boolean) => void;
    readonly interceptors: readonly RegisteredCapabilityInterceptor[];
    readonly observers: readonly EffectLifecycleObserver[];
}
export declare function normalizeRouteCapabilities(values: readonly string[] | undefined): readonly string[];
export declare function createCapabilityGuard(allowed: readonly string[], method: string, path: string, onUse: ((event: CapabilityUseEvent) => void) | undefined, trackEffect: ((context: object, committed: boolean) => void) | undefined, interceptors: readonly RegisteredCapabilityInterceptor[], observers: readonly EffectLifecycleObserver[]): CapabilityGuard;
//# sourceMappingURL=capability-runtime.d.ts.map