TypeScript SDK reference

Public signatures and types from the TypeScript SDK, including resource helpers and model contracts. 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;
    }): 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>;
    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>;
}

registry

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

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/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/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/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/ImageCacheState

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

validation/ImageInfo

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

validation/ImageListResponse

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

validation/ImagePullRequest

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

validation/ImagePullResponse

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

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/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/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/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/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/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/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/ErrorEvent

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

models/ErrorResponse

export interface ErrorResponse {
    "code"?: string | null;
    "error": string;
}

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;
    "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/ImageCacheState

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

models/ImageInfo

export interface ImageInfo {
    "architectures": Array<string>;
    "cached": ImageCacheState;
    "description": string;
    "image"?: string | null;
    "name": string;
}

models/ImageListResponse

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

models/ImagePullRequest

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

models/ImagePullResponse

export interface ImagePullResponse {
    "digest": string;
    "image": string;
    "resolved": 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;
    "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;
    "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;
    "available_actions": Array<VmAction>;
    "can_resume"?: boolean;
    "cpus"?: number | null;
    "created_at"?: string | null;
    "denied_requests"?: number | null;
    "description"?: string | null;
    "files"?: null | VmFilesInfo;
    "forked_from"?: string | null;
    "id": string;
    "last_error"?: string | null;
    "model_call_count"?: number | null;
    "name"?: string | null;
    "network"?: null | VmNetworkInfo;
    "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;
    "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/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/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/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/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 {
    "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;
    "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;
    "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;
    "available_actions": Array<VmAction>;
    "can_resume"?: boolean;
    "denied_requests"?: number | null;
    "id": string;
    "last_error"?: string | null;
    "model_call_count"?: number | null;
    "name"?: string | null;
    "persistent": boolean;
    "resume_blocked_reason"?: string | null;
    "status": VmLifecycleState;
    "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/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/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/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/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/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>;