import { z } from 'zod';
import { ComputerAppSchema, ComputerWindowSchema } from '@xopcai/computer-control-contract';
import type { EndpointToolRuntime } from '../endpoint-tools/runtime.js';
import type { Config } from '../config/schema.js';
import { type ComputerServiceLimits } from './model-policy.js';
import { ComputerDiagnosticSchema } from './errors.js';
import { type ComputerVerification } from './task-state.js';
declare const Reply: z.ZodObject<{
    status: z.ZodEnum<{
        ready: "ready";
        running: "running";
        paused: "paused";
        stopped: "stopped";
        pending_authorization: "pending_authorization";
        pending_action: "pending_action";
    }>;
    sessionId: z.ZodString;
    brokerEpoch: z.ZodString;
    generation: z.ZodNumber;
    grantId: z.ZodOptional<z.ZodString>;
    observation: z.ZodOptional<z.ZodObject<{
        id: z.ZodString;
        sessionId: z.ZodString;
        brokerEpoch: z.ZodString;
        generation: z.ZodNumber;
        target: z.ZodObject<{
            appId: z.ZodString;
            pid: z.ZodNumber;
            processIdentity: z.ZodString;
            windowId: z.ZodString;
            width: z.ZodNumber;
            height: z.ZodNumber;
            geometryRevision: z.ZodString;
        }, z.core.$strict>;
        capturedAt: z.ZodNumber;
        imageWidth: z.ZodNumber;
        imageHeight: z.ZodNumber;
        summary: z.ZodString;
        focusedEditableRef: z.ZodOptional<z.ZodString>;
        stateDigest: z.ZodString;
    }, z.core.$strict>>;
    errorCode: z.ZodOptional<z.ZodString>;
    diagnostic: z.ZodOptional<z.ZodObject<{
        errorCode: z.ZodString;
        phase: z.ZodEnum<{
            observe: "observe";
            model: "model";
            dispatch: "dispatch";
            frame_upload: "frame_upload";
        }>;
        diagnosticId: z.ZodUUID;
        validationReason: z.ZodOptional<z.ZodEnum<{
            invalid_json: "invalid_json";
            invalid_arguments: "invalid_arguments";
            missing_call: "missing_call";
            multiple_calls: "multiple_calls";
            invalid_envelope: "invalid_envelope";
            output_limit: "output_limit";
        }>>;
        httpStatus: z.ZodOptional<z.ZodNumber>;
        requestId: z.ZodOptional<z.ZodString>;
        serviceErrorCode: z.ZodOptional<z.ZodEnum<{
            provider_error: "provider_error";
            max_input_tokens_exceeded: "max_input_tokens_exceeded";
            max_tokens_exceeded: "max_tokens_exceeded";
            model_capability_unsupported: "model_capability_unsupported";
            unsupported_request_field: "unsupported_request_field";
            invalid_image: "invalid_image";
            request_too_large: "request_too_large";
            invalid_request: "invalid_request";
            free_pool_unavailable: "free_pool_unavailable";
        }>>;
    }, z.core.$strict>>;
    apps: z.ZodOptional<z.ZodArray<z.ZodObject<{
        appRef: z.ZodString;
        name: z.ZodString;
        running: z.ZodBoolean;
    }, z.core.$strict>>>;
    windows: z.ZodOptional<z.ZodArray<z.ZodObject<{
        windowRef: z.ZodString;
        title: z.ZodString;
        visible: z.ZodBoolean;
    }, z.core.$strict>>>;
    receipt: z.ZodOptional<z.ZodObject<{
        actionId: z.ZodString;
        dispatch: z.ZodEnum<{
            unknown: "unknown";
            completed: "completed";
            started: "started";
            notStarted: "notStarted";
        }>;
        outcome: z.ZodEnum<{
            unknown: "unknown";
            applied: "applied";
            notApplied: "notApplied";
        }>;
        verification: z.ZodEnum<{
            artifact: "artifact";
            none: "none";
            semantic: "semantic";
            visual: "visual";
        }>;
        errorCode: z.ZodOptional<z.ZodString>;
    }, z.core.$strip>>;
}, z.core.$strict>;
export declare const ComputerUseInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
    op: z.ZodLiteral<"discover">;
    query: z.ZodString;
}, z.core.$strict>, z.ZodObject<{
    op: z.ZodLiteral<"open">;
    appRef: z.ZodString;
    windowRef: z.ZodOptional<z.ZodString>;
    mode: z.ZodEnum<{
        observe: "observe";
        control: "control";
    }>;
    prepare: z.ZodBoolean;
}, z.core.$strict>, z.ZodObject<{
    op: z.ZodLiteral<"observe">;
    question: z.ZodOptional<z.ZodString>;
    expect: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
        kind: z.ZodLiteral<"text">;
        text: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"field">;
        label: z.ZodString;
        value: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"selected">;
        label: z.ZodString;
    }, z.core.$strict>], "kind">>;
}, z.core.$strict>, z.ZodObject<{
    op: z.ZodLiteral<"step">;
    goal: z.ZodString;
    expect: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
        kind: z.ZodLiteral<"text">;
        text: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"field">;
        label: z.ZodString;
        value: z.ZodString;
    }, z.core.$strict>, z.ZodObject<{
        kind: z.ZodLiteral<"selected">;
        label: z.ZodString;
    }, z.core.$strict>], "kind">>;
}, z.core.$strict>, z.ZodObject<{
    op: z.ZodLiteral<"close">;
}, z.core.$strict>], "op">;
export type ComputerUseInput = z.infer<typeof ComputerUseInputSchema>;
export interface ComputerPublicResult {
    status: string;
    sessionId: string;
    pending?: boolean;
    summary?: string;
    receipt?: z.infer<typeof Reply>['receipt'];
    claimedSuccess?: boolean;
    verified?: boolean;
    verification?: ComputerVerification;
    budget?: {
        actionsRemaining: number;
        modelRequestsRemaining: number;
        expiresAt: number;
        serviceLimits?: ComputerServiceLimits;
    };
    handoff?: {
        recentActions: Array<{
            goal: string;
            action: string;
            dispatch: string;
            outcome: string;
            verification?: ComputerVerification;
        }>;
    };
    observation?: {
        id: string;
        width: number;
        height: number;
    };
    errorCode?: string;
    diagnostic?: z.infer<typeof ComputerDiagnosticSchema>;
    nextAction?: string;
    apps?: z.infer<typeof ComputerAppSchema>[];
    windows?: z.infer<typeof ComputerWindowSchema>[];
}
export declare class ComputerRuntime {
    private readonly endpoints;
    private readonly getConfig;
    private readonly getTurnEndpoint?;
    private readonly sessions;
    private readonly operations;
    constructor(endpoints: EndpointToolRuntime, getConfig: () => Config, getTurnEndpoint?: (owner: string) => string | undefined);
    execute(owner: string, input: ComputerUseInput, signal?: AbortSignal): Promise<ComputerPublicResult>;
    private executeInput;
    private dispatchAction;
    private budget;
    private present;
    private resolveEndpoint;
    private send;
    private forget;
    close(owner: string): Promise<boolean>;
    shutdown(): Promise<void>;
}
export {};