import type { AgentIdentity, AgentRouter, AgentSession, AgentSessionStatus, AgentSessionStore, ArtifactStore, BackgroundAgentPlatformConfig, CapabilityBroker, CapabilityGrant, ExecutionEnvironment, ExecutionEnvironmentProvider, IdentityProvider, OutputArtifact, ReviewDecisionRecord, ReviewGate, RouteDecision, SubmitTaskInput, TaskSpec, WaitForSessionOptions, AgentTrigger } from "./types.js";
import { type PlatformAuditSummary, type PlatformAuditSummaryOptions, type PlatformHealthSnapshot, type PlatformHealthSnapshotOptions } from "./observability.js";
export declare function validateTaskSpec(task: TaskSpec): void;
export declare class StaticAgentRouter implements AgentRouter {
    private readonly decision;
    constructor(decision: RouteDecision | ((task: TaskSpec, trigger: AgentTrigger) => RouteDecision | Promise<RouteDecision>));
    route(task: TaskSpec, trigger: AgentTrigger): RouteDecision | Promise<RouteDecision>;
}
export declare class InMemoryAgentSessionStore implements AgentSessionStore {
    private readonly sessions;
    create(session: AgentSession): void;
    save(session: AgentSession): void;
    get(sessionId: string): AgentSession | null;
    list(filter?: {
        status?: AgentSessionStatus;
    }): AgentSession[];
}
export declare class InMemoryArtifactStore implements ArtifactStore {
    private readonly artifacts;
    put(artifact: OutputArtifact): void;
    list(sessionId: string): OutputArtifact[];
}
export declare class InMemoryExecutionEnvironmentProvider implements ExecutionEnvironmentProvider {
    private readonly options;
    private readonly environments;
    constructor(options?: {
        provider?: string;
        workspaceRoot?: string;
        image?: string;
        clock?: () => Date;
        idFactory?: (prefix: string) => string;
    });
    provision(request: {
        sessionId: string;
        route: RouteDecision;
    }): ExecutionEnvironment;
    release(environment: ExecutionEnvironment, _reason: string): void;
    get(environmentId: string): ExecutionEnvironment | null;
}
export declare class StaticIdentityProvider implements IdentityProvider {
    private readonly options;
    private readonly identities;
    constructor(options?: {
        subjectPrefix?: string;
        defaultScopes?: string[];
        clock?: () => Date;
        idFactory?: (prefix: string) => string;
    });
    issueIdentity(request: {
        sessionId: string;
        task: TaskSpec;
        trigger: AgentTrigger;
        route: RouteDecision;
    }): AgentIdentity;
    revokeIdentity(identity: AgentIdentity, _reason: string): void;
    get(identityId: string): AgentIdentity | null;
}
export declare class InMemoryCapabilityBroker implements CapabilityBroker {
    private readonly options;
    private readonly grants;
    constructor(options?: {
        clock?: () => Date;
        idFactory?: (prefix: string) => string;
    });
    grant(request: {
        sessionId: string;
        task: TaskSpec;
        route: RouteDecision;
        identity: AgentIdentity;
    }): CapabilityGrant;
    revoke(grant: CapabilityGrant, _reason: string): void;
    assertAllowed(grant: CapabilityGrant, capabilityName: string): void;
    get(grantId: string): CapabilityGrant | null;
}
export declare class InMemoryReviewGate implements ReviewGate {
    private readonly options;
    private readonly decisions;
    constructor(options?: {
        autoDecision?: Exclude<ReviewDecisionRecord["status"], "pending">;
        reviewer?: string;
        clock?: () => Date;
        idFactory?: (prefix: string) => string;
    });
    requestReview(request: {
        sessionId: string;
    }): ReviewDecisionRecord;
    submitReview(sessionId: string, decision: Omit<ReviewDecisionRecord, "id" | "sessionId" | "requestedAt">): ReviewDecisionRecord;
    get(sessionId: string): ReviewDecisionRecord | null;
}
export declare class BackgroundAgentPlatform {
    private readonly router;
    private readonly runner;
    private readonly environmentProvider;
    private readonly identityProvider;
    private readonly capabilityBroker;
    private readonly artifactStore;
    private readonly reviewGate;
    private readonly sessionStore;
    private readonly capacity;
    private readonly logger?;
    private readonly tracer?;
    private readonly clock;
    private readonly idFactory;
    private readonly queue;
    private readonly active;
    private readonly waiters;
    private readonly controllers;
    constructor(config: BackgroundAgentPlatformConfig);
    submitTask(input: SubmitTaskInput): Promise<AgentSession>;
    runTask(input: SubmitTaskInput, waitOptions?: WaitForSessionOptions): Promise<AgentSession>;
    getSession(sessionId: string): Promise<AgentSession | null>;
    listSessions(filter?: {
        status?: AgentSessionStatus;
    }): Promise<AgentSession[]>;
    getHealthSnapshot(options?: PlatformHealthSnapshotOptions): Promise<PlatformHealthSnapshot>;
    getAuditSummary(options?: PlatformAuditSummaryOptions): Promise<PlatformAuditSummary>;
    private log;
    private startSpan;
    private instrument;
    waitForSession(sessionId: string, options?: WaitForSessionOptions): Promise<AgentSession>;
    cancelSession(sessionId: string, reason?: string): Promise<AgentSession>;
    submitReview(sessionId: string, decision: Omit<ReviewDecisionRecord, "id" | "sessionId" | "requestedAt">): Promise<AgentSession>;
    private dispatch;
    private executeSession;
    private applyOutcome;
    private requestReview;
    private releaseRuntimeResources;
    private normalizeArtifact;
    private resolveTimeout;
    private appendAudit;
    private touch;
    private saveAndNotify;
    private mustGetSession;
    private notifyWaiters;
    private removeWaiter;
}
//# sourceMappingURL=in-memory.d.ts.map