import { z } from 'zod';
import type { AiUsageContext } from '../usage/types.js';
import { type SceneActivation, type ScenePermission, type SceneTemplate } from './contracts.js';
import { SceneRepository } from './repository.js';
import { SceneCapabilityRegistry } from './registry.js';
export declare const readOnlyResultSchema: z.ZodObject<{
    kind: z.ZodEnum<{
        artifact: "artifact";
        decision: "decision";
        observation: "observation";
        no_change: "no_change";
    }>;
    summary: z.ZodString;
    evidenceIds: z.ZodArray<z.ZodString>;
}, z.core.$strict>;
export type ReadOnlySceneResult = z.infer<typeof readOnlyResultSchema>;
export interface SceneEvidence {
    id: string;
    subjectId: string;
    ownerId: string;
    workspaceId: string;
    accountId?: string;
    projectId?: string;
    conversationId?: string;
    revision: string;
    occurredAt?: number;
    freshUntil: number;
    content: string;
}
export interface SceneContextProvider {
    id: string;
    setupIssues?(activation: SceneActivation): string[];
    authorization?(activation: SceneActivation): string[] | null;
    tracksHealth?: boolean;
    requiresAccountIdentity?: boolean;
    read(input: {
        activation: SceneActivation;
        subjectId: string;
        permissions: ScenePermission;
        notBefore?: number;
        signal: AbortSignal;
    }): Promise<SceneEvidence[]>;
}
export interface SceneReadOnlyExecutor {
    execute(input: {
        template: SceneTemplate;
        goal: string;
        evidence: SceneEvidence[];
        signal: AbortSignal;
        usage: AiUsageContext;
    }): Promise<unknown>;
}
/** Runs one durable claim without exposing messaging, filesystem or write tools. */
export declare class SceneExecutionService {
    private readonly repository;
    private readonly providers;
    private readonly executor;
    private readonly authorize;
    private readonly clock;
    constructor(repository: SceneRepository, providers: SceneCapabilityRegistry<SceneContextProvider>, executor: SceneReadOnlyExecutor, authorize: (activation: SceneActivation) => Promise<ScenePermission>, clock?: () => number);
    runNext(worker: string, outerSignal?: AbortSignal): Promise<'idle' | 'completed' | 'discarded' | 'failed' | 'deferred'>;
}