// Generated by @opencode-ai/httpapi-codegen. Do not edit.
import type { Effect, Stream } from "effect"
import type { Location } from "@opencode-ai/schema/location"
import type { Agent } from "@opencode-ai/schema/agent"
import type { Plugin } from "@opencode-ai/schema/plugin"
import type { Workspace } from "@opencode-ai/schema/workspace"
import type { Session } from "@opencode-ai/schema/session"
import type { AbsolutePath } from "@opencode-ai/schema/schema"
import type { Project } from "@opencode-ai/schema/project"
import type { RelativePath } from "@opencode-ai/schema/schema"
import type { Brand } from "effect"
import type { Model } from "@opencode-ai/schema/model"
import type { SessionMessage } from "@opencode-ai/schema/session-message"
import type { PromptInput } from "@opencode-ai/schema/prompt-input"
import type { AgentAttachment } from "@opencode-ai/schema/prompt"
import type { SessionPending } from "@opencode-ai/schema/session-pending"
import type { Skill } from "@opencode-ai/schema/skill"
import type { Event } from "@opencode-ai/schema/event"
import type { InstructionEntry } from "@opencode-ai/schema/instruction-entry"
import type { Schema } from "effect"
import type { EventLog } from "@opencode-ai/schema/event-log"
import type { Shell } from "@opencode-ai/schema/shell"
import type { DateTime } from "effect"
import type { Provider } from "@opencode-ai/schema/provider"
import type { Integration } from "@opencode-ai/schema/integration"
import type { Mcp } from "@opencode-ai/schema/mcp"
import type { Credential } from "@opencode-ai/schema/credential"
import type { Form } from "@opencode-ai/schema/form"
import type { Permission } from "@opencode-ai/schema/permission"
import type { PermissionSaved } from "@opencode-ai/schema/permission-saved"
import type { FileSystem } from "@opencode-ai/schema/filesystem"
import type { Command } from "@opencode-ai/schema/command"
import type { OpenCodeEvent } from "@opencode-ai/protocol/groups/event"
import type { Pty } from "@opencode-ai/schema/pty"
import type { Question } from "@opencode-ai/schema/question"
import type { Reference } from "@opencode-ai/schema/reference"
import type { ProjectCopy } from "@opencode-ai/schema/project-copy"
import type { Vcs } from "@opencode-ai/schema/vcs"
import type { FileDiff } from "@opencode-ai/schema/file-diff"
import type { WebSearch } from "@opencode-ai/schema/websearch"
import type { Config } from "@opencode-ai/schema/config"

export type Endpoint0_0Output = { readonly healthy: true; readonly version: string; readonly pid: number }
export type HealthGetOperation<E = never> = () => Effect.Effect<Endpoint0_0Output, E>

export type Endpoint0_1Input = { readonly instanceID: string }
export type Endpoint0_1Output = { readonly accepted: boolean }
export type HealthStopOperation<E = never> = (input: Endpoint0_1Input) => Effect.Effect<Endpoint0_1Output, E>

export interface HealthApi<E = never> {
  readonly get: HealthGetOperation<E>
  readonly stop: HealthStopOperation<E>
}

export type Endpoint1_0Output = { readonly urls: ReadonlyArray<string> }
export type ServerGetOperation<E = never> = () => Effect.Effect<Endpoint1_0Output, E>

export interface ServerApi<E = never> {
  readonly get: ServerGetOperation<E>
}

export type Endpoint2_0Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint2_0Output = Location.Info
export type LocationGetOperation<E = never> = (input?: Endpoint2_0Input) => Effect.Effect<Endpoint2_0Output, E>

export interface LocationApi<E = never> {
  readonly get: LocationGetOperation<E>
}

export type Endpoint3_0Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint3_0Output = { readonly location: Location.Info; readonly data: ReadonlyArray<Agent.Info> }
export type AgentListOperation<E = never> = (input?: Endpoint3_0Input) => Effect.Effect<Endpoint3_0Output, E>

export type Endpoint3_1Input = {
  readonly agentID: Agent.ID
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint3_1Output = { readonly location: Location.Info; readonly data: Agent.Info }
export type AgentGetOperation<E = never> = (input: Endpoint3_1Input) => Effect.Effect<Endpoint3_1Output, E>

export interface AgentApi<E = never> {
  readonly list: AgentListOperation<E>
  readonly get: AgentGetOperation<E>
}

export type Endpoint4_0Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint4_0Output = { readonly location: Location.Info; readonly data: ReadonlyArray<Plugin.Info> }
export type PluginListOperation<E = never> = (input?: Endpoint4_0Input) => Effect.Effect<Endpoint4_0Output, E>

export interface PluginApi<E = never> {
  readonly list: PluginListOperation<E>
}

export type Endpoint5_0Input = {
  readonly workspace?: Workspace.ID | undefined
  readonly limit?: number | undefined
  readonly order?: "asc" | "desc" | undefined
  readonly search?: string | undefined
  readonly parentID?: Session.ID | null | undefined
  readonly directory?: AbsolutePath | undefined
  readonly project?: Project.ID | undefined
  readonly subpath?: RelativePath | undefined
  readonly cursor?: (string & Brand.Brand<"SessionsCursor">) | undefined
}
export type Endpoint5_0Output = {
  readonly data: ReadonlyArray<Session.Info>
  readonly cursor: {
    readonly previous?: (string & Brand.Brand<"SessionsCursor">) | undefined
    readonly next?: (string & Brand.Brand<"SessionsCursor">) | undefined
  }
}
export type SessionListOperation<E = never> = (input?: Endpoint5_0Input) => Effect.Effect<Endpoint5_0Output, E>

export type Endpoint5_1Input = {
  readonly id?: Session.ID | undefined
  readonly title?: string | undefined
  readonly agent?: Agent.ID | undefined
  readonly model?: Model.Ref | undefined
  readonly location?: Location.Ref | undefined
}
export type Endpoint5_1Output = Session.Info
export type SessionCreateOperation<E = never> = (input?: Endpoint5_1Input) => Effect.Effect<Endpoint5_1Output, E>

export type Endpoint5_2Input = {
  readonly info: Session.Info
  readonly messages: ReadonlyArray<SessionMessage.Info>
  readonly location?: Location.Ref | undefined
}
export type Endpoint5_2Output = Session.Info
export type SessionImportOperation<E = never> = (input: Endpoint5_2Input) => Effect.Effect<Endpoint5_2Output, E>

export type Endpoint5_3Input = { readonly sessionID: Session.ID; readonly sanitize?: boolean | undefined }
export type Endpoint5_3Output = { readonly info: Session.Info; readonly messages: ReadonlyArray<SessionMessage.Info> }
export type SessionExportOperation<E = never> = (input: Endpoint5_3Input) => Effect.Effect<Endpoint5_3Output, E>

export type Endpoint5_4Output = { readonly [x: Session.ID]: { readonly type: "running" } }
export type SessionActiveOperation<E = never> = () => Effect.Effect<Endpoint5_4Output, E>

export type Endpoint5_5Input = { readonly sessionID: Session.ID }
export type Endpoint5_5Output = Session.Info
export type SessionGetOperation<E = never> = (input: Endpoint5_5Input) => Effect.Effect<Endpoint5_5Output, E>

export type Endpoint5_6Input = { readonly sessionID: Session.ID }
export type Endpoint5_6Output = void
export type SessionRemoveOperation<E = never> = (input: Endpoint5_6Input) => Effect.Effect<Endpoint5_6Output, E>

export type Endpoint5_7Input = { readonly sessionID: Session.ID; readonly boundary: Session.ForkRequestBoundary }
export type Endpoint5_7Output = Session.Info
export type SessionForkOperation<E = never> = (input: Endpoint5_7Input) => Effect.Effect<Endpoint5_7Output, E>

export type Endpoint5_8Input = { readonly sessionID: Session.ID; readonly agent: Agent.ID }
export type Endpoint5_8Output = void
export type SessionSwitchAgentOperation<E = never> = (input: Endpoint5_8Input) => Effect.Effect<Endpoint5_8Output, E>

export type Endpoint5_9Input = { readonly sessionID: Session.ID; readonly model: Model.Ref }
export type Endpoint5_9Output = void
export type SessionSwitchModelOperation<E = never> = (input: Endpoint5_9Input) => Effect.Effect<Endpoint5_9Output, E>

export type Endpoint5_10Input = { readonly sessionID: Session.ID; readonly title: string }
export type Endpoint5_10Output = void
export type SessionRenameOperation<E = never> = (input: Endpoint5_10Input) => Effect.Effect<Endpoint5_10Output, E>

export type Endpoint5_11Input = {
  readonly sessionID: Session.ID
  readonly directory: AbsolutePath
  readonly workspaceID?: Workspace.ID | undefined
}
export type Endpoint5_11Output = void
export type SessionMoveOperation<E = never> = (input: Endpoint5_11Input) => Effect.Effect<Endpoint5_11Output, E>

export type Endpoint5_12Input = {
  readonly sessionID: Session.ID
  readonly id?: SessionMessage.ID | undefined
  readonly text: string
  readonly files?: ReadonlyArray<PromptInput.FileAttachment> | undefined
  readonly agents?: ReadonlyArray<AgentAttachment> | undefined
  readonly metadata?: { readonly [x: string]: unknown } | undefined
  readonly delivery?: "steer" | "queue" | undefined
  readonly resume?: boolean | undefined
}
export type Endpoint5_12Output = SessionPending.User
export type SessionPromptOperation<E = never> = (input: Endpoint5_12Input) => Effect.Effect<Endpoint5_12Output, E>

export type Endpoint5_13Input = {
  readonly sessionID: Session.ID
  readonly id?: SessionMessage.ID | undefined
  readonly command: string
  readonly arguments?: string | undefined
  readonly agent?: Agent.ID | undefined
  readonly model?: Model.Ref | undefined
  readonly files?: ReadonlyArray<PromptInput.FileAttachment> | undefined
  readonly agents?: ReadonlyArray<AgentAttachment> | undefined
  readonly delivery?: "steer" | "queue" | undefined
  readonly resume?: boolean | undefined
}
export type Endpoint5_13Output = SessionPending.User
export type SessionCommandOperation<E = never> = (input: Endpoint5_13Input) => Effect.Effect<Endpoint5_13Output, E>

export type Endpoint5_14Input = {
  readonly sessionID: Session.ID
  readonly id?: SessionMessage.ID | undefined
  readonly skill: Skill.ID
  readonly resume?: boolean | undefined
}
export type Endpoint5_14Output = void
export type SessionSkillOperation<E = never> = (input: Endpoint5_14Input) => Effect.Effect<Endpoint5_14Output, E>

export type Endpoint5_15Input = {
  readonly sessionID: Session.ID
  readonly id?: SessionMessage.ID | undefined
  readonly text: string
  readonly description?: string | undefined
  readonly metadata?: { readonly [x: string]: unknown } | undefined
  readonly delivery?: "steer" | "queue" | undefined
  readonly resume?: boolean | undefined
}
export type Endpoint5_15Output = SessionPending.Synthetic
export type SessionSyntheticOperation<E = never> = (input: Endpoint5_15Input) => Effect.Effect<Endpoint5_15Output, E>

export type Endpoint5_16Input = {
  readonly sessionID: Session.ID
  readonly id?: Event.ID | undefined
  readonly command: string
}
export type Endpoint5_16Output = void
export type SessionShellOperation<E = never> = (input: Endpoint5_16Input) => Effect.Effect<Endpoint5_16Output, E>

export type Endpoint5_17Input = { readonly sessionID: Session.ID; readonly id?: SessionMessage.ID | undefined }
export type Endpoint5_17Output = SessionPending.Compaction
export type SessionCompactOperation<E = never> = (input: Endpoint5_17Input) => Effect.Effect<Endpoint5_17Output, E>

export type Endpoint5_18Input = { readonly sessionID: Session.ID }
export type Endpoint5_18Output = void
export type SessionWaitOperation<E = never> = (input: Endpoint5_18Input) => Effect.Effect<Endpoint5_18Output, E>

export type Endpoint5_19Input = {
  readonly sessionID: Session.ID
  readonly messageID: SessionMessage.ID
  readonly files?: boolean | undefined
}
export type Endpoint5_19Output = Session.Revert
export type SessionRevertStageOperation<E = never> = (input: Endpoint5_19Input) => Effect.Effect<Endpoint5_19Output, E>

export type Endpoint5_20Input = { readonly sessionID: Session.ID }
export type Endpoint5_20Output = void
export type SessionRevertClearOperation<E = never> = (input: Endpoint5_20Input) => Effect.Effect<Endpoint5_20Output, E>

export type Endpoint5_21Input = { readonly sessionID: Session.ID }
export type Endpoint5_21Output = void
export type SessionRevertCommitOperation<E = never> = (input: Endpoint5_21Input) => Effect.Effect<Endpoint5_21Output, E>

export type Endpoint5_22Input = { readonly sessionID: Session.ID }
export type Endpoint5_22Output = ReadonlyArray<SessionMessage.Info>
export type SessionContextOperation<E = never> = (input: Endpoint5_22Input) => Effect.Effect<Endpoint5_22Output, E>

export type Endpoint5_23Input = { readonly sessionID: Session.ID }
export type Endpoint5_23Output = ReadonlyArray<SessionPending.Info>
export type SessionPendingListOperation<E = never> = (input: Endpoint5_23Input) => Effect.Effect<Endpoint5_23Output, E>

export type Endpoint5_24Input = { readonly sessionID: Session.ID }
export type Endpoint5_24Output = ReadonlyArray<InstructionEntry.Info>
export type SessionInstructionsEntryListOperation<E = never> = (
  input: Endpoint5_24Input,
) => Effect.Effect<Endpoint5_24Output, E>

export type Endpoint5_25Input = {
  readonly sessionID: Session.ID
  readonly key: InstructionEntry.Key
  readonly value: Schema.Json
}
export type Endpoint5_25Output = void
export type SessionInstructionsEntryPutOperation<E = never> = (
  input: Endpoint5_25Input,
) => Effect.Effect<Endpoint5_25Output, E>

export type Endpoint5_26Input = { readonly sessionID: Session.ID; readonly key: InstructionEntry.Key }
export type Endpoint5_26Output = void
export type SessionInstructionsEntryRemoveOperation<E = never> = (
  input: Endpoint5_26Input,
) => Effect.Effect<Endpoint5_26Output, E>

export type Endpoint5_27Input = { readonly sessionID: Session.ID; readonly prompt: string }
export type Endpoint5_27Output = { readonly text: string }
export type SessionGenerateOperation<E = never> = (input: Endpoint5_27Input) => Effect.Effect<Endpoint5_27Output, E>

export type Endpoint5_28Input = {
  readonly sessionID: Session.ID
  readonly after?: Event.Seq | undefined
  readonly follow?: boolean | undefined
}
export type Endpoint5_28Output =
  | (
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.created"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: {
            readonly sessionID: Session.ID
            readonly projectID: Project.ID
            readonly location: Location.Ref
            readonly subpath?: RelativePath | undefined
            readonly parentID?: Session.ID | undefined
            readonly slug: string
            readonly title?: string | undefined
            readonly agent?: Agent.ID | undefined
            readonly model?: Model.Ref | undefined
            readonly version: string
          }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.agent.selected"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: { readonly sessionID: Session.ID; readonly agent: Agent.ID }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.model.selected"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: { readonly sessionID: Session.ID; readonly model: Model.Ref }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.moved"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: {
            readonly sessionID: Session.ID
            readonly location: Location.Ref
            readonly projectID?: Project.ID | undefined
            readonly subpath?: RelativePath | undefined
          }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.renamed"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: { readonly sessionID: Session.ID; readonly title: string }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.deleted"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: { readonly sessionID: Session.ID }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.forked"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: {
            readonly sessionID: Session.ID
            readonly parentID: Session.ID
            readonly boundary: Session.ForkBoundary
            readonly instructions?:
              | { readonly [x: string & Brand.Brand<"Instruction.Key">]: string & Brand.Brand<"Instruction.Hash"> }
              | undefined
          }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.input.promoted"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: { readonly sessionID: Session.ID; readonly inputID: SessionMessage.ID }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.input.admitted"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: {
            readonly sessionID: Session.ID
            readonly inputID: SessionMessage.ID
            readonly input: SessionPending.Message
          }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.execution.started"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: { readonly sessionID: Session.ID }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.execution.succeeded"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: { readonly sessionID: Session.ID }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.execution.failed"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: {
            readonly sessionID: Session.ID
            readonly error: { readonly type: string; readonly message: string; readonly status?: number | undefined }
          }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.execution.interrupted"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: { readonly sessionID: Session.ID; readonly reason: "user" | "shutdown" | "superseded" }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.instructions.updated"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: {
            readonly sessionID: Session.ID
            readonly delta: { readonly [x: string]: (string & Brand.Brand<"Instruction.Hash">) | "removed" }
            readonly text?: string | undefined
          }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.synthetic"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: {
            readonly sessionID: Session.ID
            readonly text: string
            readonly description?: string | undefined
            readonly metadata?: { readonly [x: string]: unknown } | undefined
          }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.skill.activated"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: {
            readonly sessionID: Session.ID
            readonly id: Skill.ID
            readonly name: Skill.Name
            readonly text: string
          }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.shell.started"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: { readonly sessionID: Session.ID; readonly shell: Shell.Info }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.shell.ended"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: {
            readonly sessionID: Session.ID
            readonly shell: Shell.Info
            readonly output: {
              readonly output: string
              readonly cursor: number
              readonly size: number
              readonly truncated: boolean
            }
          }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.step.started"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: {
            readonly sessionID: Session.ID
            readonly assistantMessageID: SessionMessage.ID
            readonly agent: Agent.ID
            readonly model: Model.Ref
            readonly snapshot?: (string & Brand.Brand<"Snapshot.ID">) | undefined
          }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.step.ended"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: {
            readonly sessionID: Session.ID
            readonly assistantMessageID: SessionMessage.ID
            readonly finish: "stop" | "length" | "tool-calls" | "content-filter" | "error" | "unknown"
            readonly cost: number & Brand.Brand<"Money.USD">
            readonly tokens: {
              readonly input: number
              readonly output: number
              readonly reasoning: number
              readonly cache: { readonly read: number; readonly write: number }
            }
            readonly snapshot?: (string & Brand.Brand<"Snapshot.ID">) | undefined
            readonly files?: ReadonlyArray<RelativePath> | undefined
          }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.step.failed"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: {
            readonly sessionID: Session.ID
            readonly assistantMessageID: SessionMessage.ID
            readonly error: { readonly type: string; readonly message: string; readonly status?: number | undefined }
            readonly cost?: (number & Brand.Brand<"Money.USD">) | undefined
            readonly tokens?:
              | {
                  readonly input: number
                  readonly output: number
                  readonly reasoning: number
                  readonly cache: { readonly read: number; readonly write: number }
                }
              | undefined
            readonly snapshot?: (string & Brand.Brand<"Snapshot.ID">) | undefined
            readonly files?: ReadonlyArray<RelativePath> | undefined
          }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.text.started"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: {
            readonly sessionID: Session.ID
            readonly assistantMessageID: SessionMessage.ID
            readonly ordinal: number
          }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.text.ended"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: {
            readonly sessionID: Session.ID
            readonly assistantMessageID: SessionMessage.ID
            readonly ordinal: number
            readonly text: string
            readonly state?: SessionMessage.ProviderState | undefined
          }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.reasoning.started"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: {
            readonly sessionID: Session.ID
            readonly assistantMessageID: SessionMessage.ID
            readonly ordinal: number
            readonly state?: SessionMessage.ProviderState | undefined
          }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.reasoning.ended"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: {
            readonly sessionID: Session.ID
            readonly assistantMessageID: SessionMessage.ID
            readonly ordinal: number
            readonly text: string
            readonly state?: SessionMessage.ProviderState | undefined
          }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.tool.input.started"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: {
            readonly sessionID: Session.ID
            readonly assistantMessageID: SessionMessage.ID
            readonly id: string
            readonly name: string
          }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.tool.input.ended"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: {
            readonly sessionID: Session.ID
            readonly assistantMessageID: SessionMessage.ID
            readonly id: string
            readonly text: string
          }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.tool.called"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: {
            readonly sessionID: Session.ID
            readonly assistantMessageID: SessionMessage.ID
            readonly id: string
            readonly input: { readonly [x: string]: unknown }
            readonly executed: boolean
            readonly state?: SessionMessage.ProviderState | undefined
          }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.tool.success"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: {
            readonly sessionID: Session.ID
            readonly assistantMessageID: SessionMessage.ID
            readonly id: string
            readonly content: readonly [
              (
                | { readonly type: "text"; readonly text: string }
                | {
                    readonly type: "file"
                    readonly uri: string
                    readonly mime: string
                    readonly name?: string | undefined
                  }
              ),
              ...Array<
                | { readonly type: "text"; readonly text: string }
                | {
                    readonly type: "file"
                    readonly uri: string
                    readonly mime: string
                    readonly name?: string | undefined
                  }
              >,
            ]
            readonly metadata?: { readonly [x: string]: Schema.Json } | undefined
            readonly executed: boolean
            readonly resultState?: SessionMessage.ProviderState | undefined
          }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.tool.failed"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: {
            readonly sessionID: Session.ID
            readonly assistantMessageID: SessionMessage.ID
            readonly id: string
            readonly error: { readonly type: string; readonly message: string; readonly status?: number | undefined }
            readonly content?:
              | readonly [
                  (
                    | { readonly type: "text"; readonly text: string }
                    | {
                        readonly type: "file"
                        readonly uri: string
                        readonly mime: string
                        readonly name?: string | undefined
                      }
                  ),
                  ...Array<
                    | { readonly type: "text"; readonly text: string }
                    | {
                        readonly type: "file"
                        readonly uri: string
                        readonly mime: string
                        readonly name?: string | undefined
                      }
                  >,
                ]
              | undefined
            readonly metadata?: { readonly [x: string]: Schema.Json } | undefined
            readonly executed: boolean
            readonly resultState?: SessionMessage.ProviderState | undefined
          }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.retry.scheduled"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: {
            readonly sessionID: Session.ID
            readonly assistantMessageID: SessionMessage.ID
            readonly attempt: number
            readonly at: number
            readonly error: { readonly type: string; readonly message: string; readonly status?: number | undefined }
          }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.compaction.admitted"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: { readonly sessionID: Session.ID; readonly inputID: SessionMessage.ID }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.compaction.started"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: {
            readonly sessionID: Session.ID
            readonly reason: "auto" | "manual"
            readonly recent: string
            readonly inputID?: SessionMessage.ID | undefined
          }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.compaction.ended"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: {
            readonly sessionID: Session.ID
            readonly reason: "auto" | "manual"
            readonly text: string
            readonly recent: string
          }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.compaction.failed"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: {
            readonly sessionID: Session.ID
            readonly reason: "auto" | "manual"
            readonly error: { readonly type: string; readonly message: string; readonly status?: number | undefined }
            readonly inputID?: SessionMessage.ID | undefined
          }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.revert.staged"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: { readonly sessionID: Session.ID; readonly revert: Session.Revert }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.revert.cleared"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: { readonly sessionID: Session.ID }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.revert.committed"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: { readonly sessionID: Session.ID; readonly to: SessionMessage.ID }
        }
      | {
          readonly id: Event.ID
          readonly created: DateTime.Utc
          readonly metadata?: { readonly [x: string]: unknown } | undefined
          readonly type: "session.usage.recorded"
          readonly durable: { readonly aggregateID: string; readonly seq: Event.Seq; readonly version: Event.Version }
          readonly location?: Location.Ref | undefined
          readonly data: {
            readonly sessionID: Session.ID
            readonly source: "title" | "compaction"
            readonly cost: number & Brand.Brand<"Money.USD">
            readonly tokens: {
              readonly input: number
              readonly output: number
              readonly reasoning: number
              readonly cache: { readonly read: number; readonly write: number }
            }
          }
        }
    )
  | EventLog.Synced
export type SessionLogOperation<E = never> = (input: Endpoint5_28Input) => Stream.Stream<Endpoint5_28Output, E>

export type Endpoint5_29Input = { readonly sessionID: Session.ID }
export type Endpoint5_29Output = void
export type SessionInterruptOperation<E = never> = (input: Endpoint5_29Input) => Effect.Effect<Endpoint5_29Output, E>

export type Endpoint5_30Input = { readonly sessionID: Session.ID }
export type Endpoint5_30Output = void
export type SessionBackgroundOperation<E = never> = (input: Endpoint5_30Input) => Effect.Effect<Endpoint5_30Output, E>

export type Endpoint5_31Input = { readonly sessionID: Session.ID; readonly messageID: SessionMessage.ID }
export type Endpoint5_31Output = SessionMessage.Info
export type SessionMessageOperation<E = never> = (input: Endpoint5_31Input) => Effect.Effect<Endpoint5_31Output, E>

export interface SessionApi<E = never> {
  readonly list: SessionListOperation<E>
  readonly create: SessionCreateOperation<E>
  readonly import: SessionImportOperation<E>
  readonly export: SessionExportOperation<E>
  readonly active: SessionActiveOperation<E>
  readonly get: SessionGetOperation<E>
  readonly remove: SessionRemoveOperation<E>
  readonly fork: SessionForkOperation<E>
  readonly switchAgent: SessionSwitchAgentOperation<E>
  readonly switchModel: SessionSwitchModelOperation<E>
  readonly rename: SessionRenameOperation<E>
  readonly move: SessionMoveOperation<E>
  readonly prompt: SessionPromptOperation<E>
  readonly command: SessionCommandOperation<E>
  readonly skill: SessionSkillOperation<E>
  readonly synthetic: SessionSyntheticOperation<E>
  readonly shell: SessionShellOperation<E>
  readonly compact: SessionCompactOperation<E>
  readonly wait: SessionWaitOperation<E>
  readonly revert: {
    readonly stage: SessionRevertStageOperation<E>
    readonly clear: SessionRevertClearOperation<E>
    readonly commit: SessionRevertCommitOperation<E>
  }
  readonly context: SessionContextOperation<E>
  readonly pending: { readonly list: SessionPendingListOperation<E> }
  readonly instructions: {
    readonly entry: {
      readonly list: SessionInstructionsEntryListOperation<E>
      readonly put: SessionInstructionsEntryPutOperation<E>
      readonly remove: SessionInstructionsEntryRemoveOperation<E>
    }
  }
  readonly generate: SessionGenerateOperation<E>
  readonly log: SessionLogOperation<E>
  readonly interrupt: SessionInterruptOperation<E>
  readonly background: SessionBackgroundOperation<E>
  readonly message: SessionMessageOperation<E>
}

export type Endpoint6_0Input = {
  readonly sessionID: Session.ID
  readonly limit?: number | undefined
  readonly order?: "asc" | "desc" | undefined
  readonly cursor?: string | undefined
}
export type Endpoint6_0Output = {
  readonly data: ReadonlyArray<SessionMessage.Info>
  readonly cursor: { readonly previous?: string | undefined; readonly next?: string | undefined }
}
export type MessageListOperation<E = never> = (input: Endpoint6_0Input) => Effect.Effect<Endpoint6_0Output, E>

export interface MessageApi<E = never> {
  readonly list: MessageListOperation<E>
}

export type Endpoint7_0Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint7_0Output = { readonly location: Location.Info; readonly data: ReadonlyArray<Model.Info> }
export type ModelListOperation<E = never> = (input?: Endpoint7_0Input) => Effect.Effect<Endpoint7_0Output, E>

export type Endpoint7_1Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint7_1Output = { readonly location: Location.Info; readonly data: Model.Info | undefined }
export type ModelDefaultOperation<E = never> = (input?: Endpoint7_1Input) => Effect.Effect<Endpoint7_1Output, E>

export interface ModelApi<E = never> {
  readonly list: ModelListOperation<E>
  readonly default: ModelDefaultOperation<E>
}

export type Endpoint8_0Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
  readonly prompt: string
  readonly model?: Model.Ref | undefined
}
export type Endpoint8_0Output = { readonly text: string }
export type GenerateTextOperation<E = never> = (input: Endpoint8_0Input) => Effect.Effect<Endpoint8_0Output, E>

export interface GenerateApi<E = never> {
  readonly text: GenerateTextOperation<E>
}

export type Endpoint9_0Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint9_0Output = { readonly location: Location.Info; readonly data: ReadonlyArray<Provider.Info> }
export type ProviderListOperation<E = never> = (input?: Endpoint9_0Input) => Effect.Effect<Endpoint9_0Output, E>

export type Endpoint9_1Input = {
  readonly providerID: Provider.ID
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint9_1Output = { readonly location: Location.Info; readonly data: Provider.Info }
export type ProviderGetOperation<E = never> = (input: Endpoint9_1Input) => Effect.Effect<Endpoint9_1Output, E>

export interface ProviderApi<E = never> {
  readonly list: ProviderListOperation<E>
  readonly get: ProviderGetOperation<E>
}

export type Endpoint10_0Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint10_0Output = { readonly location: Location.Info; readonly data: ReadonlyArray<Integration.Info> }
export type IntegrationListOperation<E = never> = (input?: Endpoint10_0Input) => Effect.Effect<Endpoint10_0Output, E>

export type Endpoint10_1Input = {
  readonly integrationID: Integration.ID
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint10_1Output = { readonly location: Location.Info; readonly data: Integration.Info | undefined }
export type IntegrationGetOperation<E = never> = (input: Endpoint10_1Input) => Effect.Effect<Endpoint10_1Output, E>

export type Endpoint10_2Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
  readonly url: string
}
export type Endpoint10_2Output = void
export type IntegrationWellknownAddOperation<E = never> = (
  input: Endpoint10_2Input,
) => Effect.Effect<Endpoint10_2Output, E>

export type Endpoint10_3Input = {
  readonly integrationID: Integration.ID
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
  readonly key: string
  readonly label?: string | undefined
}
export type Endpoint10_3Output = void
export type IntegrationConnectKeyOperation<E = never> = (
  input: Endpoint10_3Input,
) => Effect.Effect<Endpoint10_3Output, E>

export type Endpoint10_4Input = {
  readonly integrationID: Integration.ID
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
  readonly methodID: Integration.MethodID
  readonly inputs: { readonly [x: string]: string }
  readonly label?: string | undefined
}
export type Endpoint10_4Output = { readonly location: Location.Info; readonly data: Integration.Attempt }
export type IntegrationOauthConnectOperation<E = never> = (
  input: Endpoint10_4Input,
) => Effect.Effect<Endpoint10_4Output, E>

export type Endpoint10_5Input = {
  readonly integrationID: Integration.ID
  readonly attemptID: Integration.AttemptID
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint10_5Output = { readonly location: Location.Info; readonly data: Integration.AttemptStatus }
export type IntegrationOauthStatusOperation<E = never> = (
  input: Endpoint10_5Input,
) => Effect.Effect<Endpoint10_5Output, E>

export type Endpoint10_6Input = {
  readonly integrationID: Integration.ID
  readonly attemptID: Integration.AttemptID
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
  readonly code?: string | undefined
}
export type Endpoint10_6Output = void
export type IntegrationOauthCompleteOperation<E = never> = (
  input: Endpoint10_6Input,
) => Effect.Effect<Endpoint10_6Output, E>

export type Endpoint10_7Input = {
  readonly integrationID: Integration.ID
  readonly attemptID: Integration.AttemptID
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint10_7Output = void
export type IntegrationOauthCancelOperation<E = never> = (
  input: Endpoint10_7Input,
) => Effect.Effect<Endpoint10_7Output, E>

export type Endpoint10_8Input = {
  readonly integrationID: Integration.ID
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
  readonly methodID: Integration.MethodID
  readonly label?: string | undefined
}
export type Endpoint10_8Output = { readonly location: Location.Info; readonly data: Integration.CommandAttempt }
export type IntegrationCommandConnectOperation<E = never> = (
  input: Endpoint10_8Input,
) => Effect.Effect<Endpoint10_8Output, E>

export type Endpoint10_9Input = {
  readonly integrationID: Integration.ID
  readonly attemptID: Integration.AttemptID
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint10_9Output = { readonly location: Location.Info; readonly data: Integration.CommandAttemptStatus }
export type IntegrationCommandStatusOperation<E = never> = (
  input: Endpoint10_9Input,
) => Effect.Effect<Endpoint10_9Output, E>

export type Endpoint10_10Input = {
  readonly integrationID: Integration.ID
  readonly attemptID: Integration.AttemptID
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint10_10Output = void
export type IntegrationCommandCancelOperation<E = never> = (
  input: Endpoint10_10Input,
) => Effect.Effect<Endpoint10_10Output, E>

export interface IntegrationApi<E = never> {
  readonly list: IntegrationListOperation<E>
  readonly get: IntegrationGetOperation<E>
  readonly wellknown: { readonly add: IntegrationWellknownAddOperation<E> }
  readonly connect: { readonly key: IntegrationConnectKeyOperation<E> }
  readonly oauth: {
    readonly connect: IntegrationOauthConnectOperation<E>
    readonly status: IntegrationOauthStatusOperation<E>
    readonly complete: IntegrationOauthCompleteOperation<E>
    readonly cancel: IntegrationOauthCancelOperation<E>
  }
  readonly command: {
    readonly connect: IntegrationCommandConnectOperation<E>
    readonly status: IntegrationCommandStatusOperation<E>
    readonly cancel: IntegrationCommandCancelOperation<E>
  }
}

export type Endpoint11_0Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint11_0Output = { readonly location: Location.Info; readonly data: ReadonlyArray<Mcp.Server> }
export type McpListOperation<E = never> = (input?: Endpoint11_0Input) => Effect.Effect<Endpoint11_0Output, E>

export type Endpoint11_1Input = {
  readonly server: string
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
  readonly config: Mcp.LocalConfig | Mcp.RemoteConfig
}
export type Endpoint11_1Output = void
export type McpAddOperation<E = never> = (input: Endpoint11_1Input) => Effect.Effect<Endpoint11_1Output, E>

export type Endpoint11_2Input = {
  readonly server: string
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint11_2Output = void
export type McpRemoveOperation<E = never> = (input: Endpoint11_2Input) => Effect.Effect<Endpoint11_2Output, E>

export type Endpoint11_3Input = {
  readonly server: string
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint11_3Output = void
export type McpConnectOperation<E = never> = (input: Endpoint11_3Input) => Effect.Effect<Endpoint11_3Output, E>

export type Endpoint11_4Input = {
  readonly server: string
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint11_4Output = void
export type McpDisconnectOperation<E = never> = (input: Endpoint11_4Input) => Effect.Effect<Endpoint11_4Output, E>

export type Endpoint11_5Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint11_5Output = { readonly location: Location.Info; readonly data: Mcp.ResourceCatalog }
export type McpResourceCatalogOperation<E = never> = (input?: Endpoint11_5Input) => Effect.Effect<Endpoint11_5Output, E>

export interface McpApi<E = never> {
  readonly list: McpListOperation<E>
  readonly add: McpAddOperation<E>
  readonly remove: McpRemoveOperation<E>
  readonly connect: McpConnectOperation<E>
  readonly disconnect: McpDisconnectOperation<E>
  readonly resource: { readonly catalog: McpResourceCatalogOperation<E> }
}

export type Endpoint12_0Input = {
  readonly credentialID: Credential.ID
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
  readonly label: string
}
export type Endpoint12_0Output = void
export type CredentialUpdateOperation<E = never> = (input: Endpoint12_0Input) => Effect.Effect<Endpoint12_0Output, E>

export type Endpoint12_1Input = {
  readonly credentialID: Credential.ID
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint12_1Output = void
export type CredentialRemoveOperation<E = never> = (input: Endpoint12_1Input) => Effect.Effect<Endpoint12_1Output, E>

export interface CredentialApi<E = never> {
  readonly update: CredentialUpdateOperation<E>
  readonly remove: CredentialRemoveOperation<E>
}

export type Endpoint13_0Output = ReadonlyArray<Project.Info>
export type ProjectListOperation<E = never> = () => Effect.Effect<Endpoint13_0Output, E>

export type Endpoint13_1Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint13_1Output = Project.Current
export type ProjectCurrentOperation<E = never> = (input?: Endpoint13_1Input) => Effect.Effect<Endpoint13_1Output, E>

export type Endpoint13_2Input = {
  readonly projectID: Project.ID
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint13_2Output = Project.Directories
export type ProjectDirectoriesOperation<E = never> = (input: Endpoint13_2Input) => Effect.Effect<Endpoint13_2Output, E>

export interface ProjectApi<E = never> {
  readonly list: ProjectListOperation<E>
  readonly current: ProjectCurrentOperation<E>
  readonly directories: ProjectDirectoriesOperation<E>
}

export type Endpoint14_0Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint14_0Output = { readonly location: Location.Info; readonly data: ReadonlyArray<Form.Info> }
export type FormRequestListOperation<E = never> = (input?: Endpoint14_0Input) => Effect.Effect<Endpoint14_0Output, E>

export type Endpoint14_1Input = { readonly sessionID: string }
export type Endpoint14_1Output = ReadonlyArray<Form.Info>
export type FormListOperation<E = never> = (input: Endpoint14_1Input) => Effect.Effect<Endpoint14_1Output, E>

export type Endpoint14_2Input = {
  readonly sessionID: string
  readonly id?: Form.ID | undefined
  readonly title: string
  readonly metadata?: Form.Metadata | undefined
  readonly fields: Form.Fields
}
export type Endpoint14_2Output = Form.Info
export type FormCreateOperation<E = never> = (input: Endpoint14_2Input) => Effect.Effect<Endpoint14_2Output, E>

export type Endpoint14_3Input = { readonly sessionID: string; readonly formID: Form.ID }
export type Endpoint14_3Output = Form.Info
export type FormGetOperation<E = never> = (input: Endpoint14_3Input) => Effect.Effect<Endpoint14_3Output, E>

export type Endpoint14_4Input = { readonly sessionID: string; readonly formID: Form.ID }
export type Endpoint14_4Output = Form.State
export type FormStateOperation<E = never> = (input: Endpoint14_4Input) => Effect.Effect<Endpoint14_4Output, E>

export type Endpoint14_5Input = { readonly sessionID: string; readonly formID: Form.ID; readonly answer: Form.Answer }
export type Endpoint14_5Output = void
export type FormReplyOperation<E = never> = (input: Endpoint14_5Input) => Effect.Effect<Endpoint14_5Output, E>

export type Endpoint14_6Input = { readonly sessionID: string; readonly formID: Form.ID }
export type Endpoint14_6Output = void
export type FormCancelOperation<E = never> = (input: Endpoint14_6Input) => Effect.Effect<Endpoint14_6Output, E>

export interface FormApi<E = never> {
  readonly request: { readonly list: FormRequestListOperation<E> }
  readonly list: FormListOperation<E>
  readonly create: FormCreateOperation<E>
  readonly get: FormGetOperation<E>
  readonly state: FormStateOperation<E>
  readonly reply: FormReplyOperation<E>
  readonly cancel: FormCancelOperation<E>
}

export type Endpoint15_0Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint15_0Output = { readonly location: Location.Info; readonly data: ReadonlyArray<Permission.Request> }
export type PermissionRequestListOperation<E = never> = (
  input?: Endpoint15_0Input,
) => Effect.Effect<Endpoint15_0Output, E>

export type Endpoint15_1Input = { readonly projectID?: Project.ID | undefined }
export type Endpoint15_1Output = ReadonlyArray<PermissionSaved.Info>
export type PermissionSavedListOperation<E = never> = (
  input?: Endpoint15_1Input,
) => Effect.Effect<Endpoint15_1Output, E>

export type Endpoint15_2Input = { readonly id: PermissionSaved.ID }
export type Endpoint15_2Output = void
export type PermissionSavedRemoveOperation<E = never> = (
  input: Endpoint15_2Input,
) => Effect.Effect<Endpoint15_2Output, E>

export type Endpoint15_3Input = {
  readonly sessionID: Session.ID
  readonly id?: Permission.ID | undefined
  readonly action: string
  readonly resources: ReadonlyArray<string>
  readonly save?: ReadonlyArray<string> | undefined
  readonly metadata?: { readonly [x: string]: unknown } | undefined
  readonly source?: Permission.Source | undefined
  readonly agent?: Agent.ID | undefined
}
export type Endpoint15_3Output = { readonly id: Permission.ID; readonly effect: Permission.Effect }
export type PermissionCreateOperation<E = never> = (input: Endpoint15_3Input) => Effect.Effect<Endpoint15_3Output, E>

export type Endpoint15_4Input = { readonly sessionID: Session.ID }
export type Endpoint15_4Output = ReadonlyArray<Permission.Request>
export type PermissionListOperation<E = never> = (input: Endpoint15_4Input) => Effect.Effect<Endpoint15_4Output, E>

export type Endpoint15_5Input = { readonly sessionID: Session.ID; readonly requestID: Permission.ID }
export type Endpoint15_5Output = Permission.Request
export type PermissionGetOperation<E = never> = (input: Endpoint15_5Input) => Effect.Effect<Endpoint15_5Output, E>

export type Endpoint15_6Input = {
  readonly sessionID: Session.ID
  readonly requestID: Permission.ID
  readonly reply: Permission.Reply
  readonly message?: string | undefined
}
export type Endpoint15_6Output = void
export type PermissionReplyOperation<E = never> = (input: Endpoint15_6Input) => Effect.Effect<Endpoint15_6Output, E>

export interface PermissionApi<E = never> {
  readonly request: { readonly list: PermissionRequestListOperation<E> }
  readonly saved: { readonly list: PermissionSavedListOperation<E>; readonly remove: PermissionSavedRemoveOperation<E> }
  readonly create: PermissionCreateOperation<E>
  readonly list: PermissionListOperation<E>
  readonly get: PermissionGetOperation<E>
  readonly reply: PermissionReplyOperation<E>
}

export type Endpoint16_0Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
  readonly path?: RelativePath | undefined
}
export type Endpoint16_0Output = { readonly location: Location.Info; readonly data: ReadonlyArray<FileSystem.Entry> }
export type FileListOperation<E = never> = (input?: Endpoint16_0Input) => Effect.Effect<Endpoint16_0Output, E>

export type Endpoint16_1Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
  readonly query: string
  readonly type?: "file" | "directory" | undefined
  readonly limit?: number | undefined
}
export type Endpoint16_1Output = { readonly location: Location.Info; readonly data: ReadonlyArray<FileSystem.Entry> }
export type FileFindOperation<E = never> = (input: Endpoint16_1Input) => Effect.Effect<Endpoint16_1Output, E>

export interface FileApi<E = never> {
  readonly list: FileListOperation<E>
  readonly find: FileFindOperation<E>
}

export type Endpoint17_0Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint17_0Output = { readonly location: Location.Info; readonly data: ReadonlyArray<Command.Info> }
export type CommandListOperation<E = never> = (input?: Endpoint17_0Input) => Effect.Effect<Endpoint17_0Output, E>

export interface CommandApi<E = never> {
  readonly list: CommandListOperation<E>
}

export type Endpoint18_0Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint18_0Output = { readonly location: Location.Info; readonly data: ReadonlyArray<Skill.Info> }
export type SkillListOperation<E = never> = (input?: Endpoint18_0Input) => Effect.Effect<Endpoint18_0Output, E>

export interface SkillApi<E = never> {
  readonly list: SkillListOperation<E>
}

export type Endpoint19_0Output = OpenCodeEvent
export type EventSubscribeOperation<E = never> = () => Stream.Stream<Endpoint19_0Output, E>

export interface EventApi<E = never> {
  readonly subscribe: EventSubscribeOperation<E>
}

export type Endpoint20_0Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint20_0Output = { readonly location: Location.Info; readonly data: ReadonlyArray<Pty.Info> }
export type PtyListOperation<E = never> = (input?: Endpoint20_0Input) => Effect.Effect<Endpoint20_0Output, E>

export type Endpoint20_1Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
  readonly command?: string | undefined
  readonly args?: ReadonlyArray<string> | undefined
  readonly cwd?: string | undefined
  readonly title?: string | undefined
  readonly env?: { readonly [x: string]: string } | undefined
}
export type Endpoint20_1Output = { readonly location: Location.Info; readonly data: Pty.Info }
export type PtyCreateOperation<E = never> = (input?: Endpoint20_1Input) => Effect.Effect<Endpoint20_1Output, E>

export type Endpoint20_2Input = {
  readonly ptyID: Pty.ID
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint20_2Output = { readonly location: Location.Info; readonly data: Pty.Info }
export type PtyGetOperation<E = never> = (input: Endpoint20_2Input) => Effect.Effect<Endpoint20_2Output, E>

export type Endpoint20_3Input = {
  readonly ptyID: Pty.ID
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
  readonly title?: string | undefined
  readonly size?: { readonly rows: number; readonly cols: number } | undefined
}
export type Endpoint20_3Output = { readonly location: Location.Info; readonly data: Pty.Info }
export type PtyUpdateOperation<E = never> = (input: Endpoint20_3Input) => Effect.Effect<Endpoint20_3Output, E>

export type Endpoint20_4Input = {
  readonly ptyID: Pty.ID
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint20_4Output = void
export type PtyRemoveOperation<E = never> = (input: Endpoint20_4Input) => Effect.Effect<Endpoint20_4Output, E>

export interface PtyApi<E = never> {
  readonly list: PtyListOperation<E>
  readonly create: PtyCreateOperation<E>
  readonly get: PtyGetOperation<E>
  readonly update: PtyUpdateOperation<E>
  readonly remove: PtyRemoveOperation<E>
}

export type Endpoint21_0Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint21_0Output = { readonly location: Location.Info; readonly data: ReadonlyArray<Shell.Info> }
export type ShellListOperation<E = never> = (input?: Endpoint21_0Input) => Effect.Effect<Endpoint21_0Output, E>

export type Endpoint21_1Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
  readonly command: string
  readonly cwd?: string | undefined
  readonly timeout: number
  readonly metadata?: { readonly [x: string]: unknown } | undefined
}
export type Endpoint21_1Output = { readonly location: Location.Info; readonly data: Shell.Info }
export type ShellCreateOperation<E = never> = (input: Endpoint21_1Input) => Effect.Effect<Endpoint21_1Output, E>

export type Endpoint21_2Input = {
  readonly id: Shell.ID
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint21_2Output = { readonly location: Location.Info; readonly data: Shell.Info }
export type ShellGetOperation<E = never> = (input: Endpoint21_2Input) => Effect.Effect<Endpoint21_2Output, E>

export type Endpoint21_3Input = {
  readonly id: Shell.ID
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
  readonly timeout: number
}
export type Endpoint21_3Output = { readonly location: Location.Info; readonly data: Shell.Info }
export type ShellTimeoutOperation<E = never> = (input: Endpoint21_3Input) => Effect.Effect<Endpoint21_3Output, E>

export type Endpoint21_4Input = {
  readonly id: Shell.ID
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
  readonly cursor?: number | undefined
  readonly limit?: number | undefined
}
export type Endpoint21_4Output = {
  readonly location: Location.Info
  readonly data: {
    readonly output: string
    readonly cursor: number
    readonly size: number
    readonly truncated: boolean
  }
}
export type ShellOutputOperation<E = never> = (input: Endpoint21_4Input) => Effect.Effect<Endpoint21_4Output, E>

export type Endpoint21_5Input = {
  readonly id: Shell.ID
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint21_5Output = void
export type ShellRemoveOperation<E = never> = (input: Endpoint21_5Input) => Effect.Effect<Endpoint21_5Output, E>

export interface ShellApi<E = never> {
  readonly list: ShellListOperation<E>
  readonly create: ShellCreateOperation<E>
  readonly get: ShellGetOperation<E>
  readonly timeout: ShellTimeoutOperation<E>
  readonly output: ShellOutputOperation<E>
  readonly remove: ShellRemoveOperation<E>
}

export type Endpoint22_0Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint22_0Output = { readonly location: Location.Info; readonly data: ReadonlyArray<Question.Request> }
export type QuestionRequestListOperation<E = never> = (
  input?: Endpoint22_0Input,
) => Effect.Effect<Endpoint22_0Output, E>

export type Endpoint22_1Input = { readonly sessionID: Session.ID }
export type Endpoint22_1Output = ReadonlyArray<Question.Request>
export type QuestionListOperation<E = never> = (input: Endpoint22_1Input) => Effect.Effect<Endpoint22_1Output, E>

export type Endpoint22_2Input = {
  readonly sessionID: Session.ID
  readonly requestID: Question.ID
  readonly answers: ReadonlyArray<Question.Answer>
}
export type Endpoint22_2Output = void
export type QuestionReplyOperation<E = never> = (input: Endpoint22_2Input) => Effect.Effect<Endpoint22_2Output, E>

export type Endpoint22_3Input = { readonly sessionID: Session.ID; readonly requestID: Question.ID }
export type Endpoint22_3Output = void
export type QuestionRejectOperation<E = never> = (input: Endpoint22_3Input) => Effect.Effect<Endpoint22_3Output, E>

export interface QuestionApi<E = never> {
  readonly request: { readonly list: QuestionRequestListOperation<E> }
  readonly list: QuestionListOperation<E>
  readonly reply: QuestionReplyOperation<E>
  readonly reject: QuestionRejectOperation<E>
}

export type Endpoint23_0Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint23_0Output = { readonly location: Location.Info; readonly data: ReadonlyArray<Reference.Info> }
export type ReferenceListOperation<E = never> = (input?: Endpoint23_0Input) => Effect.Effect<Endpoint23_0Output, E>

export interface ReferenceApi<E = never> {
  readonly list: ReferenceListOperation<E>
}

export type Endpoint24_0Input = {
  readonly projectID: Project.ID
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
  readonly strategy: ProjectCopy.StrategyID
  readonly directory: AbsolutePath
  readonly name?: string | undefined
}
export type Endpoint24_0Output = ProjectCopy.Copy
export type ProjectCopyCreateOperation<E = never> = (input: Endpoint24_0Input) => Effect.Effect<Endpoint24_0Output, E>

export type Endpoint24_1Input = {
  readonly projectID: Project.ID
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
  readonly directory: AbsolutePath
  readonly force: boolean
}
export type Endpoint24_1Output = void
export type ProjectCopyRemoveOperation<E = never> = (input: Endpoint24_1Input) => Effect.Effect<Endpoint24_1Output, E>

export type Endpoint24_2Input = {
  readonly projectID: Project.ID
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint24_2Output = void
export type ProjectCopyRefreshOperation<E = never> = (input: Endpoint24_2Input) => Effect.Effect<Endpoint24_2Output, E>

export interface ProjectCopyApi<E = never> {
  readonly create: ProjectCopyCreateOperation<E>
  readonly remove: ProjectCopyRemoveOperation<E>
  readonly refresh: ProjectCopyRefreshOperation<E>
}

export type Endpoint25_0Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint25_0Output = { readonly location: Location.Info; readonly data: Vcs.Info }
export type VcsGetOperation<E = never> = (input?: Endpoint25_0Input) => Effect.Effect<Endpoint25_0Output, E>

export type Endpoint25_1Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint25_1Output = { readonly location: Location.Info; readonly data: ReadonlyArray<Vcs.FileStatus> }
export type VcsStatusOperation<E = never> = (input?: Endpoint25_1Input) => Effect.Effect<Endpoint25_1Output, E>

export type Endpoint25_2Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
  readonly mode: Vcs.Mode
  readonly context?: number | undefined
}
export type Endpoint25_2Output = { readonly location: Location.Info; readonly data: ReadonlyArray<FileDiff.Info> }
export type VcsDiffOperation<E = never> = (input: Endpoint25_2Input) => Effect.Effect<Endpoint25_2Output, E>

export interface VcsApi<E = never> {
  readonly get: VcsGetOperation<E>
  readonly status: VcsStatusOperation<E>
  readonly diff: VcsDiffOperation<E>
}

export type Endpoint26_0Output = ReadonlyArray<Location.Ref>
export type DebugLocationListOperation<E = never> = () => Effect.Effect<Endpoint26_0Output, E>

export type Endpoint26_1Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint26_1Output = void
export type DebugLocationEvictOperation<E = never> = (input?: Endpoint26_1Input) => Effect.Effect<Endpoint26_1Output, E>

export interface DebugApi<E = never> {
  readonly location: { readonly list: DebugLocationListOperation<E>; readonly evict: DebugLocationEvictOperation<E> }
}

export type Endpoint27_0Output =
  | { readonly status: "required" | "completed" }
  | {
      readonly status: "running"
      readonly progress: {
        readonly label: string
        readonly numerator?: number | undefined
        readonly denominator?: number | undefined
      }
    }
  | { readonly status: "error"; readonly error: string }
export type MigrationV1StatusOperation<E = never> = () => Effect.Effect<Endpoint27_0Output, E>

export interface MigrationApi<E = never> {
  readonly v1: { readonly status: MigrationV1StatusOperation<E> }
}

export type Endpoint28_0Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint28_0Output = { readonly location: Location.Info; readonly data: ReadonlyArray<WebSearch.Provider> }
export type WebsearchProvidersOperation<E = never> = (input?: Endpoint28_0Input) => Effect.Effect<Endpoint28_0Output, E>

export type Endpoint28_1Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
  readonly query: string
  readonly providerID?: WebSearch.ID | undefined
}
export type Endpoint28_1Output = { readonly location: Location.Info; readonly data: WebSearch.Response }
export type WebsearchQueryOperation<E = never> = (input: Endpoint28_1Input) => Effect.Effect<Endpoint28_1Output, E>

export interface WebsearchApi<E = never> {
  readonly providers: WebsearchProvidersOperation<E>
  readonly query: WebsearchQueryOperation<E>
}

export type Endpoint29_0Input = {
  readonly location?: { readonly directory?: string | undefined; readonly workspace?: string | undefined } | undefined
}
export type Endpoint29_0Output = ReadonlyArray<Config.Entry>
export type ConfigGetOperation<E = never> = (input?: Endpoint29_0Input) => Effect.Effect<Endpoint29_0Output, E>

export interface ConfigApi<E = never> {
  readonly get: ConfigGetOperation<E>
}

export interface AppApi<E = never> {
  readonly health: HealthApi<E>
  readonly server: ServerApi<E>
  readonly location: LocationApi<E>
  readonly agent: AgentApi<E>
  readonly plugin: PluginApi<E>
  readonly session: SessionApi<E>
  readonly message: MessageApi<E>
  readonly model: ModelApi<E>
  readonly generate: GenerateApi<E>
  readonly provider: ProviderApi<E>
  readonly integration: IntegrationApi<E>
  readonly mcp: McpApi<E>
  readonly credential: CredentialApi<E>
  readonly project: ProjectApi<E>
  readonly form: FormApi<E>
  readonly permission: PermissionApi<E>
  readonly file: FileApi<E>
  readonly command: CommandApi<E>
  readonly skill: SkillApi<E>
  readonly event: EventApi<E>
  readonly pty: PtyApi<E>
  readonly shell: ShellApi<E>
  readonly question: QuestionApi<E>
  readonly reference: ReferenceApi<E>
  readonly projectCopy: ProjectCopyApi<E>
  readonly vcs: VcsApi<E>
  readonly debug: DebugApi<E>
  readonly migration: MigrationApi<E>
  readonly websearch: WebsearchApi<E>
  readonly config: ConfigApi<E>
}
