TypeScript SDK reference

This reference lists the public TypeScript SDK interfaces, including signatures, resource helpers, and model types, so you can look up how to call the SDK and interpret its results. Start with Getting started with the SDK; see Errors and recovery for connection lifetime, deadlines, and retries.

hypervisor

export declare class Hypervisor extends Client {
    readonly networks: Networks;
    /** The MCP servers every VM runs, from settings and corp config. */
    readonly mcp: Mcp;
    readonly debug: Debug;
    readonly images: Images;
    readonly credentials: Credentials;
    readonly connections: Connections;
    constructor(url?: string, token?: string, options?: TransportOptions);
    info(options?: CallOptions): Promise<models.HypervisorInfo>;
    list(options?: CallOptions): Promise<models.ListResponse>;
    vm(selector: VmSelector): VM;
    create(options?: CreateOptions): Promise<VM>;
    managed(options?: ManagedCreateOptions): Promise<ManagedSession>;
    withManaged<T>(options: ManagedCreateOptions, work: (vm: VM, signal: AbortSignal) => Promise<T>): Promise<T>;
    log(options?: HostLogOptions): Promise<models.HostLogsResponse>;
    run(command: string, options?: RunOptions): Promise<models.ExecResponse>;
    purge(options?: CallOptions & {
        all?: boolean;
    }): Promise<models.PurgeResponse>;
    update(options?: CallOptions): Promise<models.UpdateActionResponse>;
    restart(options?: CallOptions): Promise<models.RestartResponse>;
}

vm

export declare class VM extends Client {
    readonly files: Files;
    readonly networks: VmNetworks;
    readonly stats: Stats;
    readonly container: Container;
    readonly ports: Ports;
    readonly credentialGrants: CredentialGrants;
    constructor(url: string, token: string, selector: VmSelector, options?: TransportOptions);
    get id(): string | undefined;
    get name(): string | undefined;
    info(options?: CallOptions): Promise<models.SandboxInfo>;
    exec(command: string, options?: CallOptions & {
        timeout_secs?: number;
        target?: models.ExecTarget | null;
    }): Promise<models.ExecResponse>;
    start(options?: CallOptions): Promise<models.ProvisionResponse>;
    persist(name: string, options?: CallOptions): Promise<models.PersistResponse>;
    stop(options?: CallOptions): Promise<models.StopResponse>;
    pause(options?: CallOptions): Promise<models.VmActionResponse>;
    resume(options?: CallOptions): Promise<models.ProvisionResponse>;
    delete(options?: CallOptions): Promise<models.VmActionResponse>;
    fork(name: string, options?: CallOptions & {
        description?: string;
        labels?: Record<string, string>;
    }): Promise<VM>;
    log(options?: LogOptions): Promise<models.LogsResponse>;
    history(options?: HistoryOptions): Promise<models.HistoryResponse>;
    timeline(options?: TimelineOptions): Promise<models.TimelineResponse>;
}

managed

/** Finite ownership of one ephemeral VM; ordinary VM.close stays connection-only. */
export declare class ManagedSession {
    get ownership(): models.ManagedSessionOwnership | undefined;
    get vm(): VM;
    /** Aborts when the owner is cancelled, closes, or loses its lease. */
    get signal(): AbortSignal;
    /** Await the original close before returning the callback's result or failure. */
    run<T>(work: (vm: VM, signal: AbortSignal) => Promise<T>): Promise<T>;
    /** Join cleanup; a failed close is retried only by another explicit close call. */
    close(outcome?: models.ManagedSessionOutcome): Promise<void>;
}

options

export type VmSelector = {
    id: string;
    name?: never;
} | {
    name: string;
    id?: never;
};

export interface Registry {
    username?: string;
    password?: string;
    ca_pem?: string;
}

export interface ImageListOptions extends CallOptions {
    refresh?: boolean;
}

export interface ImagePullOptions extends CallOptions {
    registry?: Registry;
}

export interface CreateOptions extends CallOptions {
    name?: string;
    cpus?: number;
    memory?: number;
    env?: Record<string, string>;
    labels?: Record<string, string>;
    networks?: readonly NetworkInfo[];
    image?: string;
    command?: readonly string[];
    registry?: Registry;
}

/** Managed ownership is always unnamed and ephemeral. */
export type ManagedCreateOptions = Omit<CreateOptions, 'name'> & {
    name?: never;
};

export interface RunOptions extends CallOptions {
    timeout_secs?: number;
    cpus?: number;
    memory?: number;
    env?: Record<string, string>;
}

export interface DiagnosticOptions extends CallOptions {
    since?: string;
    limit?: number;
}

export interface TriageOptions extends DiagnosticOptions {
    vm_id?: string;
}

export interface LogOptions extends CallOptions {
    grep?: string;
    tail?: number;
    max_bytes?: number;
}

export interface HostLogOptions extends LogOptions {
    source?: HostLogSource;
}

export interface HistoryOptions extends CallOptions {
    limit?: number;
    offset?: number;
    search?: string;
    layer?: HistoryLayerFilter;
}

export interface TimelineOptions extends CallOptions {
    trace_id?: string;
    since?: string;
    limit?: number;
    layers?: TimelineLayer[];
}

export interface NetworkLogOptions extends CallOptions {
    cursor?: string;
    limit?: number;
    vm?: string;
    connection?: string;
    type?: string;
    decision?: string;
    since?: number;
    until?: number;
}

resources

export interface VmContext {
    transport: Transport;
    id: string;
}

/** Paths are the guest's: `/root/x` in a VM, `/workspace/x` in its container,
 * or `x` relative to the workspace. `exact` takes a path literally, relative to
 * the workspace root, even when it is absolute. */
export type FileOptions = CallOptions & {
    exact?: boolean;
};

export declare class Files extends Resource {
    read(path: string, options?: FileOptions): Promise<Uint8Array>;
    write(path: string, data: Uint8Array, options?: FileOptions): Promise<models.UploadResponse>;
    /** An empty `path` lists the workspace root. */
    list(path?: string, options?: FileOptions & {
        depth?: number;
    }): Promise<models.FileListResponse>;
}

export declare class Stats extends Resource {
    summary(options?: CallOptions): Promise<models.VmStatsSummaryResponse>;
    details(options?: CallOptions): Promise<models.VmStatsDetailResponse>;
}

export declare class Container extends Resource {
    status(options?: CallOptions): Promise<models.ContainerStatusResponse>;
}

export interface Port {
    id: string;
    guest: number;
    host: number | null;
    authenticate: boolean;
    url?: string;
    /** Non-enumerable: never serialized or printed with the port. */
    readonly bootstrapToken?: string;
    expiresInSeconds?: number;
}

export declare class Ports extends Resource {
    constructor(context: (options: CallOptions) => Promise<VmContext>, target: (options: CallOptions) => Promise<models.ExposureTarget>);
    open(guest: number, options?: CallOptions & {
        host?: number;
        authenticate?: boolean;
    }): Promise<Port>;
    list(options?: CallOptions): Promise<Port[]>;
    close(opened: Port, options?: CallOptions): Promise<models.VmActionResponse>;
}

export declare class Networks {
    constructor(transport: Transport);
    create(name: string, options?: CallOptions): Promise<models.NetworkInfo>;
    list(options?: CallOptions): Promise<models.NetworkInfo[]>;
    inspect(networkId: string, options?: CallOptions): Promise<models.NetworkInfo>;
    delete(network: models.NetworkInfo, options?: CallOptions): Promise<models.VmActionResponse>;
    logs(network: models.NetworkInfo, options?: NetworkLogOptions): Promise<models.NetworkLogsResponse>;
}

export declare class VmNetworks extends Resource {
    list(options?: CallOptions): Promise<models.NetworkInfo[]>;
    attach(network: models.NetworkInfo, options?: CallOptions): Promise<models.NetworkInfo>;
    detach(network: models.NetworkInfo, options?: CallOptions): Promise<models.NetworkInfo>;
}

export declare class McpTools {
    constructor(transport: Transport, serverId: string);
    list(options?: CallOptions): Promise<models.McpToolsListResponse>;
    call(name: string, arguments_: models.Value, options?: CallOptions): Promise<models.Value>;
}

export declare class McpServer {
    readonly info: models.McpServerInfoResponse;
    readonly tools: McpTools;
    constructor(transport: Transport, info: models.McpServerInfoResponse);
    refresh(options?: CallOptions): Promise<models.McpRefreshResponse>;
}

/** The MCP servers every VM runs: settings.toml `[mcp]` with corp's laid over it. */
export declare class Mcp {
    constructor(transport: Transport);
    info(options?: CallOptions): Promise<models.McpInfoResponse>;
    servers(options?: CallOptions): Promise<models.McpServersListResponse>;
    defaultPermission(options?: CallOptions): Promise<models.McpDefaultPermissionResponse>;
    get(name: string, options?: CallOptions): Promise<McpServer>;
}

connections

/** Host consent never implicitly grants a VM access or launches a browser. */
export declare class Connections {
    constructor(transport: Transport);
    list(options?: CallOptions & {
        limit?: number;
        cursor?: string;
    }): Promise<models.ConnectionListResponse>;
    /** Retain the request ID; opening the returned URL and polling are explicit. */
    authorizeGoogle(request: models.AuthorizeGoogleRequest, options?: CallOptions): Promise<models.AuthorizeGoogleResponse>;
    authorization(id: string, options?: CallOptions): Promise<models.AuthorizationTransaction>;
    cancelAuthorization(id: string, options?: CallOptions): Promise<models.AuthorizationTransaction>;
    get(id: string, options?: CallOptions): Promise<models.ConnectionSummary>;
    /** Fence grants; poll explicitly to confirm provider retirement. */
    disconnect(id: string, options?: CallOptions): Promise<models.DisconnectResponse>;
}

/** Explicit approvals for the canonical session resolved by this VM handle. */
export declare class CredentialGrants {
    constructor(context: (options: CallOptions) => Promise<VmContext>);
    list(options?: CallOptions): Promise<models.SessionGrantListResponse>;
    /** Never reconnect, acquire consent or replay a mutation implicitly. */
    create(request: models.CreateSessionGrantRequest, options?: CallOptions): Promise<models.SessionGrantSummary>;
    revoke(grant_id: string, options?: CallOptions): Promise<models.RevokeSessionGrantResponse>;
}

credentials

/** Explicit host material; responses contain only opaque references. */
export declare class Credentials {
    constructor(transport: Transport);
    inject(provider: `${CredentialInjectProvider}`, value: string, options?: CallOptions & {
        storage?: `${CredentialStorage}`;
    }): Promise<CredentialInjectResponse>;
}

debug

export declare class Debug {
    constructor(transport: Transport);
    panics(options?: DiagnosticOptions): Promise<models.PanicsResponse>;
    triage(options?: TriageOptions): Promise<models.TriageResponse>;
}

execution

/** Decode one stdout or stderr value to its exact bytes. */
export declare function decodeExecOutput(output: ExecOutput): Uint8Array;

images

/** Catalog and prefetch through the service's image admission policy. */
export declare class Images {
    constructor(transport: Transport);
    list(options?: ImageListOptions): Promise<models.ImageListResponse>;
    pull(image: string, options?: ImagePullOptions): Promise<models.ImagePullResponse>;
}

local-browser

/** Browsers cannot read installed host credentials; callers connect explicitly. */
export declare function localConnection(): [
    string,
    string
];

local-node

export declare function localConnection(): [
    string,
    string
];

registry

/** Preserve the caller's access intent; never turn a non-object into anonymous access. */
export declare function registryAccess(registry: Registry | undefined): Registry | undefined;

stream

export declare const STREAM_SUBPROTOCOL = "capsem.stream.v3";

export declare const MAX_STREAM_FRAME_BYTES: number;

export declare const MAX_STREAM_DATA_BYTES: number;

export type ServerFrame = {
    kind: 'output';
    bytes: Uint8Array;
} | {
    kind: 'status';
    status: StreamStatus;
} | {
    kind: 'invalid';
    reason: string;
};

export declare function encodeStdin(bytes: Uint8Array): Uint8Array;

export declare function encodeControl(value: StreamControl): Uint8Array;

export declare function decodeServerFrame(data: ArrayBuffer | Uint8Array): ServerFrame;

transport

export declare enum Method {
    GET = "GET",
    POST = "POST",
    PUT = "PUT",
    DELETE = "DELETE"
}

export declare enum MediaType {
    JSON = "application/json",
    BINARY = "application/octet-stream",
    GZIP = "application/gzip"
}

export interface CallOptions {
    signal?: AbortSignal | undefined;
    /** Replaces the transport's default deadline for this call. */
    timeoutMs?: number | undefined;
}

export interface TransportOptions {
    timeoutMs?: number;
}

export declare class HttpError extends Error {
    readonly status: number;
    readonly body: string;
    readonly name = "HttpError";
    constructor(status: number, body: string);
    /** Future/non-JSON refusal envelopes retain their HTTP status and raw body. */
    get credentialCode(): CredentialErrorCode | undefined;
}

export declare class NetworkError extends Error {
    readonly name = "NetworkError";
    constructor(cause: unknown);
}

export declare class Transport {
    constructor(url: string, token: string, options?: TransportOptions);
    /** The default per-request deadline, in milliseconds. */
    get timeoutMs(): number;
    close(): void;
    request(method: Method, path: string, options?: RequestOptions): Promise<Uint8Array>;
}

validation/ArchivedEventBody

export declare const ArchivedEventBodySchema: z.ZodType<ArchivedEventBody>;

validation/AssetFileState

export declare const AssetFileStateSchema: z.ZodType<AssetFileState>;

validation/AssetFileStatus

export declare const AssetFileStatusSchema: z.ZodType<AssetFileStatus>;

validation/AssetManifestStatus

export declare const AssetManifestStatusSchema: z.ZodType<AssetManifestStatus>;

validation/AssetStatus

export declare const AssetStatusSchema: z.ZodType<AssetStatus>;

validation/AuditEvent

export declare const AuditEventSchema: z.ZodType<AuditEvent>;

validation/AuditHistoryDetails

export declare const AuditHistoryDetailsSchema: z.ZodType<AuditHistoryDetails>;

validation/AuthorizationTransaction

export declare const AuthorizationTransactionSchema: z.ZodType<AuthorizationTransaction>;

validation/AuthorizeGoogleRequest

export declare const AuthorizeGoogleRequestSchema: z.ZodType<AuthorizeGoogleRequest>;

validation/AuthorizeGoogleResponse

export declare const AuthorizeGoogleResponseSchema: z.ZodType<AuthorizeGoogleResponse>;

validation/BodyEncoding

export declare const BodyEncodingSchema: z.ZodType<BodyEncoding>;

validation/BrowserAcknowledgeRequest

export declare const BrowserAcknowledgeRequestSchema: z.ZodType<BrowserAcknowledgeRequest>;

validation/BrowserAcknowledgeResponse

export declare const BrowserAcknowledgeResponseSchema: z.ZodType<BrowserAcknowledgeResponse>;

validation/BrowserRequest

export declare const BrowserRequestSchema: z.ZodType<BrowserRequest>;

validation/CapabilitySummary

export declare const CapabilitySummarySchema: z.ZodType<CapabilitySummary>;

validation/CapturedContent

export declare const CapturedContentSchema: z.ZodType<CapturedContent>;

validation/CapturedPayload

export declare const CapturedPayloadSchema: z.ZodType<CapturedPayload>;

validation/CaptureStatus

export declare const CaptureStatusSchema: z.ZodType<CaptureStatus>;

validation/CatalogInfo

export declare const CatalogInfoSchema: z.ZodType<CatalogInfo>;

validation/ConnectionListResponse

export declare const ConnectionListResponseSchema: z.ZodType<ConnectionListResponse>;

validation/ConnectionProvider

export declare const ConnectionProviderSchema: z.ZodType<ConnectionProvider>;

validation/ConnectionState

export declare const ConnectionStateSchema: z.ZodType<ConnectionState>;

validation/ConnectionSummary

export declare const ConnectionSummarySchema: z.ZodType<ConnectionSummary>;

validation/ContainerSpec

export declare const ContainerSpecSchema: z.ZodType<ContainerSpec>;

validation/ContainerState

export declare const ContainerStateSchema: z.ZodType<ContainerState>;

validation/ContainerStatusResponse

export declare const ContainerStatusResponseSchema: z.ZodType<ContainerStatusResponse>;

validation/ContainerSurface

export declare const ContainerSurfaceSchema: z.ZodType<ContainerSurface>;

validation/ContainerSurfaceKind

export declare const ContainerSurfaceKindSchema: z.ZodType<ContainerSurfaceKind>;

validation/CostCoverage

export declare const CostCoverageSchema: z.ZodType<CostCoverage>;

validation/CreateNetworkRequest

export declare const CreateNetworkRequestSchema: z.ZodType<CreateNetworkRequest>;

validation/CreateProxyRequest

export declare const CreateProxyRequestSchema: z.ZodType<CreateProxyRequest>;

validation/CreateProxyResponse

export declare const CreateProxyResponseSchema: z.ZodType<CreateProxyResponse>;

validation/CreateSessionGrantRequest

export declare const CreateSessionGrantRequestSchema: z.ZodType<CreateSessionGrantRequest>;

validation/CredentialErrorCode

export declare const CredentialErrorCodeSchema: z.ZodType<CredentialErrorCode>;

validation/CredentialEvent

export declare const CredentialEventSchema: z.ZodType<CredentialEvent>;

validation/CredentialEventType

export declare const CredentialEventTypeSchema: z.ZodType<CredentialEventType>;

validation/CredentialInjectProvider

export declare const CredentialInjectProviderSchema: z.ZodType<CredentialInjectProvider>;

validation/CredentialInjectRequest

export declare const CredentialInjectRequestSchema: z.ZodType<CredentialInjectRequest>;

validation/CredentialInjectResponse

export declare const CredentialInjectResponseSchema: z.ZodType<CredentialInjectResponse>;

validation/CredentialOutcome

export declare const CredentialOutcomeSchema: z.ZodType<CredentialOutcome>;

validation/CredentialStorage

export declare const CredentialStorageSchema: z.ZodType<CredentialStorage>;

validation/DisconnectResponse

export declare const DisconnectResponseSchema: z.ZodType<DisconnectResponse>;

validation/DnsEvent

export declare const DnsEventSchema: z.ZodType<DnsEvent>;

validation/EnrollmentKind

export declare const EnrollmentKindSchema: z.ZodType<EnrollmentKind>;

validation/ErrorCode

export declare const ErrorCodeSchema: z.ZodType<ErrorCode>;

validation/ErrorEvent

export declare const ErrorEventSchema: z.ZodType<ErrorEvent>;

validation/ErrorResponse

export declare const ErrorResponseSchema: z.ZodType<ErrorResponse>;

validation/EventBodiesResponse

export declare const EventBodiesResponseSchema: z.ZodType<EventBodiesResponse>;

validation/EventBody

export declare const EventBodySchema: z.ZodType<EventBody>;

validation/ExecHistoryDetails

export declare const ExecHistoryDetailsSchema: z.ZodType<ExecHistoryDetails>;

validation/ExecOutput

export declare const ExecOutputSchema: z.ZodType<ExecOutput>;

validation/ExecOutputEncoding

export declare const ExecOutputEncodingSchema: z.ZodType<ExecOutputEncoding>;

validation/ExecRequest

export declare const ExecRequestSchema: z.ZodType<ExecRequest>;

validation/ExecResponse

export declare const ExecResponseSchema: z.ZodType<ExecResponse>;

validation/ExecSource

export declare const ExecSourceSchema: z.ZodType<ExecSource>;

validation/ExecTarget

export declare const ExecTargetSchema: z.ZodType<ExecTarget>;

validation/ExposureAccess

export declare const ExposureAccessSchema: z.ZodType<ExposureAccess>;

validation/ExposureInfo

export declare const ExposureInfoSchema: z.ZodType<ExposureInfo>;

validation/ExposureListResponse

export declare const ExposureListResponseSchema: z.ZodType<ExposureListResponse>;

validation/ExposureRequest

export declare const ExposureRequestSchema: z.ZodType<ExposureRequest>;

validation/ExposureTarget

export declare const ExposureTargetSchema: z.ZodType<ExposureTarget>;

validation/FileActionCount

export declare const FileActionCountSchema: z.ZodType<FileActionCount>;

validation/FileEntryType

export declare const FileEntryTypeSchema: z.ZodType<FileEntryType>;

validation/FileEvent

export declare const FileEventSchema: z.ZodType<FileEvent>;

validation/FileEventAction

export declare const FileEventActionSchema: z.ZodType<FileEventAction>;

validation/FileListEntry

export declare const FileListEntrySchema: z.ZodType<FileListEntry>;

validation/FileListResponse

export declare const FileListResponseSchema: z.ZodType<FileListResponse>;

validation/ForkRequest

export declare const ForkRequestSchema: z.ZodType<ForkRequest>;

validation/ForkResponse

export declare const ForkResponseSchema: z.ZodType<ForkResponse>;

validation/GrantState

export declare const GrantStateSchema: z.ZodType<GrantState>;

validation/HistoryDetails

export declare const HistoryDetailsSchema: z.ZodType<HistoryDetails>;

validation/HistoryEntry

export declare const HistoryEntrySchema: z.ZodType<HistoryEntry>;

validation/HistoryLayer

export declare const HistoryLayerSchema: z.ZodType<HistoryLayer>;

validation/HistoryLayerFilter

export declare const HistoryLayerFilterSchema: z.ZodType<HistoryLayerFilter>;

validation/HistoryResponse

export declare const HistoryResponseSchema: z.ZodType<HistoryResponse>;

validation/HostLogSource

export declare const HostLogSourceSchema: z.ZodType<HostLogSource>;

validation/HostLogsResponse

export declare const HostLogsResponseSchema: z.ZodType<HostLogsResponse>;

validation/HostTriageResponse

export declare const HostTriageResponseSchema: z.ZodType<HostTriageResponse>;

validation/HttpEvent

export declare const HttpEventSchema: z.ZodType<HttpEvent>;

validation/HypervisorInfo

export declare const HypervisorInfoSchema: z.ZodType<HypervisorInfo>;

validation/ImageApp

export declare const ImageAppSchema: z.ZodType<ImageApp>;

validation/ImageCacheState

export declare const ImageCacheStateSchema: z.ZodType<ImageCacheState>;

validation/ImageDownloadPhase

export declare const ImageDownloadPhaseSchema: z.ZodType<ImageDownloadPhase>;

validation/ImageDownloadProgress

export declare const ImageDownloadProgressSchema: z.ZodType<ImageDownloadProgress>;

validation/ImageEvidence

export declare const ImageEvidenceSchema: z.ZodType<ImageEvidence>;

validation/ImageEvidenceKind

export declare const ImageEvidenceKindSchema: z.ZodType<ImageEvidenceKind>;

validation/ImageInfo

export declare const ImageInfoSchema: z.ZodType<ImageInfo>;

validation/ImageInterface

export declare const ImageInterfaceSchema: z.ZodType<ImageInterface>;

validation/ImageInventoryResponse

export declare const ImageInventoryResponseSchema: z.ZodType<ImageInventoryResponse>;

validation/ImageListResponse

export declare const ImageListResponseSchema: z.ZodType<ImageListResponse>;

validation/ImagePackage

export declare const ImagePackageSchema: z.ZodType<ImagePackage>;

validation/ImagePackageInventory

export declare const ImagePackageInventorySchema: z.ZodType<ImagePackageInventory>;

validation/ImagePullRequest

export declare const ImagePullRequestSchema: z.ZodType<ImagePullRequest>;

validation/ImagePullResponse

export declare const ImagePullResponseSchema: z.ZodType<ImagePullResponse>;

validation/ImageSurface

export declare const ImageSurfaceSchema: z.ZodType<ImageSurface>;

validation/ImageTool

export declare const ImageToolSchema: z.ZodType<ImageTool>;

validation/Interaction

export declare const InteractionSchema: z.ZodType<Interaction>;

validation/InteractionBlock

export declare const InteractionBlockSchema: z.ZodType<InteractionBlock>;

validation/InteractionBlockKind

export declare const InteractionBlockKindSchema: z.ZodType<InteractionBlockKind>;

validation/InteractionBody

export declare const InteractionBodySchema: z.ZodType<InteractionBody>;

validation/InteractionContent

export declare const InteractionContentSchema: z.ZodType<InteractionContent>;

validation/InteractionMessage

export declare const InteractionMessageSchema: z.ZodType<InteractionMessage>;

validation/InteractionMessageKind

export declare const InteractionMessageKindSchema: z.ZodType<InteractionMessageKind>;

validation/InteractionReport

export declare const InteractionReportSchema: z.ZodType<InteractionReport>;

validation/InteractionRequest

export declare const InteractionRequestSchema: z.ZodType<InteractionRequest>;

validation/InteractionRequestKind

export declare const InteractionRequestKindSchema: z.ZodType<InteractionRequestKind>;

validation/InteractionRole

export declare const InteractionRoleSchema: z.ZodType<InteractionRole>;

validation/InteractionToolCall

export declare const InteractionToolCallSchema: z.ZodType<InteractionToolCall>;

validation/InteractionToolCallKind

export declare const InteractionToolCallKindSchema: z.ZodType<InteractionToolCallKind>;

validation/InteractionToolResult

export declare const InteractionToolResultSchema: z.ZodType<InteractionToolResult>;

validation/InteractionToolResultKind

export declare const InteractionToolResultKindSchema: z.ZodType<InteractionToolResultKind>;

validation/JsonContent

export declare const JsonContentSchema: z.ZodType<JsonContent>;

validation/JsonContentKind

export declare const JsonContentKindSchema: z.ZodType<JsonContentKind>;

validation/ListResponse

export declare const ListResponseSchema: z.ZodType<ListResponse>;

validation/LocalCredentialAuthority

export declare const LocalCredentialAuthoritySchema: z.ZodType<LocalCredentialAuthority>;

validation/LogsResponse

export declare const LogsResponseSchema: z.ZodType<LogsResponse>;

validation/ManagedSessionClaimRequest

export declare const ManagedSessionClaimRequestSchema: z.ZodType<ManagedSessionClaimRequest>;

validation/ManagedSessionClaimResponse

export declare const ManagedSessionClaimResponseSchema: z.ZodType<ManagedSessionClaimResponse>;

validation/ManagedSessionClosedState

export declare const ManagedSessionClosedStateSchema: z.ZodType<ManagedSessionClosedState>;

validation/ManagedSessionCloseRequest

export declare const ManagedSessionCloseRequestSchema: z.ZodType<ManagedSessionCloseRequest>;

validation/ManagedSessionCloseResponse

export declare const ManagedSessionCloseResponseSchema: z.ZodType<ManagedSessionCloseResponse>;

validation/ManagedSessionCreate

export declare const ManagedSessionCreateSchema: z.ZodType<ManagedSessionCreate>;

validation/ManagedSessionErrorCode

export declare const ManagedSessionErrorCodeSchema: z.ZodType<ManagedSessionErrorCode>;

validation/ManagedSessionFailure

export declare const ManagedSessionFailureSchema: z.ZodType<ManagedSessionFailure>;

validation/ManagedSessionOutcome

export declare const ManagedSessionOutcomeSchema: z.ZodType<ManagedSessionOutcome>;

validation/ManagedSessionOwnership

export declare const ManagedSessionOwnershipSchema: z.ZodType<ManagedSessionOwnership>;

validation/ManagedSessionState

export declare const ManagedSessionStateSchema: z.ZodType<ManagedSessionState>;

validation/MaterialClass

export declare const MaterialClassSchema: z.ZodType<MaterialClass>;

validation/McpDefaultPermissionResponse

export declare const McpDefaultPermissionResponseSchema: z.ZodType<McpDefaultPermissionResponse>;

validation/McpInfoResponse

export declare const McpInfoResponseSchema: z.ZodType<McpInfoResponse>;

validation/McpPermissionAction

export declare const McpPermissionActionSchema: z.ZodType<McpPermissionAction>;

validation/McpRefreshResponse

export declare const McpRefreshResponseSchema: z.ZodType<McpRefreshResponse>;

validation/McpServerInfoResponse

export declare const McpServerInfoResponseSchema: z.ZodType<McpServerInfoResponse>;

validation/McpServersListResponse

export declare const McpServersListResponseSchema: z.ZodType<McpServersListResponse>;

validation/McpToolInfoResponse

export declare const McpToolInfoResponseSchema: z.ZodType<McpToolInfoResponse>;

validation/McpToolsListResponse

export declare const McpToolsListResponseSchema: z.ZodType<McpToolsListResponse>;

validation/McpUsage

export declare const McpUsageSchema: z.ZodType<McpUsage>;

validation/ModelEvent

export declare const ModelEventSchema: z.ZodType<ModelEvent>;

validation/ModelUsage

export declare const ModelUsageSchema: z.ZodType<ModelUsage>;

validation/NetworkDecision

export declare const NetworkDecisionSchema: z.ZodType<NetworkDecision>;

validation/NetworkInfo

export declare const NetworkInfoSchema: z.ZodType<NetworkInfo>;

validation/NetworkListResponse

export declare const NetworkListResponseSchema: z.ZodType<NetworkListResponse>;

validation/NetworkLogEvent

export declare const NetworkLogEventSchema: z.ZodType<NetworkLogEvent>;

validation/NetworkLogsResponse

export declare const NetworkLogsResponseSchema: z.ZodType<NetworkLogsResponse>;

validation/NetworkMemberInfo

export declare const NetworkMemberInfoSchema: z.ZodType<NetworkMemberInfo>;

validation/NetworkMemberState

export declare const NetworkMemberStateSchema: z.ZodType<NetworkMemberState>;

validation/NetworkProtocol

export declare const NetworkProtocolSchema: z.ZodType<NetworkProtocol>;

validation/PanicEvent

export declare const PanicEventSchema: z.ZodType<PanicEvent>;

validation/PanicsResponse

export declare const PanicsResponseSchema: z.ZodType<PanicsResponse>;

validation/PersistRequest

export declare const PersistRequestSchema: z.ZodType<PersistRequest>;

validation/PersistResponse

export declare const PersistResponseSchema: z.ZodType<PersistResponse>;

validation/PreviewSessionResponse

export declare const PreviewSessionResponseSchema: z.ZodType<PreviewSessionResponse>;

validation/PreviewSessionsRevokedResponse

export declare const PreviewSessionsRevokedResponseSchema: z.ZodType<PreviewSessionsRevokedResponse>;

validation/ProcessEvent

export declare const ProcessEventSchema: z.ZodType<ProcessEvent>;

validation/ProviderRevocationState

export declare const ProviderRevocationStateSchema: z.ZodType<ProviderRevocationState>;

validation/ProvisionRequest

export declare const ProvisionRequestSchema: z.ZodType<ProvisionRequest>;

validation/ProvisionResponse

export declare const ProvisionResponseSchema: z.ZodType<ProvisionResponse>;

validation/ProxyHeartbeatResponse

export declare const ProxyHeartbeatResponseSchema: z.ZodType<ProxyHeartbeatResponse>;

validation/ProxyLeaseRequest

export declare const ProxyLeaseRequestSchema: z.ZodType<ProxyLeaseRequest>;

validation/PurgeRequest

export declare const PurgeRequestSchema: z.ZodType<PurgeRequest>;

validation/PurgeResponse

export declare const PurgeResponseSchema: z.ZodType<PurgeResponse>;

validation/RawContent

export declare const RawContentSchema: z.ZodType<RawContent>;

validation/RawContentKind

export declare const RawContentKindSchema: z.ZodType<RawContentKind>;

validation/RawContentReason

export declare const RawContentReasonSchema: z.ZodType<RawContentReason>;

validation/RegistryAccess

export declare const RegistryAccessSchema: z.ZodType<RegistryAccess>;

validation/ResourceSummary

export declare const ResourceSummarySchema: z.ZodType<ResourceSummary>;

validation/RestartAuthentication

export declare const RestartAuthenticationSchema: z.ZodType<RestartAuthentication>;

validation/RestartResponse

export declare const RestartResponseSchema: z.ZodType<RestartResponse>;

validation/RestartStatus

export declare const RestartStatusSchema: z.ZodType<RestartStatus>;

validation/RevokedCredentialAuthority

export declare const RevokedCredentialAuthoritySchema: z.ZodType<RevokedCredentialAuthority>;

validation/RevokeSessionGrantResponse

export declare const RevokeSessionGrantResponseSchema: z.ZodType<RevokeSessionGrantResponse>;

validation/RunRequest

export declare const RunRequestSchema: z.ZodType<RunRequest>;

validation/SandboxInfo

export declare const SandboxInfoSchema: z.ZodType<SandboxInfo>;

validation/ScopeProfileSummary

export declare const ScopeProfileSummarySchema: z.ZodType<ScopeProfileSummary>;

validation/SecurityAskDecision

export declare const SecurityAskDecisionSchema: z.ZodType<SecurityAskDecision>;

validation/SecurityAskListResponse

export declare const SecurityAskListResponseSchema: z.ZodType<SecurityAskListResponse>;

validation/SecurityAskRequest

export declare const SecurityAskRequestSchema: z.ZodType<SecurityAskRequest>;

validation/SecurityAskResolveRequest

export declare const SecurityAskResolveRequestSchema: z.ZodType<SecurityAskResolveRequest>;

validation/SecurityAskStatus

export declare const SecurityAskStatusSchema: z.ZodType<SecurityAskStatus>;

validation/ServiceAvailability

export declare const ServiceAvailabilitySchema: z.ZodType<ServiceAvailability>;

validation/ServiceManager

export declare const ServiceManagerSchema: z.ZodType<ServiceManager>;

validation/SessionDbStatus

export declare const SessionDbStatusSchema: z.ZodType<SessionDbStatus>;

validation/SessionGrantListResponse

export declare const SessionGrantListResponseSchema: z.ZodType<SessionGrantListResponse>;

validation/SessionGrantSummary

export declare const SessionGrantSummarySchema: z.ZodType<SessionGrantSummary>;

validation/SlowOpEvent

export declare const SlowOpEventSchema: z.ZodType<SlowOpEvent>;

validation/StopProxyResponse

export declare const StopProxyResponseSchema: z.ZodType<StopProxyResponse>;

validation/StopResponse

export declare const StopResponseSchema: z.ZodType<StopResponse>;

validation/StorageDiagnostics

export declare const StorageDiagnosticsSchema: z.ZodType<StorageDiagnostics>;

validation/StreamControl

export declare const StreamControlSchema: z.ZodType<StreamControl>;

validation/StreamControlCloseStdin

export declare const StreamControlCloseStdinSchema: z.ZodType<StreamControlCloseStdin>;

validation/StreamControlFocus

export declare const StreamControlFocusSchema: z.ZodType<StreamControlFocus>;

validation/StreamControlResize

export declare const StreamControlResizeSchema: z.ZodType<StreamControlResize>;

validation/StreamControlStart

export declare const StreamControlStartSchema: z.ZodType<StreamControlStart>;

validation/StreamKind

export declare const StreamKindSchema: z.ZodType<StreamKind>;

validation/StreamStatus

export declare const StreamStatusSchema: z.ZodType<StreamStatus>;

validation/StreamStatusError

export declare const StreamStatusErrorSchema: z.ZodType<StreamStatusError>;

validation/StreamStatusExit

export declare const StreamStatusExitSchema: z.ZodType<StreamStatusExit>;

validation/StreamStatusStarted

export declare const StreamStatusStartedSchema: z.ZodType<StreamStatusStarted>;

validation/StreamStatusTerminal

export declare const StreamStatusTerminalSchema: z.ZodType<StreamStatusTerminal>;

validation/SupplyChainChannelEvidence

export declare const SupplyChainChannelEvidenceSchema: z.ZodType<SupplyChainChannelEvidence>;

validation/SupplyChainEvidence

export declare const SupplyChainEvidenceSchema: z.ZodType<SupplyChainEvidence>;

validation/SupplyChainManifestEvidence

export declare const SupplyChainManifestEvidenceSchema: z.ZodType<SupplyChainManifestEvidence>;

validation/SupplyChainReference

export declare const SupplyChainReferenceSchema: z.ZodType<SupplyChainReference>;

validation/TerminalCursor

export declare const TerminalCursorSchema: z.ZodType<TerminalCursor>;

validation/TerminalEvent

export declare const TerminalEventSchema: z.ZodType<TerminalEvent>;

validation/TerminalEventKind

export declare const TerminalEventKindSchema: z.ZodType<TerminalEventKind>;

validation/TerminalModes

export declare const TerminalModesSchema: z.ZodType<TerminalModes>;

validation/TerminalNotification

export declare const TerminalNotificationSchema: z.ZodType<TerminalNotification>;

validation/TerminalState

export declare const TerminalStateSchema: z.ZodType<TerminalState>;

validation/TerminalSummary

export declare const TerminalSummarySchema: z.ZodType<TerminalSummary>;

validation/TextContent

export declare const TextContentSchema: z.ZodType<TextContent>;

validation/TextContentKind

export declare const TextContentKindSchema: z.ZodType<TextContentKind>;

validation/TimelineEvent

export declare const TimelineEventSchema: z.ZodType<TimelineEvent>;

validation/TimelineLayer

export declare const TimelineLayerSchema: z.ZodType<TimelineLayer>;

validation/TimelineReference

export declare const TimelineReferenceSchema: z.ZodType<TimelineReference>;

validation/TimelineResponse

export declare const TimelineResponseSchema: z.ZodType<TimelineResponse>;

validation/TimelineStatus

export declare const TimelineStatusSchema: z.ZodType<TimelineStatus>;

validation/ToolDecision

export declare const ToolDecisionSchema: z.ZodType<ToolDecision>;

validation/ToolEvent

export declare const ToolEventSchema: z.ZodType<ToolEvent>;

validation/ToolOrigin

export declare const ToolOriginSchema: z.ZodType<ToolOrigin>;

validation/TransactionState

export declare const TransactionStateSchema: z.ZodType<TransactionState>;

validation/TriageResponse

export declare const TriageResponseSchema: z.ZodType<TriageResponse>;

validation/UpdateActionResponse

export declare const UpdateActionResponseSchema: z.ZodType<UpdateActionResponse>;

validation/UpdateActionStatus

export declare const UpdateActionStatusSchema: z.ZodType<UpdateActionStatus>;

validation/UpdateApplyRequest

export declare const UpdateApplyRequestSchema: z.ZodType<UpdateApplyRequest>;

validation/UpdateCheckRequest

export declare const UpdateCheckRequestSchema: z.ZodType<UpdateCheckRequest>;

validation/UpdateCommandPlan

export declare const UpdateCommandPlanSchema: z.ZodType<UpdateCommandPlan>;

validation/UpdateCompatibilityState

export declare const UpdateCompatibilityStateSchema: z.ZodType<UpdateCompatibilityState>;

validation/UpdateStatusResponse

export declare const UpdateStatusResponseSchema: z.ZodType<UpdateStatusResponse>;

validation/UpdateTrackState

export declare const UpdateTrackStateSchema: z.ZodType<UpdateTrackState>;

validation/UpdateTrackStatus

export declare const UpdateTrackStatusSchema: z.ZodType<UpdateTrackStatus>;

validation/UploadResponse

export declare const UploadResponseSchema: z.ZodType<UploadResponse>;

validation/ValidationStatus

export declare const ValidationStatusSchema: z.ZodType<ValidationStatus>;

validation/Value

export declare const ValueSchema: z.ZodType<Value>;

validation/VmAction

export declare const VmActionSchema: z.ZodType<VmAction>;

validation/VmActionResponse

export declare const VmActionResponseSchema: z.ZodType<VmActionResponse>;

validation/VmAiInfo

export declare const VmAiInfoSchema: z.ZodType<VmAiInfo>;

validation/VmFilesInfo

export declare const VmFilesInfoSchema: z.ZodType<VmFilesInfo>;

validation/VmLifecycleState

export declare const VmLifecycleStateSchema: z.ZodType<VmLifecycleState>;

validation/VmNetworkInfo

export declare const VmNetworkInfoSchema: z.ZodType<VmNetworkInfo>;

validation/VmStatsDetailResponse

export declare const VmStatsDetailResponseSchema: z.ZodType<VmStatsDetailResponse>;

validation/VmStatsSummaryResponse

export declare const VmStatsSummaryResponseSchema: z.ZodType<VmStatsSummaryResponse>;

validation/VmStatusResponse

export declare const VmStatusResponseSchema: z.ZodType<VmStatusResponse>;

validation/VmSummary

export declare const VmSummarySchema: z.ZodType<VmSummary>;

models/ArchivedEventBody

export interface ArchivedEventBody {
    "body_hash": string;
    "content": string;
    "content_type"?: string | null;
    "direction": string;
    "encoding": BodyEncoding;
    "event_id": string;
    "original_bytes": number;
    "source_table": string;
    "stored_bytes": number;
    "truncated": boolean;
    "truncated_for_transport": boolean;
}

models/AssetFileState

export declare enum AssetFileState {
    PRESENT = "present",
    MISSING = "missing",
    INVALID = "invalid"
}

models/AssetFileStatus

export interface AssetFileStatus {
    "actual_size"?: number | null;
    "expected_hash": string;
    "expected_size"?: number | null;
    "kind": string;
    "name": string;
    "path": string;
    "status": AssetFileState;
}

models/AssetManifestStatus

export interface AssetManifestStatus {
    "assets_current"?: string | null;
    "binaries_current"?: string | null;
    "blake3"?: string | null;
    "format"?: number | null;
    "origin": string;
    "origin_path"?: string | null;
    "origin_source"?: string | null;
    "packaged_at"?: string | null;
    "path": string;
    "refresh_policy"?: string | null;
    "refreshed_at"?: string | null;
    "validation_error"?: string | null;
    "validation_status": ValidationStatus;
}

models/AssetStatus

export interface AssetStatus {
    "asset_version"?: string | null;
    "assets": Array<AssetFileStatus>;
    "bytes_done"?: number | null;
    "bytes_total"?: number | null;
    "current_arch": string;
    "current_asset"?: string | null;
    "downloaded"?: number | null;
    "downloading": boolean;
    "errors": Array<string>;
    "manifest": AssetManifestStatus;
    "ready": boolean;
    "reconcile_error"?: string | null;
    "started"?: boolean | null;
}

models/AuditEvent

export interface AuditEvent {
    "argv": string;
    "audit_id"?: string | null;
    "comm"?: string | null;
    "credential_ref"?: string | null;
    "cwd"?: string | null;
    "event_id": string;
    "exe": string;
    "exec_event_id"?: number | null;
    "exit_code"?: number | null;
    "parent_exe"?: string | null;
    "pid": number;
    "ppid": number;
    "session_id"?: number | null;
    "timestamp": string;
    "trace_id"?: string | null;
    "tty"?: string | null;
    "uid": number;
}

models/AuditHistoryDetails

export interface AuditHistoryDetails {
    "audit_id"?: string | null;
    "comm"?: string | null;
    "cwd"?: string | null;
    "exe": string;
    "parent_exe"?: string | null;
    "pid": number;
    "ppid": number;
    "session_id"?: number | null;
    "tty"?: string | null;
    "uid": number;
}

models/AuthorizationTransaction

export interface AuthorizationTransaction {
    "connection_id": string | null;
    "error_code": null | CredentialErrorCode;
    "expires_at": string;
    "id": string;
    "state": TransactionState;
}

models/AuthorizeGoogleRequest

export interface AuthorizeGoogleRequest {
    "reconnect_connection_id": string | null;
    "request_id": string;
    "scope_profile_id": string;
}

models/AuthorizeGoogleResponse

export interface AuthorizeGoogleResponse {
    "authorization_url": string | null;
    "transaction": AuthorizationTransaction;
}

models/BodyEncoding

export declare enum BodyEncoding {
    UTF8 = "utf8",
    BASE64 = "base64"
}

models/BrowserAcknowledgeRequest

export interface BrowserAcknowledgeRequest {
    "owner_generation": string;
    "request_id": number;
}

models/BrowserAcknowledgeResponse

export interface BrowserAcknowledgeResponse {
    "owner_generation": string;
    "request_id": number;
    "vm_id": string;
}

models/BrowserRequest

export interface BrowserRequest {
    "id": number;
    "owner_generation"?: string | null;
    "url": string;
}

models/CapabilitySummary

export interface CapabilitySummary {
    "consumer": string;
    "id": string;
    "label": string;
    "required_scopes": Array<string>;
    "supported": boolean;
}

models/CapturedContent

export type CapturedContent = JsonContent | TextContent | RawContent;

models/CapturedPayload

export interface CapturedPayload {
    "content": CapturedContent;
    "status": CaptureStatus;
}

models/CaptureStatus

export declare enum CaptureStatus {
    COMPLETE = "complete",
    TRUNCATED = "truncated",
    UNKNOWN = "unknown"
}

models/CatalogInfo

export interface CatalogInfo {
    "channel": string;
    "digest": string;
    "generated_at"?: string | null;
    "reference": string;
}

models/ConnectionListResponse

export interface ConnectionListResponse {
    "connections": Array<ConnectionSummary>;
    "next_cursor": string | null;
    "scope_profiles": Array<ScopeProfileSummary>;
}

models/ConnectionProvider

export declare enum ConnectionProvider {
    GOOGLE = "google"
}

models/ConnectionState

export declare enum ConnectionState {
    CONNECTED = "connected",
    REAUTH_REQUIRED = "reauth_required",
    DISCONNECTING = "disconnecting",
    DISCONNECTED = "disconnected",
    DEGRADED = "degraded"
}

models/ConnectionSummary

export interface ConnectionSummary {
    "account_label": string | null;
    "available_capabilities": Array<string>;
    "created_at": string;
    "error_code": null | CredentialErrorCode;
    "granted_scopes": Array<string>;
    "id": string;
    "last_refresh_at": string | null;
    "provider": ConnectionProvider;
    "provider_revocation": ProviderRevocationState;
    "revision": number;
    "scope_profile_id": string;
    "state": ConnectionState;
    "updated_at": string;
}

models/ContainerSpec

export interface ContainerSpec {
    "args"?: Array<string>;
    "attach"?: boolean;
    "env"?: Record<string, string>;
    "image": string;
    "registry"?: null | RegistryAccess;
}

models/ContainerState

export declare enum ContainerState {
    PULLING = "pulling",
    STAGING = "staging",
    STAGED = "staged",
    STARTING = "starting",
    RUNNING = "running",
    EXITED = "exited",
    FAILED = "failed"
}

models/ContainerStatusResponse

export interface ContainerStatusResponse {
    "digest"?: string | null;
    "error"?: string | null;
    "exit_code"?: number | null;
    "image": string;
    "resolved"?: string | null;
    "state": ContainerState;
    "surface"?: null | ContainerSurface;
}

models/ContainerSurface

export interface ContainerSurface {
    "exposure_id"?: string | null;
    "kind": ContainerSurfaceKind;
    "port": number;
}

models/ContainerSurfaceKind

export declare enum ContainerSurfaceKind {
    XPRA = "xpra"
}

models/CostCoverage

export interface CostCoverage {
    "priced_calls": number;
    "unknown_calls": number;
    "unpriced_calls": number;
}

models/CreateNetworkRequest

export interface CreateNetworkRequest {
    "name": string;
}

models/CreateProxyRequest

export interface CreateProxyRequest {
    "bind": string;
    "port": number;
    "provider": string;
}

models/CreateProxyResponse

export interface CreateProxyResponse {
    "base_url": string;
    "bind": string;
    "lease_expires_unix_ms": number;
    "lease_token": string;
    "port": number;
    "provider": string;
    "session_id": string;
}

models/CreateSessionGrantRequest

export interface CreateSessionGrantRequest {
    "capability_ids": Array<string>;
    "connection_id": string;
    "expected_owner_generation": string;
    "expires_at": string | null;
    "request_id": string;
}

models/CredentialErrorCode

export declare enum CredentialErrorCode {
    CONFIGURATION_REQUIRED = "configuration_required",
    UNSUPPORTED_CAPABILITY = "unsupported_capability",
    UNKNOWN_SCOPE_PROFILE = "unknown_scope_profile",
    POLICY_DENIED = "policy_denied",
    SCOPE_DENIED = "scope_denied",
    CONNECTION_UNAVAILABLE = "connection_unavailable",
    REAUTH_REQUIRED = "reauth_required",
    STORAGE_UNAVAILABLE = "storage_unavailable",
    STORAGE_COMMIT_FAILED = "storage_commit_failed",
    TRANSACTION_EXPIRED = "transaction_expired",
    TRANSACTION_CANCELLED = "transaction_cancelled",
    INVALID_CALLBACK = "invalid_callback",
    PROVIDER_REJECTED = "provider_rejected",
    PROVIDER_TIMEOUT = "provider_timeout",
    OWNER_CHANGED = "owner_changed",
    SESSION_UNAVAILABLE = "session_unavailable",
    GRANT_UNAVAILABLE = "grant_unavailable",
    REQUEST_CONFLICT = "request_conflict",
    REVOCATION_PENDING = "revocation_pending"
}

models/CredentialEvent

export interface CredentialEvent {
    "context_json"?: string | null;
    "event_id": string;
    "event_type"?: null | CredentialEventType;
    "material_class": MaterialClass;
    "origin"?: null | CredentialEventType;
    "provider"?: string | null;
    "source": string;
    "timestamp": string;
    "trace_id"?: string | null;
    "verb": CredentialOutcome;
}

models/CredentialEventType

export declare enum CredentialEventType {
    HTTP_REQUEST = "http.request",
    HTTP_RESPONSE = "http.response",
    MODEL_CALL = "model.call",
    MCP_TOOL_CALL = "mcp.tool_call",
    MCP_TOOL_LIST = "mcp.tool_list",
    MCP_EVENT = "mcp.event",
    DNS_QUERY = "dns.query",
    FILE_EVENT = "file.event",
    FILE_IMPORT = "file.import",
    FILE_EXPORT = "file.export",
    PROCESS_EXEC = "process.exec",
    PROCESS_EXEC_COMPLETE = "process.exec_complete",
    PROCESS_AUDIT = "process.audit",
    CREDENTIAL_SUBSTITUTION = "credential.substitution",
    SECURITY_RULE = "security.rule",
    SECURITY_ASK = "security.ask"
}

models/CredentialInjectProvider

export declare enum CredentialInjectProvider {
    ANTHROPIC = "anthropic",
    GOOGLE = "google",
    OPENAI = "openai",
    GITHUB = "github",
    MCP = "mcp"
}

models/CredentialInjectRequest

export interface CredentialInjectRequest {
    "provider": CredentialInjectProvider;
    "storage"?: CredentialStorage;
    "value": string;
}

models/CredentialInjectResponse

export interface CredentialInjectResponse {
    "credential_ref": string;
    "storage": CredentialStorage;
}

models/CredentialOutcome

export declare enum CredentialOutcome {
    CAPTURED = "captured",
    BROKERED = "brokered",
    INJECTED = "injected",
    ERROR = "error"
}

models/CredentialStorage

export declare enum CredentialStorage {
    FILE = "file",
    MEMORY = "memory"
}

models/DisconnectResponse

export interface DisconnectResponse {
    "connection": ConnectionSummary;
    "local_authority": LocalCredentialAuthority;
    "revoked_grant_count": number;
}

models/DnsEvent

export interface DnsEvent {
    "credential_ref"?: string | null;
    "decision": NetworkDecision;
    "event_id": string;
    "matched_rule"?: string | null;
    "policy_rule"?: string | null;
    "process_name"?: string | null;
    "qclass": number;
    "qname": string;
    "qtype": number;
    "rcode": number;
    "source_proto"?: null | NetworkProtocol;
    "timestamp": string;
    "trace_id"?: string | null;
    "upstream_resolver_ms"?: number | null;
}

models/EnrollmentKind

export declare enum EnrollmentKind {
    OWNED_OAUTH_CLIENT = "owned_oauth_client",
    NATIVE_CONSUMER_SIGN_IN = "native_consumer_sign_in"
}

models/ErrorCode

export declare enum ErrorCode {
    VM_NOT_FOUND = "vm_not_found",
    CREATE_TIMEOUT = "create_timeout",
    EXEC_TIMEOUT = "exec_timeout",
    CONFIGURATION_REQUIRED = "configuration_required",
    UNSUPPORTED_CAPABILITY = "unsupported_capability",
    UNKNOWN_SCOPE_PROFILE = "unknown_scope_profile",
    POLICY_DENIED = "policy_denied",
    SCOPE_DENIED = "scope_denied",
    CONNECTION_UNAVAILABLE = "connection_unavailable",
    REAUTH_REQUIRED = "reauth_required",
    STORAGE_UNAVAILABLE = "storage_unavailable",
    STORAGE_COMMIT_FAILED = "storage_commit_failed",
    TRANSACTION_EXPIRED = "transaction_expired",
    TRANSACTION_CANCELLED = "transaction_cancelled",
    INVALID_CALLBACK = "invalid_callback",
    PROVIDER_REJECTED = "provider_rejected",
    PROVIDER_TIMEOUT = "provider_timeout",
    OWNER_CHANGED = "owner_changed",
    SESSION_UNAVAILABLE = "session_unavailable",
    GRANT_UNAVAILABLE = "grant_unavailable",
    REQUEST_CONFLICT = "request_conflict",
    REVOCATION_PENDING = "revocation_pending"
}

models/ErrorEvent

export interface ErrorEvent {
    "binary": string;
    "level": string;
    "message": string;
    "target"?: string | null;
    "ts": string;
}

models/ErrorResponse

export interface ErrorResponse {
    "code"?: null | ErrorCode;
    "error": string;
    "timeout_secs"?: number | null;
    "vm_id"?: string | null;
}

models/EventBodiesResponse

export interface EventBodiesResponse {
    "bodies": Array<ArchivedEventBody>;
    "event_id": string;
}

models/EventBody

export interface EventBody {
    "body_hash": string;
    "content_type"?: string | null;
    "direction": string;
    "event_id": string;
    "original_bytes": number;
    "source_table": string;
    "stored_bytes": number;
    "truncated": boolean;
}

models/ExecHistoryDetails

export interface ExecHistoryDetails {
    "exec_id": number;
    "process_name"?: string | null;
    "source": ExecSource;
    "trace_id"?: string | null;
}

models/ExecOutput

export interface ExecOutput {
    "data": string;
    "encoding": ExecOutputEncoding;
}

models/ExecOutputEncoding

export declare enum ExecOutputEncoding {
    UTF8 = "utf8",
    BASE64 = "base64"
}

models/ExecRequest

export interface ExecRequest {
    "command": string;
    "target"?: null | ExecTarget;
    "timeout_secs"?: number | null;
}

models/ExecResponse

export interface ExecResponse {
    "exit_code": number;
    "stderr": ExecOutput;
    "stdout": ExecOutput;
    "truncated"?: boolean;
}

models/ExecSource

export declare enum ExecSource {
    API = "api",
    CLI = "cli",
    MCP = "mcp",
    FRONTEND = "frontend"
}

models/ExecTarget

export declare enum ExecTarget {
    WORKLOAD = "workload",
    VM = "vm"
}

models/ExposureAccess

export declare enum ExposureAccess {
    LOOPBACK_TCP = "loopback_tcp",
    HTTP_PREVIEW = "http_preview"
}

models/ExposureInfo

export interface ExposureInfo {
    "access": ExposureAccess;
    "guest_port": number;
    "host_port"?: number | null;
    "id": string;
    "target": ExposureTarget;
}

models/ExposureListResponse

export interface ExposureListResponse {
    "exposures": Array<ExposureInfo>;
    "owner_generation": string;
}

models/ExposureRequest

export interface ExposureRequest {
    "access"?: ExposureAccess;
    "guest_port": number;
    "host_port"?: number;
    "target"?: ExposureTarget;
}

models/ExposureTarget

export declare enum ExposureTarget {
    CONTAINER = "container",
    VM = "vm"
}

models/FileActionCount

export interface FileActionCount {
    "action": FileEventAction;
    "count": number;
}

models/FileEntryType

export declare enum FileEntryType {
    FILE = "file",
    DIRECTORY = "directory"
}

models/FileEvent

export interface FileEvent {
    "action": FileEventAction;
    "credential_ref"?: string | null;
    "event_id": string;
    "path": string;
    "size"?: number | null;
    "timestamp": string;
    "trace_id"?: string | null;
}

models/FileEventAction

export declare enum FileEventAction {
    CREATED = "created",
    MODIFIED = "modified",
    DELETED = "deleted",
    RESTORED = "restored",
    READ = "read",
    IMPORT = "import",
    EXPORT = "export"
}

models/FileListEntry

export interface FileListEntry {
    "children"?: Array<FileListEntry> | null;
    "is_text"?: boolean | null;
    "label"?: string | null;
    "mime"?: string | null;
    "mtime": number;
    "name": string;
    "path": string;
    "size": number;
    "type": FileEntryType;
}

models/FileListResponse

export interface FileListResponse {
    "entries": Array<FileListEntry>;
}

models/ForkRequest

export interface ForkRequest {
    "description"?: string | null;
    "labels"?: Record<string, string> | null;
    "name": string;
}

models/ForkResponse

export interface ForkResponse {
    "id": string;
    "name": string;
    "size_bytes": number;
}

models/GrantState

export declare enum GrantState {
    ACTIVE = "active",
    REVOKED = "revoked",
    EXPIRED = "expired"
}

models/HistoryDetails

export type HistoryDetails = ExecHistoryDetails | AuditHistoryDetails;

models/HistoryEntry

export interface HistoryEntry {
    "command": string;
    "details": HistoryDetails;
    "duration_ms"?: number | null;
    "exit_code"?: number | null;
    "layer": HistoryLayer;
    "stderr_preview"?: string | null;
    "stdout_preview"?: string | null;
    "timestamp": string;
}

models/HistoryLayer

export declare enum HistoryLayer {
    EXEC = "exec",
    AUDIT = "audit"
}

models/HistoryLayerFilter

export declare enum HistoryLayerFilter {
    ALL = "all",
    EXEC = "exec",
    AUDIT = "audit"
}

models/HistoryResponse

export interface HistoryResponse {
    "commands": Array<HistoryEntry>;
    "has_more": boolean;
    "total": number;
}

models/HostLogSource

export declare enum HostLogSource {
    SERVICE = "service",
    MCP = "mcp",
    GATEWAY = "gateway",
    TRAY = "tray",
    APP = "app"
}

models/HostLogsResponse

export interface HostLogsResponse {
    "source": HostLogSource;
    "text": string;
}

models/HostTriageResponse

export interface HostTriageResponse {
    "errors": Array<ErrorEvent>;
    "panics": Array<PanicEvent>;
    "slow_ops": Array<SlowOpEvent>;
}

models/HttpEvent

export interface HttpEvent {
    "bytes_received"?: number | null;
    "bytes_sent"?: number | null;
    "credential_ref"?: string | null;
    "decision": NetworkDecision;
    "domain": string;
    "duration_ms"?: number | null;
    "event_id": string;
    "matched_rule"?: string | null;
    "method"?: string | null;
    "path"?: string | null;
    "policy_rule"?: string | null;
    "port"?: number | null;
    "query"?: string | null;
    "request_headers"?: string | null;
    "response_headers"?: string | null;
    "status_code"?: number | null;
    "timestamp": string;
    "trace_id"?: string | null;
}

models/HypervisorInfo

export interface HypervisorInfo {
    "assets"?: null | AssetStatus;
    "gateway_version": string;
    "resource_summary"?: null | ResourceSummary;
    "service": ServiceAvailability;
    "updates"?: null | UpdateStatusResponse;
    "vm_count": number;
    "vms": Array<VmSummary>;
}

models/ImageApp

export interface ImageApp {
    "architecture": string;
    "catalog_name": string;
    "category"?: string | null;
    "description": string;
    "display_name": string;
    "evidence"?: Array<ImageEvidence>;
    "icon"?: string | null;
    "image": string;
    "interfaces"?: Array<ImageInterface>;
    "publisher"?: string | null;
    "url"?: string | null;
}

models/ImageCacheState

export declare enum ImageCacheState {
    UNKNOWN = "unknown",
    MISSING = "missing",
    PARTIAL = "partial",
    READY = "ready"
}

models/ImageDownloadPhase

export declare enum ImageDownloadPhase {
    PREPARING = "preparing",
    DOWNLOADING = "downloading",
    VERIFYING = "verifying"
}

models/ImageDownloadProgress

export interface ImageDownloadProgress {
    "completed_bytes": number;
    "phase": ImageDownloadPhase;
    "total_bytes"?: number | null;
}

models/ImageEvidence

export interface ImageEvidence {
    "kind": ImageEvidenceKind;
    "media_type": string;
    "reference": string;
}

models/ImageEvidenceKind

export declare enum ImageEvidenceKind {
    OBOM = "obom",
    SBOM = "sbom",
    ABOM = "abom",
    PACKAGE_INVENTORY = "package_inventory"
}

models/ImageInfo

export interface ImageInfo {
    "app"?: null | ImageApp;
    "architectures": Array<string>;
    "cached": ImageCacheState;
    "description": string;
    "image"?: string | null;
    "name": string;
    "previous_image"?: string | null;
    "progress"?: null | ImageDownloadProgress;
    "surface"?: null | ImageSurface;
}

models/ImageInterface

export declare enum ImageInterface {
    TERMINAL = "terminal",
    GRAPHICAL = "graphical",
    WEB = "web",
    API = "api"
}

models/ImageInventoryResponse

export interface ImageInventoryResponse {
    "architecture": string;
    "artifact_reference"?: string | null;
    "image": string;
    "inventory"?: null | ImagePackageInventory;
}

models/ImageListResponse

export interface ImageListResponse {
    "catalog"?: null | CatalogInfo;
    "images": Array<ImageInfo>;
}

models/ImagePackage

export interface ImagePackage {
    "architecture": string;
    "name": string;
    "version": string;
}

models/ImagePackageInventory

export interface ImagePackageInventory {
    "architecture": string;
    "packages": Array<ImagePackage>;
    "schema": string;
    "subject": string;
    "tools": Array<ImageTool>;
}

models/ImagePullRequest

export interface ImagePullRequest {
    "image": string;
    "registry"?: null | RegistryAccess;
}

models/ImagePullResponse

export interface ImagePullResponse {
    "digest": string;
    "image": string;
    "resolved": string;
}

models/ImageSurface

export declare enum ImageSurface {
    TERMINAL = "terminal",
    XPRA = "xpra"
}

models/ImageTool

export interface ImageTool {
    "name": string;
    "version": string;
}

models/Interaction

export interface Interaction {
    "content": InteractionContent;
    "event_id": string;
    "item_index"?: number | null;
    "model_call_id"?: number | null;
    "model_event_id"?: string | null;
    "timestamp": string;
    "trace_id"?: string | null;
    "turn_id"?: string | null;
}

models/InteractionBlock

export interface InteractionBlock {
    "kind": InteractionBlockKind;
    "payload"?: null | CapturedPayload;
}

models/InteractionBlockKind

export declare enum InteractionBlockKind {
    TEXT = "text",
    REASONING = "reasoning"
}

models/InteractionBody

export interface InteractionBody {
    "body_hash": string;
    "content_type"?: string | null;
    "direction": string;
    "event_id": string;
    "original_bytes": number;
    "source_table": string;
    "stored_bytes": number;
    "truncated": boolean;
}

models/InteractionContent

export type InteractionContent = InteractionRequest | InteractionMessage | InteractionToolCall | InteractionToolResult;

models/InteractionMessage

export interface InteractionMessage {
    "blocks": Array<InteractionBlock>;
    "kind": InteractionMessageKind;
    "role": InteractionRole;
}

models/InteractionMessageKind

export declare enum InteractionMessageKind {
    MESSAGE = "message"
}

models/InteractionReport

export interface InteractionReport {
    "bodies": Array<InteractionBody>;
    "items": Array<Interaction>;
}

models/InteractionRequest

export interface InteractionRequest {
    "kind": InteractionRequestKind;
    "payload"?: null | CapturedPayload;
}

models/InteractionRequestKind

export declare enum InteractionRequestKind {
    REQUEST_PREVIEW = "request_preview"
}

models/InteractionRole

export declare enum InteractionRole {
    ASSISTANT = "assistant"
}

models/InteractionToolCall

export interface InteractionToolCall {
    "arguments"?: null | CapturedPayload;
    "call_id": string;
    "decision": ToolDecision;
    "kind": InteractionToolCallKind;
    "origin": ToolOrigin;
    "request"?: null | CapturedPayload;
    "result"?: null | InteractionToolResult;
    "server_name"?: string | null;
    "tool_name": string;
}

models/InteractionToolCallKind

export declare enum InteractionToolCallKind {
    TOOL_CALL = "tool_call"
}

models/InteractionToolResult

export interface InteractionToolResult {
    "call_id": string;
    "error_message"?: string | null;
    "is_error"?: boolean | null;
    "kind": InteractionToolResultKind;
    "payload"?: null | CapturedPayload;
    "response"?: null | CapturedPayload;
}

models/InteractionToolResultKind

export declare enum InteractionToolResultKind {
    TOOL_RESULT = "tool_result"
}

models/JsonContent

export interface JsonContent {
    "kind": JsonContentKind;
    "value": JSONType;
}

models/JsonContentKind

export declare enum JsonContentKind {
    JSON = "json"
}

models/ListResponse

export interface ListResponse {
    "sandboxes": Array<SandboxInfo>;
}

models/LocalCredentialAuthority

export declare enum LocalCredentialAuthority {
    REVOKING = "revoking",
    REVOKED = "revoked"
}

models/LogsResponse

export interface LogsResponse {
    "logs": string;
    "process_logs"?: string | null;
    "serial_logs"?: string | null;
}

models/ManagedSessionClaimRequest

export interface ManagedSessionClaimRequest {
    "ownership_token": string;
}

models/ManagedSessionClaimResponse

export interface ManagedSessionClaimResponse {
    "error"?: null | ManagedSessionFailure;
    "ownership": ManagedSessionOwnership;
    "session"?: null | ProvisionResponse;
    "state": ManagedSessionState;
}

models/ManagedSessionClosedState

export declare enum ManagedSessionClosedState {
    CLOSED = "closed"
}

models/ManagedSessionCloseRequest

export interface ManagedSessionCloseRequest {
    "outcome": ManagedSessionOutcome;
    "ownership_token": string;
}

models/ManagedSessionCloseResponse

export interface ManagedSessionCloseResponse {
    "evidence_retained": boolean;
    "generation": string;
    "request_id": string;
    "session_id"?: string | null;
    "state": ManagedSessionClosedState;
}

models/ManagedSessionCreate

export interface ManagedSessionCreate {
    "ownership_token": string;
    "request_id": string;
}

models/ManagedSessionErrorCode

export declare enum ManagedSessionErrorCode {
    INVALID_REQUEST = "invalid_request",
    FORBIDDEN = "forbidden",
    NOT_FOUND = "not_found",
    DUPLICATE_REQUEST = "duplicate_request",
    EXPIRED = "expired",
    CREATION_FAILED = "creation_failed",
    CLEANUP_FAILED = "cleanup_failed",
    RECOVERY_PENDING = "recovery_pending",
    STORE_UNAVAILABLE = "store_unavailable"
}

models/ManagedSessionFailure

export interface ManagedSessionFailure {
    "code": ManagedSessionErrorCode;
    "error": string;
}

models/ManagedSessionOutcome

export declare enum ManagedSessionOutcome {
    COMPLETED = "completed",
    FAILED = "failed",
    CANCELLED = "cancelled"
}

models/ManagedSessionOwnership

export interface ManagedSessionOwnership {
    "expires_at": string;
    "generation": string;
    "lease_seconds": number;
    "renew_after_seconds": number;
    "request_id": string;
}

models/ManagedSessionState

export declare enum ManagedSessionState {
    PENDING = "pending",
    ACTIVE = "active",
    CLOSING = "closing",
    CLOSED = "closed",
    FAILED = "failed"
}

models/MaterialClass

export declare enum MaterialClass {
    CREDENTIAL = "credential"
}

models/McpDefaultPermissionResponse

export interface McpDefaultPermissionResponse {
    "action": McpPermissionAction;
    "rule_id"?: string | null;
    "source": string;
}

models/McpInfoResponse

export interface McpInfoResponse {
    "builtin_local_enabled": boolean;
    "manual_server_count": number;
    "server_count": number;
}

models/McpPermissionAction

export declare enum McpPermissionAction {
    ALLOW = "allow",
    ASK = "ask",
    BLOCK = "block",
    PREPROCESS = "preprocess",
    REWRITE = "rewrite",
    POSTPROCESS = "postprocess"
}

models/McpRefreshResponse

export interface McpRefreshResponse {
    "instances": number;
    "server_id": string;
    "success": boolean;
}

models/McpServerInfoResponse

export interface McpServerInfoResponse {
    "custom_header_count": number;
    "enabled": boolean;
    "has_auth_credential": boolean;
    "is_stdio": boolean;
    "name": string;
    "running": boolean;
    "source": string;
    "tool_count": number;
    "url": string;
}

models/McpServersListResponse

export type McpServersListResponse = Array<McpServerInfoResponse>;

models/McpToolInfoResponse

export interface McpToolInfoResponse {
    "annotations"?: JSONType;
    "description"?: string | null;
    "namespaced_name": string;
    "original_name": string;
    "permission_action": McpPermissionAction;
    "permission_source": string;
    "pin_changed": boolean;
    "pin_hash"?: string | null;
    "server_name": string;
}

models/McpToolsListResponse

export type McpToolsListResponse = Array<McpToolInfoResponse>;

models/McpUsage

export interface McpUsage {
    "bytes_received": number;
    "bytes_sent": number;
    "call_count": number;
    "duration_ms": number;
    "server_name"?: string | null;
    "tool_name": string;
}

models/ModelEvent

export interface ModelEvent {
    "credential_ref"?: string | null;
    "duration_ms"?: number | null;
    "event_id": string;
    "input_tokens"?: number | null;
    "method": string;
    "model"?: string | null;
    "output_tokens"?: number | null;
    "path": string;
    "provider": string;
    "response_bytes"?: number | null;
    "status_code"?: number | null;
    "stop_reason"?: string | null;
    "timestamp": string;
    "trace_id"?: string | null;
}

models/ModelUsage

export interface ModelUsage {
    "call_count": number;
    "cost_coverage"?: null | CostCoverage;
    "duration_ms": number;
    "estimated_cost_usd": number;
    "input_tokens": number;
    "model": string;
    "output_tokens": number;
    "provider": string;
}

models/NetworkDecision

export declare enum NetworkDecision {
    ALLOWED = "allowed",
    DENIED = "denied",
    ERROR = "error",
    REDIRECTED = "redirected"
}

models/NetworkInfo

export interface NetworkInfo {
    "created_unix_ms": number;
    "id": string;
    "members": Array<NetworkMemberInfo>;
    "name": string;
    "subnet": string;
}

models/NetworkListResponse

export interface NetworkListResponse {
    "networks": Array<NetworkInfo>;
}

models/NetworkLogEvent

export interface NetworkLogEvent {
    "connection_id"?: string | null;
    "event": JSONType;
    "event_id": string;
    "event_type": string;
    "sequence": number;
    "timestamp_unix_ms": number;
}

models/NetworkLogsResponse

export interface NetworkLogsResponse {
    "cursor": string;
    "events": Array<NetworkLogEvent>;
    "next_cursor"?: string | null;
}

models/NetworkMemberInfo

export interface NetworkMemberInfo {
    "address": string;
    "state": NetworkMemberState;
    "updated_unix_ms": number;
    "vm_id": string;
}

models/NetworkMemberState

export declare enum NetworkMemberState {
    DECLARED = "declared",
    ATTACHING = "attaching",
    READY = "ready",
    FAILED = "failed"
}

models/NetworkProtocol

export declare enum NetworkProtocol {
    TCP = "tcp",
    UDP = "udp"
}

models/PanicEvent

export interface PanicEvent {
    "binary": string;
    "frames": Array<string>;
    "location"?: string | null;
    "message": string;
    "thread"?: string | null;
    "ts": string;
}

models/PanicsResponse

export interface PanicsResponse {
    "panics": Array<PanicEvent>;
}

models/PersistRequest

export interface PersistRequest {
    "name": string;
}

models/PersistResponse

export interface PersistResponse {
    "name": string;
    "success": boolean;
}

models/PreviewSessionResponse

export interface PreviewSessionResponse {
    "bootstrap_token": string;
    "expires_in_seconds": number;
    "url": string;
}

models/PreviewSessionsRevokedResponse

export interface PreviewSessionsRevokedResponse {
    "revoked": number;
}

models/ProcessEvent

export interface ProcessEvent {
    "command": string;
    "credential_ref"?: string | null;
    "duration_ms"?: number | null;
    "event_id": string;
    "exec_id": number;
    "exit_code"?: number | null;
    "pid"?: number | null;
    "process_name"?: string | null;
    "source": ExecSource;
    "stderr_bytes"?: number | null;
    "stdout_bytes"?: number | null;
    "timestamp": string;
    "trace_id"?: string | null;
}

models/ProviderRevocationState

export declare enum ProviderRevocationState {
    NOT_STARTED = "not_started",
    PENDING = "pending",
    SUCCEEDED = "succeeded",
    FAILED = "failed"
}

models/ProvisionRequest

export interface ProvisionRequest {
    "container"?: null | ContainerSpec;
    "cpus"?: number | null;
    "env"?: Record<string, string> | null;
    "from"?: string | null;
    "labels"?: Record<string, string> | null;
    "managed"?: null | ManagedSessionCreate;
    "name"?: string | null;
    "networks"?: Array<string>;
    "persistent"?: boolean;
    "ram_mb"?: number | null;
}

models/ProvisionResponse

export interface ProvisionResponse {
    "available_actions": Array<VmAction>;
    "can_resume"?: boolean;
    "id": string;
    "name": string;
    "ownership"?: null | ManagedSessionOwnership;
    "persistent"?: boolean;
    "status": VmLifecycleState;
}

models/ProxyHeartbeatResponse

export interface ProxyHeartbeatResponse {
    "lease_expires_unix_ms": number;
    "session_id": string;
}

models/ProxyLeaseRequest

export interface ProxyLeaseRequest {
    "lease_token": string;
}

models/PurgeRequest

export interface PurgeRequest {
    "all"?: boolean;
}

models/PurgeResponse

export interface PurgeResponse {
    "ephemeral_purged": number;
    "persistent_purged": number;
    "purged": number;
}

models/RawContent

export interface RawContent {
    "kind": RawContentKind;
    "raw": string;
    "reason": RawContentReason;
}

models/RawContentKind

export declare enum RawContentKind {
    RAW = "raw"
}

models/RawContentReason

export declare enum RawContentReason {
    TRUNCATED = "truncated",
    INVALID_JSON = "invalid_json",
    UNPARSED = "unparsed"
}

models/RegistryAccess

export interface RegistryAccess {
    "ca_pem"?: string | null;
    "password"?: string | null;
    "username"?: string | null;
}

models/ResourceSummary

export interface ResourceSummary {
    "running_count": number;
    "stopped_count": number;
    "suspended_count": number;
    "total_cpus": number;
    "total_ram_mb": number;
}

models/RestartAuthentication

export declare enum RestartAuthentication {
    NEW_TOKEN_REQUIRED = "new_token_required"
}

models/RestartResponse

export interface RestartResponse {
    "authentication": RestartAuthentication;
    "manager": ServiceManager;
    "status": RestartStatus;
}

models/RestartStatus

export declare enum RestartStatus {
    ACCEPTED = "accepted"
}

models/RevokedCredentialAuthority

export declare enum RevokedCredentialAuthority {
    REVOKED = "revoked"
}

models/RevokeSessionGrantResponse

export interface RevokeSessionGrantResponse {
    "grant": SessionGrantSummary;
    "local_authority": RevokedCredentialAuthority;
}

models/RunRequest

export interface RunRequest {
    "command": string;
    "cpus"?: number | null;
    "env"?: Record<string, string> | null;
    "ram_mb"?: number | null;
    "timeout_secs"?: number | null;
}

models/SandboxInfo

export interface SandboxInfo {
    "ai"?: null | VmAiInfo;
    "allowed_requests"?: number | null;
    "app"?: null | ImageApp;
    "available_actions": Array<VmAction>;
    "browser_request"?: null | BrowserRequest;
    "can_resume"?: boolean;
    "cost_coverage"?: null | CostCoverage;
    "cpus"?: number | null;
    "created_at"?: string | null;
    "denied_requests"?: number | null;
    "description"?: string | null;
    "files"?: null | VmFilesInfo;
    "forked_from"?: string | null;
    "id": string;
    "labels"?: Record<string, string> | null;
    "last_error"?: string | null;
    "model_call_count"?: number | null;
    "name"?: string | null;
    "network"?: null | VmNetworkInfo;
    "pending_approval_count"?: number;
    "persistent"?: boolean;
    "pid": number;
    "ram_mb"?: number | null;
    "resume_blocked_reason"?: string | null;
    "session_db"?: null | SessionDbStatus;
    "size_bytes"?: number | null;
    "status": VmLifecycleState;
    "storage"?: null | StorageDiagnostics;
    "terminal"?: null | TerminalSummary;
    "total_estimated_cost"?: number | null;
    "total_file_events"?: number | null;
    "total_input_tokens"?: number | null;
    "total_output_tokens"?: number | null;
    "total_requests"?: number | null;
    "total_thinking_tokens"?: number | null;
    "total_tool_calls"?: number | null;
    "uptime_secs"?: number | null;
    "version"?: string | null;
}

models/ScopeProfileSummary

export interface ScopeProfileSummary {
    "application_label": string;
    "capabilities": Array<CapabilitySummary>;
    "enabled": boolean;
    "enrollment_kind": EnrollmentKind;
    "id": string;
    "label": string;
    "requested_scopes": Array<string>;
}

models/SecurityAskDecision

export declare enum SecurityAskDecision {
    APPROVE = "approve",
    DENY = "deny"
}

models/SecurityAskListResponse

export interface SecurityAskListResponse {
    "generation": string;
    "pending_count": number;
    "requests": Array<SecurityAskRequest>;
    "vm_id": string;
}

models/SecurityAskRequest

export interface SecurityAskRequest {
    "ask_id": string;
    "created_at_unix_ms": number;
    "event_id": string;
    "event_type": string;
    "expires_at_unix_ms": number;
    "resolution_reason"?: string | null;
    "resolved_at_unix_ms"?: number | null;
    "rule_id": string;
    "rule_name": string;
    "status": SecurityAskStatus;
    "summary": string;
}

models/SecurityAskResolveRequest

export interface SecurityAskResolveRequest {
    "decision": SecurityAskDecision;
    "generation": string;
}

models/SecurityAskStatus

export declare enum SecurityAskStatus {
    PENDING = "pending",
    APPROVED = "approved",
    DENIED = "denied",
    EXPIRED = "expired",
    CANCELLED = "cancelled"
}

models/ServiceAvailability

export declare enum ServiceAvailability {
    RUNNING = "running",
    UNAVAILABLE = "unavailable"
}

models/ServiceManager

export declare enum ServiceManager {
    LAUNCHD = "launchd",
    SYSTEMD = "systemd"
}

models/SessionDbStatus

export interface SessionDbStatus {
    "error"?: string | null;
    "ready": boolean;
}

models/SessionGrantListResponse

export interface SessionGrantListResponse {
    "denied_capability_ids": Array<string>;
    "grants": Array<SessionGrantSummary>;
    "owner_generation": string;
    "session_id": string;
}

models/SessionGrantSummary

export interface SessionGrantSummary {
    "capability_ids": Array<string>;
    "connection_id": string;
    "created_at": string;
    "expires_at": string;
    "id": string;
    "owner_generation": string;
    "revision": number;
    "revoked_at": string | null;
    "runtime_bound": boolean;
    "session_id": string;
    "state": GrantState;
}

models/SlowOpEvent

export interface SlowOpEvent {
    "binary": string;
    "duration_ms": number;
    "op": string;
    "ts": string;
}

models/StopProxyResponse

export interface StopProxyResponse {
    "session_id": string;
    "stopped": boolean;
}

models/StopResponse

export interface StopResponse {
    "persistent": boolean;
    "success": boolean;
}

models/StorageDiagnostics

export interface StorageDiagnostics {
    "guest_overlay_device": string;
    "guest_overlay_mount": string;
    "host_available_bytes": number;
    "host_free_bytes": number;
    "host_total_bytes": number;
    "rootfs_image_logical_bytes": number;
    "rootfs_image_path": string;
    "rootfs_image_physical_bytes": number;
}

models/StreamControl

export type StreamControl = StreamControlStart | StreamControlResize | StreamControlFocus | StreamControlCloseStdin;

models/StreamControlCloseStdin

export interface StreamControlCloseStdin {
    "type": "close_stdin";
}

models/StreamControlFocus

export interface StreamControlFocus {
    "cols": number;
    "rows": number;
    "type": "focus";
}

models/StreamControlResize

export interface StreamControlResize {
    "cols": number;
    "rows": number;
    "type": "resize";
}

models/StreamControlStart

export interface StreamControlStart {
    "command"?: string | null;
    "kind": StreamKind;
    "type": "start";
}

models/StreamKind

export declare enum StreamKind {
    TERMINAL = "terminal",
    EXEC = "exec",
    CONTAINER = "container"
}

models/StreamStatus

export type StreamStatus = StreamStatusStarted | StreamStatusTerminal | StreamStatusExit | StreamStatusError;

models/StreamStatusError

export interface StreamStatusError {
    "message": string;
    "type": "error";
}

models/StreamStatusExit

export interface StreamStatusExit {
    "code": number;
    "truncated": boolean;
    "type": "exit";
}

models/StreamStatusStarted

export interface StreamStatusStarted {
    "type": "started";
}

models/StreamStatusTerminal

export interface StreamStatusTerminal {
    "state": TerminalState;
    "type": "terminal";
}

models/SupplyChainChannelEvidence

export interface SupplyChainChannelEvidence {
    "sha256"?: string | null;
    "url"?: string | null;
}

models/SupplyChainEvidence

export interface SupplyChainEvidence {
    "attestations": Array<SupplyChainReference>;
    "channel_index": SupplyChainChannelEvidence;
    "host_sbom": SupplyChainReference;
    "manifest": SupplyChainManifestEvidence;
    "vm_obom": SupplyChainReference;
}

models/SupplyChainManifestEvidence

export interface SupplyChainManifestEvidence {
    "blake3"?: string | null;
    "origin"?: string | null;
    "path": string;
    "source"?: string | null;
}

models/SupplyChainReference

export interface SupplyChainReference {
    "format"?: string | null;
    "generator"?: string | null;
    "name": string;
    "release_artifact"?: string | null;
    "route"?: string | null;
    "scope"?: string | null;
    "workflow"?: string | null;
}

models/TerminalCursor

export interface TerminalCursor {
    "col": number;
    "hidden": boolean;
    "row": number;
}

models/TerminalEvent

export interface TerminalEvent {
    "kind": TerminalEventKind;
    "notification"?: null | TerminalNotification;
    "visual": boolean;
}

models/TerminalEventKind

export declare enum TerminalEventKind {
    BELL = "bell",
    NOTIFICATION = "notification"
}

models/TerminalModes

export interface TerminalModes {
    "alternate_screen": boolean;
    "application_cursor": boolean;
    "application_keypad": boolean;
    "bracketed_paste": boolean;
    "mouse_encoding": string;
    "mouse_protocol": string;
}

models/TerminalNotification

export interface TerminalNotification {
    "body": string;
    "id": string;
    "title": string;
}

models/TerminalState

export interface TerminalState {
    "bell_count": number;
    "cols": number;
    "cursor": TerminalCursor;
    "events": Array<TerminalEvent>;
    "icon_name": string;
    "last_notification"?: null | TerminalNotification;
    "modes": TerminalModes;
    "reset": boolean;
    "revision": number;
    "rows": number;
    "title": string;
}

models/TerminalSummary

export interface TerminalSummary {
    "bell_count": number;
    "last_notification"?: null | TerminalNotification;
    "revision": number;
    "title": string;
}

models/TextContent

export interface TextContent {
    "kind": TextContentKind;
    "text": string;
}

models/TextContentKind

export declare enum TextContentKind {
    TEXT = "text"
}

models/TimelineEvent

export interface TimelineEvent {
    "duration_ms"?: number | null;
    "layer": TimelineLayer;
    "ref": TimelineReference;
    "status"?: null | TimelineStatus;
    "summary": string;
    "timestamp": string;
    "trace_id"?: string | null;
}

models/TimelineLayer

export declare enum TimelineLayer {
    EXEC = "exec",
    TOOL = "tool",
    NET = "net",
    FS = "fs",
    MODEL = "model"
}

models/TimelineReference

export type TimelineReference = number | string;

models/TimelineResponse

export interface TimelineResponse {
    "events": Array<TimelineEvent>;
}

models/TimelineStatus

export type TimelineStatus = number | ToolDecision;

models/ToolDecision

export declare enum ToolDecision {
    ALLOWED = "allowed",
    DENIED = "denied",
    WARNED = "warned",
    ERROR = "error"
}

models/ToolEvent

export interface ToolEvent {
    "arguments"?: string | null;
    "bytes": number;
    "call_id": string;
    "credential_ref"?: string | null;
    "decision": ToolDecision;
    "duration_ms": number;
    "error_message"?: string | null;
    "event_id": string;
    "method"?: string | null;
    "model_call_id"?: number | null;
    "model_parent_missing": boolean;
    "process_name"?: string | null;
    "response_event_id"?: string | null;
    "response_preview"?: string | null;
    "server_name": string;
    "source": ToolOrigin;
    "timestamp"?: string | null;
    "tool_name": string;
}

models/ToolOrigin

export declare enum ToolOrigin {
    MODEL = "model",
    NATIVE = "native",
    MCP = "mcp",
    BUILTIN = "builtin",
    LOCAL = "local",
    MCP_PROXY = "mcp_proxy"
}

models/TransactionState

export declare enum TransactionState {
    PENDING = "pending",
    CONNECTED = "connected",
    DENIED = "denied",
    EXPIRED = "expired",
    CANCELLED = "cancelled",
    FAILED = "failed"
}

models/TriageResponse

export interface TriageResponse {
    "host": HostTriageResponse;
    "rank": Array<string>;
    "session": JSONType;
    "session_id"?: string | null;
    "since": string;
}

models/UpdateActionResponse

export interface UpdateActionResponse {
    "command": UpdateCommandPlan;
    "exit_code"?: number | null;
    "status": UpdateActionStatus;
    "stderr"?: string | null;
    "stdout"?: string | null;
}

models/UpdateActionStatus

export declare enum UpdateActionStatus {
    PLANNED = "planned",
    SUCCEEDED = "succeeded",
    FAILED = "failed"
}

models/UpdateApplyRequest

export interface UpdateApplyRequest {
    "confirmed"?: boolean;
    "dry_run"?: boolean;
}

models/UpdateCheckRequest

export interface UpdateCheckRequest {
    "dry_run"?: boolean;
}

models/UpdateCommandPlan

export interface UpdateCommandPlan {
    "args": Array<string>;
    "program": string;
}

models/UpdateCompatibilityState

export declare enum UpdateCompatibilityState {
    COMPATIBLE = "compatible",
    UNKNOWN = "unknown",
    NOT_APPLICABLE = "not_applicable"
}

models/UpdateStatusResponse

export interface UpdateStatusResponse {
    "assets": UpdateTrackStatus;
    "binary": UpdateTrackStatus;
    "channel_hash"?: string | null;
    "channel_url"?: string | null;
    "checked_at"?: number | null;
    "images": UpdateTrackStatus;
    "last_error"?: string | null;
    "stale": boolean;
    "supply_chain": SupplyChainEvidence;
    "validation_error"?: string | null;
    "validation_status"?: null | ValidationStatus;
}

models/UpdateTrackState

export declare enum UpdateTrackState {
    CURRENT = "current",
    UPDATE_AVAILABLE = "update_available",
    UNKNOWN = "unknown",
    NOT_PUBLISHED = "not_published"
}

models/UpdateTrackStatus

export interface UpdateTrackStatus {
    "blocked_reason"?: string | null;
    "compatibility": UpdateCompatibilityState;
    "current"?: string | null;
    "latest"?: string | null;
    "state": UpdateTrackState;
    "update_available": boolean;
}

models/UploadResponse

export interface UploadResponse {
    "container_path"?: string | null;
    "size": number;
    "success": boolean;
    "vm_path": string;
}

models/ValidationStatus

export declare enum ValidationStatus {
    VALID = "valid",
    INVALID = "invalid",
    MISSING = "missing",
    FETCH_ERROR = "fetch_error"
}

models/Value

export type Value = JSONType;

models/VmAction

export declare enum VmAction {
    PAUSE = "pause",
    STOP = "stop",
    START = "start",
    RESUME = "resume",
    FORK = "fork",
    DELETE = "delete"
}

models/VmActionResponse

export interface VmActionResponse {
    "success": boolean;
}

models/VmAiInfo

export interface VmAiInfo {
    "cost_coverage"?: null | CostCoverage;
    "mcp": Array<McpUsage>;
    "model_call_count": number;
    "models": Array<ModelUsage>;
    "total_estimated_cost_usd": number;
    "total_input_tokens": number;
    "total_output_tokens": number;
    "total_thinking_tokens": number;
    "total_tool_calls": number;
}

models/VmFilesInfo

export interface VmFilesInfo {
    "actions": Array<FileActionCount>;
    "total_events": number;
}

models/VmLifecycleState

export declare enum VmLifecycleState {
    RUNNING = "Running",
    STOPPED = "Stopped",
    SUSPENDED = "Suspended",
    DEFUNCT = "Defunct",
    INCOMPATIBLE = "Incompatible"
}

models/VmNetworkInfo

export interface VmNetworkInfo {
    "allowed_requests": number;
    "bytes_received": number;
    "bytes_sent": number;
    "denied_requests": number;
    "errors": number;
    "total_requests": number;
}

models/VmStatsDetailResponse

export interface VmStatsDetailResponse {
    "audit_events": Array<AuditEvent>;
    "body_blobs": Record<string, Array<EventBody>>;
    "credential_events": Array<CredentialEvent>;
    "dns_events": Array<DnsEvent>;
    "file_events": Array<FileEvent>;
    "http_events": Array<HttpEvent>;
    "interactions": InteractionReport;
    "model_events": Array<ModelEvent>;
    "model_stats": Array<ModelUsage>;
    "process_events": Array<ProcessEvent>;
    "tool_events": Array<ToolEvent>;
}

models/VmStatsSummaryResponse

export interface VmStatsSummaryResponse {
    "allowed_requests": number;
    "cost_coverage"?: null | CostCoverage;
    "denied_requests": number;
    "total_estimated_cost": number;
    "total_input_tokens": number;
    "total_output_tokens": number;
    "total_requests": number;
    "total_thinking_tokens": number;
    "total_tool_calls": number;
}

models/VmStatusResponse

export interface VmStatusResponse {
    "available_actions": Array<VmAction>;
    "can_resume"?: boolean;
    "created_at"?: string | null;
    "id": string;
    "last_error"?: string | null;
    "name": string;
    "pending_approval_count"?: number;
    "persistent"?: boolean;
    "pid"?: number | null;
    "resume_blocked_reason"?: string | null;
    "status": VmLifecycleState;
    "storage"?: null | StorageDiagnostics;
    "uptime_secs"?: number | null;
}

models/VmSummary

export interface VmSummary {
    "allowed_requests"?: number | null;
    "app"?: null | ImageApp;
    "available_actions": Array<VmAction>;
    "browser_request"?: null | BrowserRequest;
    "can_resume"?: boolean;
    "cost_coverage"?: null | CostCoverage;
    "denied_requests"?: number | null;
    "id": string;
    "last_error"?: string | null;
    "model_call_count"?: number | null;
    "name"?: string | null;
    "pending_approval_count"?: number;
    "persistent": boolean;
    "resume_blocked_reason"?: string | null;
    "status": VmLifecycleState;
    "terminal"?: null | TerminalSummary;
    "total_estimated_cost"?: number | null;
    "total_file_events"?: number | null;
    "total_input_tokens"?: number | null;
    "total_output_tokens"?: number | null;
    "total_requests"?: number | null;
    "total_tool_calls"?: number | null;
    "uptime_secs"?: number | null;
}

operations/acknowledgeBrowserRequest

export declare function acknowledgeBrowserRequest(transport: Transport, parameters: {
    "id": string;
    "body": BrowserAcknowledgeRequest;
}, options?: CallOptions): Promise<BrowserAcknowledgeResponse>;

operations/attachNetworkMember

export declare function attachNetworkMember(transport: Transport, parameters: {
    "id": string;
    "vm_id": string;
}, options?: CallOptions): Promise<NetworkInfo>;

operations/authorizeGoogleConnection

export declare function authorizeGoogleConnection(transport: Transport, parameters: {
    "body": AuthorizeGoogleRequest;
}, options?: CallOptions): Promise<AuthorizeGoogleResponse>;

operations/callMcpTool

export declare function callMcpTool(transport: Transport, parameters: {
    "server_id": string;
    "tool_id": string;
    "body": Value;
}, options?: CallOptions): Promise<Value>;

operations/cancelConnectionAuthorization

export declare function cancelConnectionAuthorization(transport: Transport, parameters: {
    "transaction_id": string;
}, options?: CallOptions): Promise<AuthorizationTransaction>;

operations/checkHypervisorUpdate

export declare function checkHypervisorUpdate(transport: Transport, parameters: {
    "body": UpdateCheckRequest;
}, options?: CallOptions): Promise<UpdateActionResponse>;

operations/claimManagedSession

export declare function claimManagedSession(transport: Transport, parameters: {
    "request_id": string;
    "body": ManagedSessionClaimRequest;
}, options?: CallOptions): Promise<ManagedSessionClaimResponse>;

operations/closeManagedSession

export declare function closeManagedSession(transport: Transport, parameters: {
    "request_id": string;
    "body": ManagedSessionCloseRequest;
}, options?: CallOptions): Promise<ManagedSessionCloseResponse>;

operations/createNetwork

export declare function createNetwork(transport: Transport, parameters: {
    "body": CreateNetworkRequest;
}, options?: CallOptions): Promise<NetworkInfo>;

operations/createProxy

export declare function createProxy(transport: Transport, parameters: {
    "body": CreateProxyRequest;
}, options?: CallOptions): Promise<CreateProxyResponse>;

operations/createSessionCredentialGrant

export declare function createSessionCredentialGrant(transport: Transport, parameters: {
    "id": string;
    "body": CreateSessionGrantRequest;
}, options?: CallOptions): Promise<SessionGrantSummary>;

operations/createVm

export declare function createVm(transport: Transport, parameters: {
    "body": ProvisionRequest;
}, options?: CallOptions): Promise<ProvisionResponse>;

operations/createVmExposure

export declare function createVmExposure(transport: Transport, parameters: {
    "id": string;
    "body": ExposureRequest;
}, options?: CallOptions): Promise<ExposureInfo>;

operations/createVmPreviewSession

export declare function createVmPreviewSession(transport: Transport, parameters: {
    "id": string;
    "exposure_id": string;
}, options?: CallOptions): Promise<PreviewSessionResponse>;

operations/deleteNetwork

export declare function deleteNetwork(transport: Transport, parameters: {
    "id": string;
}, options?: CallOptions): Promise<VmActionResponse>;

operations/deleteVm

export declare function deleteVm(transport: Transport, parameters: {
    "id": string;
}, options?: CallOptions): Promise<VmActionResponse>;

operations/deleteVmExposure

export declare function deleteVmExposure(transport: Transport, parameters: {
    "id": string;
    "exposure_id": string;
}, options?: CallOptions): Promise<VmActionResponse>;

operations/detachNetworkMember

export declare function detachNetworkMember(transport: Transport, parameters: {
    "id": string;
    "vm_id": string;
}, options?: CallOptions): Promise<NetworkInfo>;

operations/disconnectConnection

export declare function disconnectConnection(transport: Transport, parameters: {
    "connection_id": string;
}, options?: CallOptions): Promise<DisconnectResponse>;

operations/downloadVmFile

export declare function downloadVmFile(transport: Transport, parameters: {
    "id": string;
    "path": string;
    "exact"?: boolean;
}, options?: CallOptions): Promise<Uint8Array>;

operations/execVm

export declare function execVm(transport: Transport, parameters: {
    "id": string;
    "body": ExecRequest;
}, options?: CallOptions): Promise<ExecResponse>;

operations/exportVmBodies

export declare function exportVmBodies(transport: Transport, parameters: {
    "id": string;
}, options?: CallOptions): Promise<Uint8Array>;

operations/forkVm

export declare function forkVm(transport: Transport, parameters: {
    "id": string;
    "body": ForkRequest;
}, options?: CallOptions): Promise<ForkResponse>;

operations/getAssetStatus

export declare function getAssetStatus(transport: Transport, options?: CallOptions): Promise<AssetStatus>;

operations/getConnection

export declare function getConnection(transport: Transport, parameters: {
    "connection_id": string;
}, options?: CallOptions): Promise<ConnectionSummary>;

operations/getConnectionAuthorization

export declare function getConnectionAuthorization(transport: Transport, parameters: {
    "transaction_id": string;
}, options?: CallOptions): Promise<AuthorizationTransaction>;

operations/getHypervisorInfo

export declare function getHypervisorInfo(transport: Transport, options?: CallOptions): Promise<HypervisorInfo>;

operations/getHypervisorLogs

export declare function getHypervisorLogs(transport: Transport, parameters: {
    "name": HostLogSource;
    "grep"?: string;
    "tail"?: number;
    "max_bytes"?: number;
}, options?: CallOptions): Promise<HostLogsResponse>;

operations/getImageInventory

export declare function getImageInventory(transport: Transport, parameters: {
    "name": string;
    "image": string;
}, options?: CallOptions): Promise<ImageInventoryResponse>;

operations/getMcpDefault

export declare function getMcpDefault(transport: Transport, options?: CallOptions): Promise<McpDefaultPermissionResponse>;

operations/getMcpInfo

export declare function getMcpInfo(transport: Transport, options?: CallOptions): Promise<McpInfoResponse>;

operations/getNetwork

export declare function getNetwork(transport: Transport, parameters: {
    "id": string;
}, options?: CallOptions): Promise<NetworkInfo>;

operations/getNetworkLogs

export declare function getNetworkLogs(transport: Transport, parameters: {
    "id": string;
    "cursor"?: string | null;
    "limit"?: number | null;
    "vm"?: string | null;
    "connection"?: string | null;
    "type"?: string | null;
    "decision"?: string | null;
    "since"?: number | null;
    "until"?: number | null;
}, options?: CallOptions): Promise<NetworkLogsResponse>;

operations/getPanics

export declare function getPanics(transport: Transport, parameters?: {
    "since"?: string | null;
    "limit"?: number | null;
    "id"?: string | null;
}, options?: CallOptions): Promise<PanicsResponse>;

operations/getTriage

export declare function getTriage(transport: Transport, parameters?: {
    "since"?: string | null;
    "limit"?: number | null;
    "id"?: string | null;
}, options?: CallOptions): Promise<TriageResponse>;

operations/getUpdateStatus

export declare function getUpdateStatus(transport: Transport, options?: CallOptions): Promise<UpdateStatusResponse>;

operations/getVmContainer

export declare function getVmContainer(transport: Transport, parameters: {
    "id": string;
}, options?: CallOptions): Promise<ContainerStatusResponse>;

operations/getVmEventBodies

export declare function getVmEventBodies(transport: Transport, parameters: {
    "id": string;
    "event_id": string;
    "max_bytes"?: number | null;
}, options?: CallOptions): Promise<EventBodiesResponse>;

operations/getVmHistory

export declare function getVmHistory(transport: Transport, parameters: {
    "id": string;
    "limit"?: number;
    "offset"?: number;
    "search"?: string;
    "layer"?: HistoryLayerFilter;
}, options?: CallOptions): Promise<HistoryResponse>;

operations/getVmInfo

export declare function getVmInfo(transport: Transport, parameters: {
    "id": string;
}, options?: CallOptions): Promise<SandboxInfo>;

operations/getVmLogs

export declare function getVmLogs(transport: Transport, parameters: {
    "id": string;
    "grep"?: string;
    "tail"?: number;
    "max_bytes"?: number;
}, options?: CallOptions): Promise<LogsResponse>;

operations/getVmStatsDetail

export declare function getVmStatsDetail(transport: Transport, parameters: {
    "id": string;
}, options?: CallOptions): Promise<VmStatsDetailResponse>;

operations/getVmStatsSummary

export declare function getVmStatsSummary(transport: Transport, parameters: {
    "id": string;
}, options?: CallOptions): Promise<VmStatsSummaryResponse>;

operations/getVmStatus

export declare function getVmStatus(transport: Transport, parameters: {
    "id": string;
}, options?: CallOptions): Promise<VmStatusResponse>;

operations/getVmTimeline

export declare function getVmTimeline(transport: Transport, parameters: {
    "id": string;
    "trace_id"?: string;
    "since"?: string;
    "limit"?: number;
    "layers"?: Array<TimelineLayer>;
}, options?: CallOptions): Promise<TimelineResponse>;

operations/heartbeatProxy

export declare function heartbeatProxy(transport: Transport, parameters: {
    "id": string;
    "body": ProxyLeaseRequest;
}, options?: CallOptions): Promise<ProxyHeartbeatResponse>;

operations/injectCredential

export declare function injectCredential(transport: Transport, parameters: {
    "body": CredentialInjectRequest;
}, options?: CallOptions): Promise<CredentialInjectResponse>;

operations/listConnections

export declare function listConnections(transport: Transport, parameters?: {
    "limit"?: number;
    "cursor"?: string;
}, options?: CallOptions): Promise<ConnectionListResponse>;

operations/listImages

export declare function listImages(transport: Transport, parameters?: {
    "refresh"?: boolean;
}, options?: CallOptions): Promise<ImageListResponse>;

operations/listMcpServers

export declare function listMcpServers(transport: Transport, options?: CallOptions): Promise<McpServersListResponse>;

operations/listMcpTools

export declare function listMcpTools(transport: Transport, parameters: {
    "server_id": string;
}, options?: CallOptions): Promise<McpToolsListResponse>;

operations/listNetworks

export declare function listNetworks(transport: Transport, options?: CallOptions): Promise<NetworkListResponse>;

operations/listSecurityAsks

export declare function listSecurityAsks(transport: Transport, parameters: {
    "id": string;
    "limit"?: number;
}, options?: CallOptions): Promise<SecurityAskListResponse>;

operations/listSessionCredentialGrants

export declare function listSessionCredentialGrants(transport: Transport, parameters: {
    "id": string;
}, options?: CallOptions): Promise<SessionGrantListResponse>;

operations/listVmExposures

export declare function listVmExposures(transport: Transport, parameters: {
    "id": string;
}, options?: CallOptions): Promise<ExposureListResponse>;

operations/listVmFiles

export declare function listVmFiles(transport: Transport, parameters: {
    "id": string;
    "path"?: string;
    "depth"?: number;
    "exact"?: boolean;
}, options?: CallOptions): Promise<FileListResponse>;

operations/listVms

export declare function listVms(transport: Transport, options?: CallOptions): Promise<ListResponse>;

operations/pauseVm

export declare function pauseVm(transport: Transport, parameters: {
    "id": string;
}, options?: CallOptions): Promise<VmActionResponse>;

operations/persistVm

export declare function persistVm(transport: Transport, parameters: {
    "id": string;
    "body": PersistRequest;
}, options?: CallOptions): Promise<PersistResponse>;

operations/pullImage

export declare function pullImage(transport: Transport, parameters: {
    "body": ImagePullRequest;
}, options?: CallOptions): Promise<ImagePullResponse>;

operations/purgeVms

export declare function purgeVms(transport: Transport, parameters: {
    "body": PurgeRequest;
}, options?: CallOptions): Promise<PurgeResponse>;

operations/refreshMcpServer

export declare function refreshMcpServer(transport: Transport, parameters: {
    "server_id": string;
}, options?: CallOptions): Promise<McpRefreshResponse>;

operations/resolveSecurityAsk

export declare function resolveSecurityAsk(transport: Transport, parameters: {
    "id": string;
    "ask_id": string;
    "body": SecurityAskResolveRequest;
}, options?: CallOptions): Promise<SecurityAskRequest>;

operations/restartHypervisor

export declare function restartHypervisor(transport: Transport, options?: CallOptions): Promise<RestartResponse>;

operations/resumeVm

export declare function resumeVm(transport: Transport, parameters: {
    "id": string;
}, options?: CallOptions): Promise<ProvisionResponse>;

operations/revokeSessionCredentialGrant

export declare function revokeSessionCredentialGrant(transport: Transport, parameters: {
    "id": string;
    "grant_id": string;
}, options?: CallOptions): Promise<RevokeSessionGrantResponse>;

operations/revokeVmPreviewSessions

export declare function revokeVmPreviewSessions(transport: Transport, parameters: {
    "id": string;
    "exposure_id": string;
}, options?: CallOptions): Promise<PreviewSessionsRevokedResponse>;

operations/runVm

export declare function runVm(transport: Transport, parameters: {
    "body": RunRequest;
}, options?: CallOptions): Promise<ExecResponse>;

operations/startVm

export declare function startVm(transport: Transport, parameters: {
    "id": string;
}, options?: CallOptions): Promise<ProvisionResponse>;

operations/stopProxy

export declare function stopProxy(transport: Transport, parameters: {
    "id": string;
    "body": ProxyLeaseRequest;
}, options?: CallOptions): Promise<StopProxyResponse>;

operations/stopVm

export declare function stopVm(transport: Transport, parameters: {
    "id": string;
}, options?: CallOptions): Promise<StopResponse>;

operations/updateHypervisor

export declare function updateHypervisor(transport: Transport, parameters: {
    "body": UpdateApplyRequest;
}, options?: CallOptions): Promise<UpdateActionResponse>;

operations/uploadVmFile

export declare function uploadVmFile(transport: Transport, parameters: {
    "id": string;
    "path": string;
    "exact"?: boolean;
    "body": Uint8Array;
}, options?: CallOptions): Promise<UploadResponse>;