@secure-exec/core 0.0.0-split-runtime-preview.7b0dded

package/dist/generated-protocol.d.ts

@@ -0,0 +1,1038 @@
+import * as bare from "@rivetkit/bare-ts";
+export type i32 = number;
+export type i64 = bigint;
+export type u16 = number;
+export type u32 = number;
+export type u64 = bigint;
+export type JsonUtf8 = string;
+export declare function readJsonUtf8(bc: bare.ByteCursor): JsonUtf8;
+export declare function writeJsonUtf8(bc: bare.ByteCursor, x: JsonUtf8): void;
+export type ProtocolSchema = {
+    readonly name: string;
+    readonly version: u16;
+};
+export declare function readProtocolSchema(bc: bare.ByteCursor): ProtocolSchema;
+export declare function writeProtocolSchema(bc: bare.ByteCursor, x: ProtocolSchema): void;
+export type RequestId = i64;
+export declare function readRequestId(bc: bare.ByteCursor): RequestId;
+export declare function writeRequestId(bc: bare.ByteCursor, x: RequestId): void;
+export type ExtEnvelope = {
+    readonly namespace: string;
+    readonly payload: ArrayBuffer;
+};
+export declare function readExtEnvelope(bc: bare.ByteCursor): ExtEnvelope;
+export declare function writeExtEnvelope(bc: bare.ByteCursor, x: ExtEnvelope): void;
+export type ConnectionOwnership = {
+    readonly connectionId: string;
+};
+export declare function readConnectionOwnership(bc: bare.ByteCursor): ConnectionOwnership;
+export declare function writeConnectionOwnership(bc: bare.ByteCursor, x: ConnectionOwnership): void;
+export type SessionOwnership = {
+    readonly connectionId: string;
+    readonly sessionId: string;
+};
+export declare function readSessionOwnership(bc: bare.ByteCursor): SessionOwnership;
+export declare function writeSessionOwnership(bc: bare.ByteCursor, x: SessionOwnership): void;
+export type VmOwnership = {
+    readonly connectionId: string;
+    readonly sessionId: string;
+    readonly vmId: string;
+};
+export declare function readVmOwnership(bc: bare.ByteCursor): VmOwnership;
+export declare function writeVmOwnership(bc: bare.ByteCursor, x: VmOwnership): void;
+export type OwnershipScope = {
+    readonly tag: "ConnectionOwnership";
+    readonly val: ConnectionOwnership;
+} | {
+    readonly tag: "SessionOwnership";
+    readonly val: SessionOwnership;
+} | {
+    readonly tag: "VmOwnership";
+    readonly val: VmOwnership;
+};
+export declare function readOwnershipScope(bc: bare.ByteCursor): OwnershipScope;
+export declare function writeOwnershipScope(bc: bare.ByteCursor, x: OwnershipScope): void;
+export type AuthenticateRequest = {
+    readonly clientName: string;
+    readonly authToken: string;
+    readonly protocolVersion: u16;
+    readonly bridgeVersion: u32;
+};
+export declare function readAuthenticateRequest(bc: bare.ByteCursor): AuthenticateRequest;
+export declare function writeAuthenticateRequest(bc: bare.ByteCursor, x: AuthenticateRequest): void;
+export type SidecarPlacementShared = {
+    readonly pool: string | null;
+};
+export declare function readSidecarPlacementShared(bc: bare.ByteCursor): SidecarPlacementShared;
+export declare function writeSidecarPlacementShared(bc: bare.ByteCursor, x: SidecarPlacementShared): void;
+export type SidecarPlacementExplicit = {
+    readonly sidecarId: string;
+};
+export declare function readSidecarPlacementExplicit(bc: bare.ByteCursor): SidecarPlacementExplicit;
+export declare function writeSidecarPlacementExplicit(bc: bare.ByteCursor, x: SidecarPlacementExplicit): void;
+export type SidecarPlacement = {
+    readonly tag: "SidecarPlacementShared";
+    readonly val: SidecarPlacementShared;
+} | {
+    readonly tag: "SidecarPlacementExplicit";
+    readonly val: SidecarPlacementExplicit;
+};
+export declare function readSidecarPlacement(bc: bare.ByteCursor): SidecarPlacement;
+export declare function writeSidecarPlacement(bc: bare.ByteCursor, x: SidecarPlacement): void;
+export type OpenSessionRequest = {
+    readonly placement: SidecarPlacement;
+    readonly metadata: ReadonlyMap<string, string>;
+};
+export declare function readOpenSessionRequest(bc: bare.ByteCursor): OpenSessionRequest;
+export declare function writeOpenSessionRequest(bc: bare.ByteCursor, x: OpenSessionRequest): void;
+export declare enum GuestRuntimeKind {
+    JavaScript = "JavaScript",
+    Python = "Python",
+    WebAssembly = "WebAssembly"
+}
+export declare function readGuestRuntimeKind(bc: bare.ByteCursor): GuestRuntimeKind;
+export declare function writeGuestRuntimeKind(bc: bare.ByteCursor, x: GuestRuntimeKind): void;
+export declare enum RootFilesystemMode {
+    Ephemeral = "Ephemeral",
+    ReadOnly = "ReadOnly"
+}
+export declare function readRootFilesystemMode(bc: bare.ByteCursor): RootFilesystemMode;
+export declare function writeRootFilesystemMode(bc: bare.ByteCursor, x: RootFilesystemMode): void;
+export declare enum RootFilesystemEntryKind {
+    File = "File",
+    Directory = "Directory",
+    Symlink = "Symlink"
+}
+export declare function readRootFilesystemEntryKind(bc: bare.ByteCursor): RootFilesystemEntryKind;
+export declare function writeRootFilesystemEntryKind(bc: bare.ByteCursor, x: RootFilesystemEntryKind): void;
+export declare enum RootFilesystemEntryEncoding {
+    UtF8 = "UtF8",
+    BasE64 = "BasE64"
+}
+export declare function readRootFilesystemEntryEncoding(bc: bare.ByteCursor): RootFilesystemEntryEncoding;
+export declare function writeRootFilesystemEntryEncoding(bc: bare.ByteCursor, x: RootFilesystemEntryEncoding): void;
+export type RootFilesystemEntry = {
+    readonly path: string;
+    readonly kind: RootFilesystemEntryKind;
+    readonly mode: u32 | null;
+    readonly uid: u32 | null;
+    readonly gid: u32 | null;
+    readonly content: string | null;
+    readonly encoding: RootFilesystemEntryEncoding | null;
+    readonly target: string | null;
+    readonly executable: boolean;
+};
+export declare function readRootFilesystemEntry(bc: bare.ByteCursor): RootFilesystemEntry;
+export declare function writeRootFilesystemEntry(bc: bare.ByteCursor, x: RootFilesystemEntry): void;
+export type SnapshotRootFilesystemLower = {
+    readonly entries: readonly RootFilesystemEntry[];
+};
+export declare function readSnapshotRootFilesystemLower(bc: bare.ByteCursor): SnapshotRootFilesystemLower;
+export declare function writeSnapshotRootFilesystemLower(bc: bare.ByteCursor, x: SnapshotRootFilesystemLower): void;
+export type BundledBaseFilesystemLower = null;
+export type RootFilesystemLowerDescriptor = {
+    readonly tag: "SnapshotRootFilesystemLower";
+    readonly val: SnapshotRootFilesystemLower;
+} | {
+    readonly tag: "BundledBaseFilesystemLower";
+    readonly val: BundledBaseFilesystemLower;
+};
+export declare function readRootFilesystemLowerDescriptor(bc: bare.ByteCursor): RootFilesystemLowerDescriptor;
+export declare function writeRootFilesystemLowerDescriptor(bc: bare.ByteCursor, x: RootFilesystemLowerDescriptor): void;
+export type RootFilesystemDescriptor = {
+    readonly mode: RootFilesystemMode;
+    readonly disableDefaultBaseLayer: boolean;
+    readonly lowers: readonly RootFilesystemLowerDescriptor[];
+    readonly bootstrapEntries: readonly RootFilesystemEntry[];
+};
+export declare function readRootFilesystemDescriptor(bc: bare.ByteCursor): RootFilesystemDescriptor;
+export declare function writeRootFilesystemDescriptor(bc: bare.ByteCursor, x: RootFilesystemDescriptor): void;
+export declare enum PermissionMode {
+    Allow = "Allow",
+    Ask = "Ask",
+    Deny = "Deny"
+}
+export declare function readPermissionMode(bc: bare.ByteCursor): PermissionMode;
+export declare function writePermissionMode(bc: bare.ByteCursor, x: PermissionMode): void;
+export type FsPermissionRule = {
+    readonly mode: PermissionMode;
+    readonly operations: readonly string[];
+    readonly paths: readonly string[];
+};
+export declare function readFsPermissionRule(bc: bare.ByteCursor): FsPermissionRule;
+export declare function writeFsPermissionRule(bc: bare.ByteCursor, x: FsPermissionRule): void;
+export type FsPermissionRuleSet = {
+    readonly default: PermissionMode | null;
+    readonly rules: readonly FsPermissionRule[];
+};
+export declare function readFsPermissionRuleSet(bc: bare.ByteCursor): FsPermissionRuleSet;
+export declare function writeFsPermissionRuleSet(bc: bare.ByteCursor, x: FsPermissionRuleSet): void;
+export type FsPermissionScope = {
+    readonly tag: "PermissionMode";
+    readonly val: PermissionMode;
+} | {
+    readonly tag: "FsPermissionRuleSet";
+    readonly val: FsPermissionRuleSet;
+};
+export declare function readFsPermissionScope(bc: bare.ByteCursor): FsPermissionScope;
+export declare function writeFsPermissionScope(bc: bare.ByteCursor, x: FsPermissionScope): void;
+export type PatternPermissionRule = {
+    readonly mode: PermissionMode;
+    readonly operations: readonly string[];
+    readonly patterns: readonly string[];
+};
+export declare function readPatternPermissionRule(bc: bare.ByteCursor): PatternPermissionRule;
+export declare function writePatternPermissionRule(bc: bare.ByteCursor, x: PatternPermissionRule): void;
+export type PatternPermissionRuleSet = {
+    readonly default: PermissionMode | null;
+    readonly rules: readonly PatternPermissionRule[];
+};
+export declare function readPatternPermissionRuleSet(bc: bare.ByteCursor): PatternPermissionRuleSet;
+export declare function writePatternPermissionRuleSet(bc: bare.ByteCursor, x: PatternPermissionRuleSet): void;
+export type PatternPermissionScope = {
+    readonly tag: "PermissionMode";
+    readonly val: PermissionMode;
+} | {
+    readonly tag: "PatternPermissionRuleSet";
+    readonly val: PatternPermissionRuleSet;
+};
+export declare function readPatternPermissionScope(bc: bare.ByteCursor): PatternPermissionScope;
+export declare function writePatternPermissionScope(bc: bare.ByteCursor, x: PatternPermissionScope): void;
+export type PermissionsPolicy = {
+    readonly fs: FsPermissionScope | null;
+    readonly network: PatternPermissionScope | null;
+    readonly childProcess: PatternPermissionScope | null;
+    readonly process: PatternPermissionScope | null;
+    readonly env: PatternPermissionScope | null;
+    readonly tool: PatternPermissionScope | null;
+};
+export declare function readPermissionsPolicy(bc: bare.ByteCursor): PermissionsPolicy;
+export declare function writePermissionsPolicy(bc: bare.ByteCursor, x: PermissionsPolicy): void;
+export type CreateVmRequest = {
+    readonly runtime: GuestRuntimeKind;
+    readonly metadata: ReadonlyMap<string, string>;
+    readonly rootFilesystem: RootFilesystemDescriptor;
+    readonly permissions: PermissionsPolicy | null;
+};
+export declare function readCreateVmRequest(bc: bare.ByteCursor): CreateVmRequest;
+export declare function writeCreateVmRequest(bc: bare.ByteCursor, x: CreateVmRequest): void;
+export declare enum DisposeReason {
+    Requested = "Requested",
+    ConnectionClosed = "ConnectionClosed",
+    HostShutdown = "HostShutdown"
+}
+export declare function readDisposeReason(bc: bare.ByteCursor): DisposeReason;
+export declare function writeDisposeReason(bc: bare.ByteCursor, x: DisposeReason): void;
+export type DisposeVmRequest = {
+    readonly reason: DisposeReason;
+};
+export declare function readDisposeVmRequest(bc: bare.ByteCursor): DisposeVmRequest;
+export declare function writeDisposeVmRequest(bc: bare.ByteCursor, x: DisposeVmRequest): void;
+export type BootstrapRootFilesystemRequest = {
+    readonly entries: readonly RootFilesystemEntry[];
+};
+export declare function readBootstrapRootFilesystemRequest(bc: bare.ByteCursor): BootstrapRootFilesystemRequest;
+export declare function writeBootstrapRootFilesystemRequest(bc: bare.ByteCursor, x: BootstrapRootFilesystemRequest): void;
+export type MountPluginDescriptor = {
+    readonly id: string;
+    readonly config: JsonUtf8;
+};
+export declare function readMountPluginDescriptor(bc: bare.ByteCursor): MountPluginDescriptor;
+export declare function writeMountPluginDescriptor(bc: bare.ByteCursor, x: MountPluginDescriptor): void;
+export type MountDescriptor = {
+    readonly guestPath: string;
+    readonly readOnly: boolean;
+    readonly plugin: MountPluginDescriptor;
+};
+export declare function readMountDescriptor(bc: bare.ByteCursor): MountDescriptor;
+export declare function writeMountDescriptor(bc: bare.ByteCursor, x: MountDescriptor): void;
+export type SoftwareDescriptor = {
+    readonly packageName: string;
+    readonly root: string;
+};
+export declare function readSoftwareDescriptor(bc: bare.ByteCursor): SoftwareDescriptor;
+export declare function writeSoftwareDescriptor(bc: bare.ByteCursor, x: SoftwareDescriptor): void;
+export type ProjectedModuleDescriptor = {
+    readonly packageName: string;
+    readonly entrypoint: string;
+};
+export declare function readProjectedModuleDescriptor(bc: bare.ByteCursor): ProjectedModuleDescriptor;
+export declare function writeProjectedModuleDescriptor(bc: bare.ByteCursor, x: ProjectedModuleDescriptor): void;
+export declare enum WasmPermissionTier {
+    Full = "Full",
+    ReadWrite = "ReadWrite",
+    ReadOnly = "ReadOnly",
+    Isolated = "Isolated"
+}
+export declare function readWasmPermissionTier(bc: bare.ByteCursor): WasmPermissionTier;
+export declare function writeWasmPermissionTier(bc: bare.ByteCursor, x: WasmPermissionTier): void;
+export type ConfigureVmRequest = {
+    readonly mounts: readonly MountDescriptor[];
+    readonly software: readonly SoftwareDescriptor[];
+    readonly permissions: PermissionsPolicy | null;
+    readonly moduleAccessCwd: string | null;
+    readonly instructions: readonly string[];
+    readonly projectedModules: readonly ProjectedModuleDescriptor[];
+    readonly commandPermissions: ReadonlyMap<string, WasmPermissionTier>;
+    readonly allowedNodeBuiltins: readonly string[];
+    readonly loopbackExemptPorts: Uint16Array;
+};
+export declare function readConfigureVmRequest(bc: bare.ByteCursor): ConfigureVmRequest;
+export declare function writeConfigureVmRequest(bc: bare.ByteCursor, x: ConfigureVmRequest): void;
+export type RegisteredHostCallbackExample = {
+    readonly description: string;
+    readonly input: JsonUtf8;
+};
+export declare function readRegisteredHostCallbackExample(bc: bare.ByteCursor): RegisteredHostCallbackExample;
+export declare function writeRegisteredHostCallbackExample(bc: bare.ByteCursor, x: RegisteredHostCallbackExample): void;
+export type RegisteredHostCallbackDefinition = {
+    readonly description: string;
+    readonly inputSchema: JsonUtf8;
+    readonly timeoutMs: u64 | null;
+    readonly examples: readonly RegisteredHostCallbackExample[];
+};
+export declare function readRegisteredHostCallbackDefinition(bc: bare.ByteCursor): RegisteredHostCallbackDefinition;
+export declare function writeRegisteredHostCallbackDefinition(bc: bare.ByteCursor, x: RegisteredHostCallbackDefinition): void;
+export type RegisterHostCallbacksRequest = {
+    readonly name: string;
+    readonly description: string;
+    readonly commandAliases: readonly string[];
+    readonly registryCommandAliases: readonly string[];
+    readonly callbacks: ReadonlyMap<string, RegisteredHostCallbackDefinition>;
+};
+export declare function readRegisterHostCallbacksRequest(bc: bare.ByteCursor): RegisterHostCallbacksRequest;
+export declare function writeRegisterHostCallbacksRequest(bc: bare.ByteCursor, x: RegisterHostCallbacksRequest): void;
+export type CreateLayerRequest = null;
+export type SealLayerRequest = {
+    readonly layerId: string;
+};
+export declare function readSealLayerRequest(bc: bare.ByteCursor): SealLayerRequest;
+export declare function writeSealLayerRequest(bc: bare.ByteCursor, x: SealLayerRequest): void;
+export type ImportSnapshotRequest = {
+    readonly entries: readonly RootFilesystemEntry[];
+};
+export declare function readImportSnapshotRequest(bc: bare.ByteCursor): ImportSnapshotRequest;
+export declare function writeImportSnapshotRequest(bc: bare.ByteCursor, x: ImportSnapshotRequest): void;
+export type ExportSnapshotRequest = {
+    readonly layerId: string;
+};
+export declare function readExportSnapshotRequest(bc: bare.ByteCursor): ExportSnapshotRequest;
+export declare function writeExportSnapshotRequest(bc: bare.ByteCursor, x: ExportSnapshotRequest): void;
+export type CreateOverlayRequest = {
+    readonly mode: RootFilesystemMode;
+    readonly upperLayerId: string | null;
+    readonly lowerLayerIds: readonly string[];
+};
+export declare function readCreateOverlayRequest(bc: bare.ByteCursor): CreateOverlayRequest;
+export declare function writeCreateOverlayRequest(bc: bare.ByteCursor, x: CreateOverlayRequest): void;
+export declare enum GuestFilesystemOperation {
+    ReadFile = "ReadFile",
+    WriteFile = "WriteFile",
+    CreateDir = "CreateDir",
+    Mkdir = "Mkdir",
+    Exists = "Exists",
+    Stat = "Stat",
+    Lstat = "Lstat",
+    ReadDir = "ReadDir",
+    RemoveFile = "RemoveFile",
+    RemoveDir = "RemoveDir",
+    Rename = "Rename",
+    Realpath = "Realpath",
+    Symlink = "Symlink",
+    ReadLink = "ReadLink",
+    Link = "Link",
+    Chmod = "Chmod",
+    Chown = "Chown",
+    Utimes = "Utimes",
+    Truncate = "Truncate",
+    Pread = "Pread"
+}
+export declare function readGuestFilesystemOperation(bc: bare.ByteCursor): GuestFilesystemOperation;
+export declare function writeGuestFilesystemOperation(bc: bare.ByteCursor, x: GuestFilesystemOperation): void;
+export type GuestFilesystemCallRequest = {
+    readonly operation: GuestFilesystemOperation;
+    readonly path: string;
+    readonly destinationPath: string | null;
+    readonly target: string | null;
+    readonly content: string | null;
+    readonly encoding: RootFilesystemEntryEncoding | null;
+    readonly recursive: boolean;
+    readonly mode: u32 | null;
+    readonly uid: u32 | null;
+    readonly gid: u32 | null;
+    readonly atimeMs: u64 | null;
+    readonly mtimeMs: u64 | null;
+    readonly len: u64 | null;
+    readonly offset: u64 | null;
+};
+export declare function readGuestFilesystemCallRequest(bc: bare.ByteCursor): GuestFilesystemCallRequest;
+export declare function writeGuestFilesystemCallRequest(bc: bare.ByteCursor, x: GuestFilesystemCallRequest): void;
+export type SnapshotRootFilesystemRequest = null;
+export type ExecuteRequest = {
+    readonly processId: string;
+    readonly command: string | null;
+    readonly runtime: GuestRuntimeKind | null;
+    readonly entrypoint: string | null;
+    readonly args: readonly string[];
+    readonly env: ReadonlyMap<string, string>;
+    readonly cwd: string | null;
+    readonly wasmPermissionTier: WasmPermissionTier | null;
+};
+export declare function readExecuteRequest(bc: bare.ByteCursor): ExecuteRequest;
+export declare function writeExecuteRequest(bc: bare.ByteCursor, x: ExecuteRequest): void;
+export type WriteStdinRequest = {
+    readonly processId: string;
+    readonly chunk: ArrayBuffer;
+};
+export declare function readWriteStdinRequest(bc: bare.ByteCursor): WriteStdinRequest;
+export declare function writeWriteStdinRequest(bc: bare.ByteCursor, x: WriteStdinRequest): void;
+export type CloseStdinRequest = {
+    readonly processId: string;
+};
+export declare function readCloseStdinRequest(bc: bare.ByteCursor): CloseStdinRequest;
+export declare function writeCloseStdinRequest(bc: bare.ByteCursor, x: CloseStdinRequest): void;
+export type KillProcessRequest = {
+    readonly processId: string;
+    readonly signal: string;
+};
+export declare function readKillProcessRequest(bc: bare.ByteCursor): KillProcessRequest;
+export declare function writeKillProcessRequest(bc: bare.ByteCursor, x: KillProcessRequest): void;
+export type GetProcessSnapshotRequest = null;
+export type FindListenerRequest = {
+    readonly host: string | null;
+    readonly port: u16 | null;
+    readonly path: string | null;
+};
+export declare function readFindListenerRequest(bc: bare.ByteCursor): FindListenerRequest;
+export declare function writeFindListenerRequest(bc: bare.ByteCursor, x: FindListenerRequest): void;
+export type FindBoundUdpRequest = {
+    readonly host: string | null;
+    readonly port: u16 | null;
+};
+export declare function readFindBoundUdpRequest(bc: bare.ByteCursor): FindBoundUdpRequest;
+export declare function writeFindBoundUdpRequest(bc: bare.ByteCursor, x: FindBoundUdpRequest): void;
+export type GetSignalStateRequest = {
+    readonly processId: string;
+};
+export declare function readGetSignalStateRequest(bc: bare.ByteCursor): GetSignalStateRequest;
+export declare function writeGetSignalStateRequest(bc: bare.ByteCursor, x: GetSignalStateRequest): void;
+export type GetZombieTimerCountRequest = null;
+export declare enum FilesystemOperation {
+    Read = "Read",
+    Write = "Write",
+    Stat = "Stat",
+    ReadDir = "ReadDir",
+    Mkdir = "Mkdir",
+    Remove = "Remove",
+    Rename = "Rename"
+}
+export declare function readFilesystemOperation(bc: bare.ByteCursor): FilesystemOperation;
+export declare function writeFilesystemOperation(bc: bare.ByteCursor, x: FilesystemOperation): void;
+export type HostFilesystemCallRequest = {
+    readonly operation: FilesystemOperation;
+    readonly path: string;
+    readonly payloadSizeBytes: u64;
+};
+export declare function readHostFilesystemCallRequest(bc: bare.ByteCursor): HostFilesystemCallRequest;
+export declare function writeHostFilesystemCallRequest(bc: bare.ByteCursor, x: HostFilesystemCallRequest): void;
+export type PersistenceLoadRequest = {
+    readonly key: string;
+};
+export declare function readPersistenceLoadRequest(bc: bare.ByteCursor): PersistenceLoadRequest;
+export declare function writePersistenceLoadRequest(bc: bare.ByteCursor, x: PersistenceLoadRequest): void;
+export type PersistenceFlushRequest = {
+    readonly key: string;
+    readonly payloadSizeBytes: u64;
+};
+export declare function readPersistenceFlushRequest(bc: bare.ByteCursor): PersistenceFlushRequest;
+export declare function writePersistenceFlushRequest(bc: bare.ByteCursor, x: PersistenceFlushRequest): void;
+export type VmFetchRequest = {
+    readonly port: u16;
+    readonly method: string;
+    readonly path: string;
+    readonly headersJson: string;
+    readonly body: string | null;
+};
+export declare function readVmFetchRequest(bc: bare.ByteCursor): VmFetchRequest;
+export declare function writeVmFetchRequest(bc: bare.ByteCursor, x: VmFetchRequest): void;
+export type RequestPayload = {
+    readonly tag: "AuthenticateRequest";
+    readonly val: AuthenticateRequest;
+} | {
+    readonly tag: "OpenSessionRequest";
+    readonly val: OpenSessionRequest;
+} | {
+    readonly tag: "CreateVmRequest";
+    readonly val: CreateVmRequest;
+} | {
+    readonly tag: "DisposeVmRequest";
+    readonly val: DisposeVmRequest;
+} | {
+    readonly tag: "BootstrapRootFilesystemRequest";
+    readonly val: BootstrapRootFilesystemRequest;
+} | {
+    readonly tag: "ConfigureVmRequest";
+    readonly val: ConfigureVmRequest;
+} | {
+    readonly tag: "RegisterHostCallbacksRequest";
+    readonly val: RegisterHostCallbacksRequest;
+} | {
+    readonly tag: "CreateLayerRequest";
+    readonly val: CreateLayerRequest;
+} | {
+    readonly tag: "SealLayerRequest";
+    readonly val: SealLayerRequest;
+} | {
+    readonly tag: "ImportSnapshotRequest";
+    readonly val: ImportSnapshotRequest;
+} | {
+    readonly tag: "ExportSnapshotRequest";
+    readonly val: ExportSnapshotRequest;
+} | {
+    readonly tag: "CreateOverlayRequest";
+    readonly val: CreateOverlayRequest;
+} | {
+    readonly tag: "GuestFilesystemCallRequest";
+    readonly val: GuestFilesystemCallRequest;
+} | {
+    readonly tag: "SnapshotRootFilesystemRequest";
+    readonly val: SnapshotRootFilesystemRequest;
+} | {
+    readonly tag: "ExecuteRequest";
+    readonly val: ExecuteRequest;
+} | {
+    readonly tag: "WriteStdinRequest";
+    readonly val: WriteStdinRequest;
+} | {
+    readonly tag: "CloseStdinRequest";
+    readonly val: CloseStdinRequest;
+} | {
+    readonly tag: "KillProcessRequest";
+    readonly val: KillProcessRequest;
+} | {
+    readonly tag: "GetProcessSnapshotRequest";
+    readonly val: GetProcessSnapshotRequest;
+} | {
+    readonly tag: "FindListenerRequest";
+    readonly val: FindListenerRequest;
+} | {
+    readonly tag: "FindBoundUdpRequest";
+    readonly val: FindBoundUdpRequest;
+} | {
+    readonly tag: "GetSignalStateRequest";
+    readonly val: GetSignalStateRequest;
+} | {
+    readonly tag: "GetZombieTimerCountRequest";
+    readonly val: GetZombieTimerCountRequest;
+} | {
+    readonly tag: "HostFilesystemCallRequest";
+    readonly val: HostFilesystemCallRequest;
+} | {
+    readonly tag: "PersistenceLoadRequest";
+    readonly val: PersistenceLoadRequest;
+} | {
+    readonly tag: "PersistenceFlushRequest";
+    readonly val: PersistenceFlushRequest;
+} | {
+    readonly tag: "VmFetchRequest";
+    readonly val: VmFetchRequest;
+} | {
+    readonly tag: "ExtEnvelope";
+    readonly val: ExtEnvelope;
+};
+export declare function readRequestPayload(bc: bare.ByteCursor): RequestPayload;
+export declare function writeRequestPayload(bc: bare.ByteCursor, x: RequestPayload): void;
+export type RequestFrame = {
+    readonly schema: ProtocolSchema;
+    readonly requestId: RequestId;
+    readonly ownership: OwnershipScope;
+    readonly payload: RequestPayload;
+};
+export declare function readRequestFrame(bc: bare.ByteCursor): RequestFrame;
+export declare function writeRequestFrame(bc: bare.ByteCursor, x: RequestFrame): void;
+export type AuthenticatedResponse = {
+    readonly sidecarId: string;
+    readonly connectionId: string;
+    readonly maxFrameBytes: u32;
+};
+export declare function readAuthenticatedResponse(bc: bare.ByteCursor): AuthenticatedResponse;
+export declare function writeAuthenticatedResponse(bc: bare.ByteCursor, x: AuthenticatedResponse): void;
+export type SessionOpenedResponse = {
+    readonly sessionId: string;
+    readonly ownerConnectionId: string;
+};
+export declare function readSessionOpenedResponse(bc: bare.ByteCursor): SessionOpenedResponse;
+export declare function writeSessionOpenedResponse(bc: bare.ByteCursor, x: SessionOpenedResponse): void;
+export type VmCreatedResponse = {
+    readonly vmId: string;
+};
+export declare function readVmCreatedResponse(bc: bare.ByteCursor): VmCreatedResponse;
+export declare function writeVmCreatedResponse(bc: bare.ByteCursor, x: VmCreatedResponse): void;
+export type VmDisposedResponse = {
+    readonly vmId: string;
+};
+export declare function readVmDisposedResponse(bc: bare.ByteCursor): VmDisposedResponse;
+export declare function writeVmDisposedResponse(bc: bare.ByteCursor, x: VmDisposedResponse): void;
+export type RootFilesystemBootstrappedResponse = {
+    readonly entryCount: u32;
+};
+export declare function readRootFilesystemBootstrappedResponse(bc: bare.ByteCursor): RootFilesystemBootstrappedResponse;
+export declare function writeRootFilesystemBootstrappedResponse(bc: bare.ByteCursor, x: RootFilesystemBootstrappedResponse): void;
+export type VmConfiguredResponse = {
+    readonly appliedMounts: u32;
+    readonly appliedSoftware: u32;
+};
+export declare function readVmConfiguredResponse(bc: bare.ByteCursor): VmConfiguredResponse;
+export declare function writeVmConfiguredResponse(bc: bare.ByteCursor, x: VmConfiguredResponse): void;
+export type HostCallbacksRegisteredResponse = {
+    readonly registration: string;
+    readonly commandCount: u32;
+};
+export declare function readHostCallbacksRegisteredResponse(bc: bare.ByteCursor): HostCallbacksRegisteredResponse;
+export declare function writeHostCallbacksRegisteredResponse(bc: bare.ByteCursor, x: HostCallbacksRegisteredResponse): void;
+export type LayerCreatedResponse = {
+    readonly layerId: string;
+};
+export declare function readLayerCreatedResponse(bc: bare.ByteCursor): LayerCreatedResponse;
+export declare function writeLayerCreatedResponse(bc: bare.ByteCursor, x: LayerCreatedResponse): void;
+export type LayerSealedResponse = {
+    readonly layerId: string;
+};
+export declare function readLayerSealedResponse(bc: bare.ByteCursor): LayerSealedResponse;
+export declare function writeLayerSealedResponse(bc: bare.ByteCursor, x: LayerSealedResponse): void;
+export type SnapshotImportedResponse = {
+    readonly layerId: string;
+};
+export declare function readSnapshotImportedResponse(bc: bare.ByteCursor): SnapshotImportedResponse;
+export declare function writeSnapshotImportedResponse(bc: bare.ByteCursor, x: SnapshotImportedResponse): void;
+export type SnapshotExportedResponse = {
+    readonly layerId: string;
+    readonly entries: readonly RootFilesystemEntry[];
+};
+export declare function readSnapshotExportedResponse(bc: bare.ByteCursor): SnapshotExportedResponse;
+export declare function writeSnapshotExportedResponse(bc: bare.ByteCursor, x: SnapshotExportedResponse): void;
+export type OverlayCreatedResponse = {
+    readonly layerId: string;
+};
+export declare function readOverlayCreatedResponse(bc: bare.ByteCursor): OverlayCreatedResponse;
+export declare function writeOverlayCreatedResponse(bc: bare.ByteCursor, x: OverlayCreatedResponse): void;
+export type GuestFilesystemStat = {
+    readonly mode: u32;
+    readonly size: u64;
+    readonly blocks: u64;
+    readonly dev: u64;
+    readonly rdev: u64;
+    readonly isDirectory: boolean;
+    readonly isSymbolicLink: boolean;
+    readonly atimeMs: u64;
+    readonly mtimeMs: u64;
+    readonly ctimeMs: u64;
+    readonly birthtimeMs: u64;
+    readonly ino: u64;
+    readonly nlink: u64;
+    readonly uid: u32;
+    readonly gid: u32;
+};
+export declare function readGuestFilesystemStat(bc: bare.ByteCursor): GuestFilesystemStat;
+export declare function writeGuestFilesystemStat(bc: bare.ByteCursor, x: GuestFilesystemStat): void;
+export type GuestFilesystemResultResponse = {
+    readonly operation: GuestFilesystemOperation;
+    readonly path: string;
+    readonly content: string | null;
+    readonly encoding: RootFilesystemEntryEncoding | null;
+    readonly entries: readonly string[] | null;
+    readonly stat: GuestFilesystemStat | null;
+    readonly exists: boolean | null;
+    readonly target: string | null;
+};
+export declare function readGuestFilesystemResultResponse(bc: bare.ByteCursor): GuestFilesystemResultResponse;
+export declare function writeGuestFilesystemResultResponse(bc: bare.ByteCursor, x: GuestFilesystemResultResponse): void;
+export type RootFilesystemSnapshotResponse = {
+    readonly entries: readonly RootFilesystemEntry[];
+};
+export declare function readRootFilesystemSnapshotResponse(bc: bare.ByteCursor): RootFilesystemSnapshotResponse;
+export declare function writeRootFilesystemSnapshotResponse(bc: bare.ByteCursor, x: RootFilesystemSnapshotResponse): void;
+export type ProcessStartedResponse = {
+    readonly processId: string;
+    readonly pid: u32 | null;
+};
+export declare function readProcessStartedResponse(bc: bare.ByteCursor): ProcessStartedResponse;
+export declare function writeProcessStartedResponse(bc: bare.ByteCursor, x: ProcessStartedResponse): void;
+export type StdinWrittenResponse = {
+    readonly processId: string;
+    readonly acceptedBytes: u64;
+};
+export declare function readStdinWrittenResponse(bc: bare.ByteCursor): StdinWrittenResponse;
+export declare function writeStdinWrittenResponse(bc: bare.ByteCursor, x: StdinWrittenResponse): void;
+export type StdinClosedResponse = {
+    readonly processId: string;
+};
+export declare function readStdinClosedResponse(bc: bare.ByteCursor): StdinClosedResponse;
+export declare function writeStdinClosedResponse(bc: bare.ByteCursor, x: StdinClosedResponse): void;
+export type ProcessKilledResponse = {
+    readonly processId: string;
+};
+export declare function readProcessKilledResponse(bc: bare.ByteCursor): ProcessKilledResponse;
+export declare function writeProcessKilledResponse(bc: bare.ByteCursor, x: ProcessKilledResponse): void;
+export declare enum ProcessSnapshotStatus {
+    Running = "Running",
+    Exited = "Exited",
+    Stopped = "Stopped"
+}
+export declare function readProcessSnapshotStatus(bc: bare.ByteCursor): ProcessSnapshotStatus;
+export declare function writeProcessSnapshotStatus(bc: bare.ByteCursor, x: ProcessSnapshotStatus): void;
+export type ProcessSnapshotEntry = {
+    readonly processId: string;
+    readonly pid: u32;
+    readonly ppid: u32;
+    readonly pgid: u32;
+    readonly sid: u32;
+    readonly driver: string;
+    readonly command: string;
+    readonly args: readonly string[];
+    readonly cwd: string;
+    readonly status: ProcessSnapshotStatus;
+    readonly exitCode: i32 | null;
+};
+export declare function readProcessSnapshotEntry(bc: bare.ByteCursor): ProcessSnapshotEntry;
+export declare function writeProcessSnapshotEntry(bc: bare.ByteCursor, x: ProcessSnapshotEntry): void;
+export type ProcessSnapshotResponse = {
+    readonly processes: readonly ProcessSnapshotEntry[];
+};
+export declare function readProcessSnapshotResponse(bc: bare.ByteCursor): ProcessSnapshotResponse;
+export declare function writeProcessSnapshotResponse(bc: bare.ByteCursor, x: ProcessSnapshotResponse): void;
+export type SocketStateEntry = {
+    readonly processId: string;
+    readonly host: string | null;
+    readonly port: u16 | null;
+    readonly path: string | null;
+};
+export declare function readSocketStateEntry(bc: bare.ByteCursor): SocketStateEntry;
+export declare function writeSocketStateEntry(bc: bare.ByteCursor, x: SocketStateEntry): void;
+export type ListenerSnapshotResponse = {
+    readonly listener: SocketStateEntry | null;
+};
+export declare function readListenerSnapshotResponse(bc: bare.ByteCursor): ListenerSnapshotResponse;
+export declare function writeListenerSnapshotResponse(bc: bare.ByteCursor, x: ListenerSnapshotResponse): void;
+export type BoundUdpSnapshotResponse = {
+    readonly socket: SocketStateEntry | null;
+};
+export declare function readBoundUdpSnapshotResponse(bc: bare.ByteCursor): BoundUdpSnapshotResponse;
+export declare function writeBoundUdpSnapshotResponse(bc: bare.ByteCursor, x: BoundUdpSnapshotResponse): void;
+export declare enum SignalDispositionAction {
+    Default = "Default",
+    Ignore = "Ignore",
+    User = "User"
+}
+export declare function readSignalDispositionAction(bc: bare.ByteCursor): SignalDispositionAction;
+export declare function writeSignalDispositionAction(bc: bare.ByteCursor, x: SignalDispositionAction): void;
+export type SignalHandlerRegistration = {
+    readonly action: SignalDispositionAction;
+    readonly mask: Uint32Array;
+    readonly flags: u32;
+};
+export declare function readSignalHandlerRegistration(bc: bare.ByteCursor): SignalHandlerRegistration;
+export declare function writeSignalHandlerRegistration(bc: bare.ByteCursor, x: SignalHandlerRegistration): void;
+export type SignalStateResponse = {
+    readonly processId: string;
+    readonly handlers: ReadonlyMap<u32, SignalHandlerRegistration>;
+};
+export declare function readSignalStateResponse(bc: bare.ByteCursor): SignalStateResponse;
+export declare function writeSignalStateResponse(bc: bare.ByteCursor, x: SignalStateResponse): void;
+export type ZombieTimerCountResponse = {
+    readonly count: u64;
+};
+export declare function readZombieTimerCountResponse(bc: bare.ByteCursor): ZombieTimerCountResponse;
+export declare function writeZombieTimerCountResponse(bc: bare.ByteCursor, x: ZombieTimerCountResponse): void;
+export type FilesystemResultResponse = {
+    readonly operation: FilesystemOperation;
+    readonly status: string;
+    readonly payloadSizeBytes: u64;
+};
+export declare function readFilesystemResultResponse(bc: bare.ByteCursor): FilesystemResultResponse;
+export declare function writeFilesystemResultResponse(bc: bare.ByteCursor, x: FilesystemResultResponse): void;
+export type PermissionDecisionResponse = {
+    readonly capability: string;
+    readonly decision: PermissionMode;
+};
+export declare function readPermissionDecisionResponse(bc: bare.ByteCursor): PermissionDecisionResponse;
+export declare function writePermissionDecisionResponse(bc: bare.ByteCursor, x: PermissionDecisionResponse): void;
+export type PersistenceStateResponse = {
+    readonly key: string;
+    readonly found: boolean;
+    readonly payloadSizeBytes: u64;
+};
+export declare function readPersistenceStateResponse(bc: bare.ByteCursor): PersistenceStateResponse;
+export declare function writePersistenceStateResponse(bc: bare.ByteCursor, x: PersistenceStateResponse): void;
+export type PersistenceFlushedResponse = {
+    readonly key: string;
+    readonly committedBytes: u64;
+};
+export declare function readPersistenceFlushedResponse(bc: bare.ByteCursor): PersistenceFlushedResponse;
+export declare function writePersistenceFlushedResponse(bc: bare.ByteCursor, x: PersistenceFlushedResponse): void;
+export type RejectedResponse = {
+    readonly code: string;
+    readonly message: string;
+};
+export declare function readRejectedResponse(bc: bare.ByteCursor): RejectedResponse;
+export declare function writeRejectedResponse(bc: bare.ByteCursor, x: RejectedResponse): void;
+export type VmFetchResponse = {
+    readonly responseJson: string;
+};
+export declare function readVmFetchResponse(bc: bare.ByteCursor): VmFetchResponse;
+export declare function writeVmFetchResponse(bc: bare.ByteCursor, x: VmFetchResponse): void;
+export type ResponsePayload = {
+    readonly tag: "AuthenticatedResponse";
+    readonly val: AuthenticatedResponse;
+} | {
+    readonly tag: "SessionOpenedResponse";
+    readonly val: SessionOpenedResponse;
+} | {
+    readonly tag: "VmCreatedResponse";
+    readonly val: VmCreatedResponse;
+} | {
+    readonly tag: "VmDisposedResponse";
+    readonly val: VmDisposedResponse;
+} | {
+    readonly tag: "RootFilesystemBootstrappedResponse";
+    readonly val: RootFilesystemBootstrappedResponse;
+} | {
+    readonly tag: "VmConfiguredResponse";
+    readonly val: VmConfiguredResponse;
+} | {
+    readonly tag: "HostCallbacksRegisteredResponse";
+    readonly val: HostCallbacksRegisteredResponse;
+} | {
+    readonly tag: "LayerCreatedResponse";
+    readonly val: LayerCreatedResponse;
+} | {
+    readonly tag: "LayerSealedResponse";
+    readonly val: LayerSealedResponse;
+} | {
+    readonly tag: "SnapshotImportedResponse";
+    readonly val: SnapshotImportedResponse;
+} | {
+    readonly tag: "SnapshotExportedResponse";
+    readonly val: SnapshotExportedResponse;
+} | {
+    readonly tag: "OverlayCreatedResponse";
+    readonly val: OverlayCreatedResponse;
+} | {
+    readonly tag: "GuestFilesystemResultResponse";
+    readonly val: GuestFilesystemResultResponse;
+} | {
+    readonly tag: "RootFilesystemSnapshotResponse";
+    readonly val: RootFilesystemSnapshotResponse;
+} | {
+    readonly tag: "ProcessStartedResponse";
+    readonly val: ProcessStartedResponse;
+} | {
+    readonly tag: "StdinWrittenResponse";
+    readonly val: StdinWrittenResponse;
+} | {
+    readonly tag: "StdinClosedResponse";
+    readonly val: StdinClosedResponse;
+} | {
+    readonly tag: "ProcessKilledResponse";
+    readonly val: ProcessKilledResponse;
+} | {
+    readonly tag: "ProcessSnapshotResponse";
+    readonly val: ProcessSnapshotResponse;
+} | {
+    readonly tag: "ListenerSnapshotResponse";
+    readonly val: ListenerSnapshotResponse;
+} | {
+    readonly tag: "BoundUdpSnapshotResponse";
+    readonly val: BoundUdpSnapshotResponse;
+} | {
+    readonly tag: "SignalStateResponse";
+    readonly val: SignalStateResponse;
+} | {
+    readonly tag: "ZombieTimerCountResponse";
+    readonly val: ZombieTimerCountResponse;
+} | {
+    readonly tag: "FilesystemResultResponse";
+    readonly val: FilesystemResultResponse;
+} | {
+    readonly tag: "PermissionDecisionResponse";
+    readonly val: PermissionDecisionResponse;
+} | {
+    readonly tag: "PersistenceStateResponse";
+    readonly val: PersistenceStateResponse;
+} | {
+    readonly tag: "PersistenceFlushedResponse";
+    readonly val: PersistenceFlushedResponse;
+} | {
+    readonly tag: "RejectedResponse";
+    readonly val: RejectedResponse;
+} | {
+    readonly tag: "VmFetchResponse";
+    readonly val: VmFetchResponse;
+} | {
+    readonly tag: "ExtEnvelope";
+    readonly val: ExtEnvelope;
+};
+export declare function readResponsePayload(bc: bare.ByteCursor): ResponsePayload;
+export declare function writeResponsePayload(bc: bare.ByteCursor, x: ResponsePayload): void;
+export type ResponseFrame = {
+    readonly schema: ProtocolSchema;
+    readonly requestId: RequestId;
+    readonly ownership: OwnershipScope;
+    readonly payload: ResponsePayload;
+};
+export declare function readResponseFrame(bc: bare.ByteCursor): ResponseFrame;
+export declare function writeResponseFrame(bc: bare.ByteCursor, x: ResponseFrame): void;
+export declare enum VmLifecycleState {
+    Creating = "Creating",
+    Ready = "Ready",
+    Disposing = "Disposing",
+    Disposed = "Disposed",
+    Failed = "Failed"
+}
+export declare function readVmLifecycleState(bc: bare.ByteCursor): VmLifecycleState;
+export declare function writeVmLifecycleState(bc: bare.ByteCursor, x: VmLifecycleState): void;
+export type VmLifecycleEvent = {
+    readonly state: VmLifecycleState;
+};
+export declare function readVmLifecycleEvent(bc: bare.ByteCursor): VmLifecycleEvent;
+export declare function writeVmLifecycleEvent(bc: bare.ByteCursor, x: VmLifecycleEvent): void;
+export declare enum StreamChannel {
+    Stdout = "Stdout",
+    Stderr = "Stderr"
+}
+export declare function readStreamChannel(bc: bare.ByteCursor): StreamChannel;
+export declare function writeStreamChannel(bc: bare.ByteCursor, x: StreamChannel): void;
+export type ProcessOutputEvent = {
+    readonly processId: string;
+    readonly channel: StreamChannel;
+    readonly chunk: ArrayBuffer;
+};
+export declare function readProcessOutputEvent(bc: bare.ByteCursor): ProcessOutputEvent;
+export declare function writeProcessOutputEvent(bc: bare.ByteCursor, x: ProcessOutputEvent): void;
+export type ProcessExitedEvent = {
+    readonly processId: string;
+    readonly exitCode: i32;
+};
+export declare function readProcessExitedEvent(bc: bare.ByteCursor): ProcessExitedEvent;
+export declare function writeProcessExitedEvent(bc: bare.ByteCursor, x: ProcessExitedEvent): void;
+export type StructuredEvent = {
+    readonly name: string;
+    readonly detail: ReadonlyMap<string, string>;
+};
+export declare function readStructuredEvent(bc: bare.ByteCursor): StructuredEvent;
+export declare function writeStructuredEvent(bc: bare.ByteCursor, x: StructuredEvent): void;
+export type EventPayload = {
+    readonly tag: "VmLifecycleEvent";
+    readonly val: VmLifecycleEvent;
+} | {
+    readonly tag: "ProcessOutputEvent";
+    readonly val: ProcessOutputEvent;
+} | {
+    readonly tag: "ProcessExitedEvent";
+    readonly val: ProcessExitedEvent;
+} | {
+    readonly tag: "StructuredEvent";
+    readonly val: StructuredEvent;
+} | {
+    readonly tag: "ExtEnvelope";
+    readonly val: ExtEnvelope;
+};
+export declare function readEventPayload(bc: bare.ByteCursor): EventPayload;
+export declare function writeEventPayload(bc: bare.ByteCursor, x: EventPayload): void;
+export type EventFrame = {
+    readonly schema: ProtocolSchema;
+    readonly ownership: OwnershipScope;
+    readonly payload: EventPayload;
+};
+export declare function readEventFrame(bc: bare.ByteCursor): EventFrame;
+export declare function writeEventFrame(bc: bare.ByteCursor, x: EventFrame): void;
+export type HostCallbackRequest = {
+    readonly invocationId: string;
+    readonly callbackKey: string;
+    readonly input: JsonUtf8;
+    readonly timeoutMs: u64;
+};
+export declare function readHostCallbackRequest(bc: bare.ByteCursor): HostCallbackRequest;
+export declare function writeHostCallbackRequest(bc: bare.ByteCursor, x: HostCallbackRequest): void;
+export type JsBridgeCallRequest = {
+    readonly callId: string;
+    readonly mountId: string;
+    readonly operation: string;
+    readonly args: JsonUtf8;
+};
+export declare function readJsBridgeCallRequest(bc: bare.ByteCursor): JsBridgeCallRequest;
+export declare function writeJsBridgeCallRequest(bc: bare.ByteCursor, x: JsBridgeCallRequest): void;
+export type SidecarRequestPayload = {
+    readonly tag: "HostCallbackRequest";
+    readonly val: HostCallbackRequest;
+} | {
+    readonly tag: "JsBridgeCallRequest";
+    readonly val: JsBridgeCallRequest;
+} | {
+    readonly tag: "ExtEnvelope";
+    readonly val: ExtEnvelope;
+};
+export declare function readSidecarRequestPayload(bc: bare.ByteCursor): SidecarRequestPayload;
+export declare function writeSidecarRequestPayload(bc: bare.ByteCursor, x: SidecarRequestPayload): void;
+export type SidecarRequestFrame = {
+    readonly schema: ProtocolSchema;
+    readonly requestId: RequestId;
+    readonly ownership: OwnershipScope;
+    readonly payload: SidecarRequestPayload;
+};
+export declare function readSidecarRequestFrame(bc: bare.ByteCursor): SidecarRequestFrame;
+export declare function writeSidecarRequestFrame(bc: bare.ByteCursor, x: SidecarRequestFrame): void;
+export type HostCallbackResultResponse = {
+    readonly invocationId: string;
+    readonly result: JsonUtf8 | null;
+    readonly error: string | null;
+};
+export declare function readHostCallbackResultResponse(bc: bare.ByteCursor): HostCallbackResultResponse;
+export declare function writeHostCallbackResultResponse(bc: bare.ByteCursor, x: HostCallbackResultResponse): void;
+export type JsBridgeResultResponse = {
+    readonly callId: string;
+    readonly result: JsonUtf8 | null;
+    readonly error: string | null;
+};
+export declare function readJsBridgeResultResponse(bc: bare.ByteCursor): JsBridgeResultResponse;
+export declare function writeJsBridgeResultResponse(bc: bare.ByteCursor, x: JsBridgeResultResponse): void;
+export type SidecarResponsePayload = {
+    readonly tag: "HostCallbackResultResponse";
+    readonly val: HostCallbackResultResponse;
+} | {
+    readonly tag: "JsBridgeResultResponse";
+    readonly val: JsBridgeResultResponse;
+} | {
+    readonly tag: "ExtEnvelope";
+    readonly val: ExtEnvelope;
+};
+export declare function readSidecarResponsePayload(bc: bare.ByteCursor): SidecarResponsePayload;
+export declare function writeSidecarResponsePayload(bc: bare.ByteCursor, x: SidecarResponsePayload): void;
+export type SidecarResponseFrame = {
+    readonly schema: ProtocolSchema;
+    readonly requestId: RequestId;
+    readonly ownership: OwnershipScope;
+    readonly payload: SidecarResponsePayload;
+};
+export declare function readSidecarResponseFrame(bc: bare.ByteCursor): SidecarResponseFrame;
+export declare function writeSidecarResponseFrame(bc: bare.ByteCursor, x: SidecarResponseFrame): void;
+export type ProtocolFrame = {
+    readonly tag: "RequestFrame";
+    readonly val: RequestFrame;
+} | {
+    readonly tag: "ResponseFrame";
+    readonly val: ResponseFrame;
+} | {
+    readonly tag: "EventFrame";
+    readonly val: EventFrame;
+} | {
+    readonly tag: "SidecarRequestFrame";
+    readonly val: SidecarRequestFrame;
+} | {
+    readonly tag: "SidecarResponseFrame";
+    readonly val: SidecarResponseFrame;
+};
+export declare function readProtocolFrame(bc: bare.ByteCursor): ProtocolFrame;
+export declare function writeProtocolFrame(bc: bare.ByteCursor, x: ProtocolFrame): void;
+export declare function encodeProtocolFrame(x: ProtocolFrame, config?: Partial<bare.Config>): Uint8Array;
+export declare function decodeProtocolFrame(bytes: Uint8Array): ProtocolFrame;