@neta-art/cohub 1.9.0 → 1.10.0

package/dist/chunks/http.d.ts

@@ -0,0 +1,1615 @@
+import { a as WebsocketClientOptions, d as SessionTurnPatchEvent, l as ContentBlock, p as CohubEnvironment, r as WebsocketClient, s as WebsocketEventPayload, u as RealtimePatchOperation } from "./websocket.js";
+
+//#region ../protocol/src/core/usage.d.ts
+type Usage = {
+  input?: number;
+  output?: number;
+  cacheRead?: number;
+  cacheWrite?: number;
+  totalTokens?: number;
+  cost?: {
+    input?: number;
+    output?: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+    total?: number;
+  } | null;
+};
+//#endregion
+//#region src/transport.d.ts
+type Fetch = typeof globalThis.fetch;
+type RequestInitWithFetch = RequestInit & {
+  fetch?: Fetch;
+};
+type RawHttpResponse = {
+  response: Response;
+  blob(): Promise<Blob>;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  text(): Promise<string>;
+  json(): Promise<unknown>;
+};
+type CohubClientOptions = {
+  env?: CohubEnvironment;
+  baseUrl?: string;
+  getAccessToken?: () => Promise<string | null> | string | null;
+  onUnauthorized?: () => Promise<void> | void;
+  setStoredAuthToken?: (token: string) => void;
+  clearStoredAuthToken?: () => void;
+  fetch?: Fetch;
+  websocket?: WebsocketClientOptions;
+};
+declare class HttpError extends Error {
+  readonly status: number;
+  readonly body: unknown;
+  constructor(message: string, status: number, body: unknown);
+}
+declare class HttpTransport {
+  private readonly baseUrl;
+  private readonly fetcher;
+  private readonly getAccessToken?;
+  private readonly onUnauthorized?;
+  constructor(options?: CohubClientOptions);
+  private withAuthorization;
+  private send;
+  request<T>(path: string, init?: RequestInitWithFetch): Promise<T>;
+  raw(path: string, init?: RequestInitWithFetch): Promise<RawHttpResponse>;
+  blob(path: string, init?: RequestInitWithFetch): Promise<Blob>;
+}
+//#endregion
+//#region ../protocol/src/model/turn.d.ts
+type SessionTurnStatus = "queued" | "running" | "abort_requested" | "completed" | "failed" | "interrupted" | "merged" | "cancelled";
+type SessionTurnIntent = "steer" | "followup";
+type SessionTurnSummary = {
+  text?: string | null;
+  finishReason?: "completed" | "failed" | "interrupted" | "merged" | "cancelled";
+  reason?: "steer" | "abort" | "merge" | string;
+  continuedByTurnId?: string | null;
+  interruptedByTurnId?: string | null;
+  mergedIntoTurnId?: string | null;
+};
+type SessionTurnIntermediateIndex = {
+  version: 1;
+  messagesObjectKey: string | null;
+  messagesSizeBytes?: number | null;
+  toolCallsBaseObjectKey?: string | null;
+};
+type SessionTurnIntermediateSummary = {
+  messageCount: number;
+  toolCallCount: number;
+  usage?: Usage | null;
+  lastMessageText?: string | null;
+  hasError?: boolean;
+};
+type SessionTurnIndexItem = {
+  id: string;
+  sessionId: string;
+  sourceSessionId?: string;
+  sourceTurnId?: string;
+  sequence: number;
+  status: SessionTurnStatus;
+  startedAt: string | null;
+  completedAt: string | null;
+  createdAt: string;
+  updatedAt: string;
+  userPreview: string | null;
+  assistantPreview: string | null;
+  provider: string | null;
+  model: string | null;
+  finalUsage: Usage | null;
+  totalUsage: Usage | null;
+  errorMessage: string | null;
+};
+type SessionTurnAuthorProfile = {
+  userUuid: string;
+  displayName: string;
+  avatarUrl: string | null;
+};
+type SessionTurnRecord = {
+  id: string;
+  sessionId: string;
+  sourceSessionId?: string;
+  sourceTurnId?: string;
+  userUuid: string | null;
+  sequence: number;
+  status: SessionTurnStatus;
+  intent: SessionTurnIntent;
+  userContent: ContentBlock[];
+  userText: string | null;
+  assistantContent: ContentBlock[] | null;
+  assistantText: string | null;
+  provider: string | null;
+  model: string | null;
+  stopReason: string | null;
+  errorMessage: string | null;
+  finalUsage: Usage | null;
+  totalUsage: Usage | null;
+  summary: SessionTurnSummary | null;
+  intermediateIndex: SessionTurnIntermediateIndex | null;
+  intermediateSummary: SessionTurnIntermediateSummary | null;
+  meta: Record<string, unknown> | null;
+  authorProfile?: SessionTurnAuthorProfile | null;
+  startedAt: string | null;
+  completedAt: string | null;
+  createdAt: string;
+  updatedAt: string;
+};
+//#endregion
+//#region ../protocol/src/model/session.d.ts
+type SessionForkRecord = {
+  id: string;
+  spaceId: string;
+  parentSessionId: string;
+  childSessionId: string;
+  rootSessionId: string;
+  depth: number;
+  anchorSourceSessionId: string;
+  anchorTurnId: string;
+  anchorSequence: number;
+  ancestorSessionIds: string[];
+  sessionPath: string[];
+  createdBy: string | null;
+  createdAt: string;
+};
+type SessionTurnSegmentRecord = {
+  id: string;
+  sessionId: string;
+  ordinal: number;
+  sourceSessionId: string;
+  fromSequence: number;
+  toSequence: number | null;
+  createdAt: string;
+};
+type SessionBindingRecord$1 = {
+  id: string;
+  spaceId: string;
+  spaceSessionId: string;
+  spaceChannelId: string;
+  provider: string;
+  bindingKey: string;
+  externalChatId: string;
+  status: string | null;
+  meta: Record<string, unknown> | null;
+  createdAt: string;
+  updatedAt: string;
+  lastMessageAt: string | null;
+};
+type SessionRecord$1 = {
+  id: string;
+  spaceId: string;
+  title: string | null;
+  source: string | null;
+  status: string | null;
+  externalSessionId: string | null;
+  meta: Record<string, unknown> | null;
+  latestMessageText: string | null;
+  lastMessageAt: string | null;
+  lastMessageId: string | null;
+  createdAt: string;
+  updatedAt: string;
+};
+type MessageAuthorProfile = {
+  userUuid: string;
+  displayName: string;
+  avatarUrl: string | null;
+};
+type MessageRecord = {
+  id: string;
+  sessionId: string;
+  role: "user" | "assistant" | "system";
+  content: ContentBlock[];
+  text: string | null;
+  sequence: number;
+  provider: string | null;
+  model: string | null;
+  stopReason: string | null;
+  errorMessage: string | null;
+  usage: Usage | null;
+  meta: Record<string, unknown> | null;
+  authorUuid?: string | null;
+  authorProfile?: MessageAuthorProfile | null;
+  createdAt: string;
+};
+//#endregion
+//#region ../protocol/dist/gateway/types.d.ts
+type DiscordChannelConfig = {
+  inbound?: {
+    requireMentionInGuild?: boolean;
+  };
+  outbound?: {
+    showThinking?: boolean;
+    showToolCalls?: boolean;
+  };
+};
+type FeishuChannelConfig = {
+  brand?: "feishu" | "lark";
+  inbound?: {
+    requireMentionInGroup?: boolean;
+  };
+  outbound?: {
+    renderMode?: "card" | "post";
+    showThinking?: boolean;
+    showToolCalls?: boolean;
+  };
+};
+type ChannelConfig = DiscordChannelConfig | FeishuChannelConfig | Record<string, unknown>;
+//#endregion
+//#region ../protocol/dist/generation/index.d.ts
+type GenerationSource = {
+  type: "url";
+  url: string;
+} | {
+  type: "base64";
+  media_type: string;
+  data: string;
+} | {
+  type: "space_file";
+  space_id: string;
+  path: string;
+};
+type GenerationContentBlockMeta = Record<string, unknown>;
+type GenerationContentBlock = {
+  type: "text";
+  text: string;
+  _meta?: GenerationContentBlockMeta;
+} | {
+  type: "image";
+  source: GenerationSource;
+  _meta?: GenerationContentBlockMeta;
+} | {
+  type: "video";
+  source: GenerationSource;
+  _meta?: GenerationContentBlockMeta;
+} | {
+  type: "audio";
+  source: GenerationSource;
+  _meta?: GenerationContentBlockMeta;
+};
+type CreateGenerationRequest = {
+  model: string;
+  content: GenerationContentBlock[];
+  parameters?: Record<string, unknown>;
+  metadata?: Record<string, unknown>;
+};
+type GenerationStatus = "queued" | "running" | "succeeded" | "failed" | "cancelled";
+type Generation = {
+  id: string;
+  status: GenerationStatus;
+  model: string;
+  input: GenerationContentBlock[];
+  output?: GenerationContentBlock[];
+  parameters?: Record<string, unknown>;
+  metadata?: Record<string, unknown>;
+  error?: {
+    code?: string;
+    message: string;
+    raw?: unknown;
+  };
+  created_at: string;
+  updated_at: string;
+  completed_at?: string;
+};
+type GenerationContentSpec = {
+  type: "text" | "image" | "video" | "audio";
+  required?: boolean;
+  min?: number;
+  max?: number;
+  sources?: Array<"url" | "base64" | "space_file">;
+  merge?: "newline" | "space" | "concat";
+  meta?: Record<string, unknown>;
+  description?: string;
+};
+type GenerationParameterSpec = {
+  type: "string";
+  optional?: boolean;
+  default?: string;
+  enum?: string[];
+  description?: string;
+  examples?: string[];
+} | {
+  type: "number";
+  optional?: boolean;
+  default?: number;
+  min?: number;
+  max?: number;
+  description?: string;
+  examples?: number[];
+} | {
+  type: "integer";
+  optional?: boolean;
+  default?: number;
+  min?: number;
+  max?: number;
+  description?: string;
+  examples?: number[];
+} | {
+  type: "boolean";
+  optional?: boolean;
+  default?: boolean;
+  description?: string;
+  examples?: boolean[];
+};
+type GenerationDeclaration = {
+  schema: "cohub.generation.v1";
+  model: string;
+  title?: string;
+  description?: string;
+  adapter: {
+    type: string;
+    base_url: string;
+    api_key: string;
+  };
+  content: {
+    input: GenerationContentSpec[];
+  };
+  parameters?: Record<string, GenerationParameterSpec>;
+  examples?: Array<{
+    title?: string;
+    request: CreateGenerationRequest;
+  }>;
+};
+type PublicGenerationDeclaration = Omit<GenerationDeclaration, "adapter">;
+type ListGenerationModelsResponse = {
+  models: PublicGenerationDeclaration[];
+};
+//#endregion
+//#region src/types.d.ts
+type ApiError = {
+  message: string;
+};
+type UserProfile = {
+  userUuid: string;
+  logtoUserId?: string;
+  displayName: string;
+  avatarUrl: string | null;
+  syncedAt?: string;
+};
+type MeResponse = {
+  uuid: string;
+  profile: UserProfile;
+  email: string | null;
+};
+type UserRulesResponse = {
+  content: string;
+  updatedAt: string | null;
+  source: "config-space";
+  path: string;
+};
+type SpaceFsEntry = {
+  name: string;
+  path: string;
+  type: "file" | "dir" | "symlink";
+  size: number;
+  mimeType: string | null;
+  mtimeMs: number;
+};
+type SpaceFsTreeResponse = {
+  path: string;
+  entries: SpaceFsEntry[];
+};
+type SpaceFsFileKind = "text" | "binary";
+type SpaceFsEncoding = "utf-8" | "base64";
+type SpaceFsFileResponse = {
+  path: string;
+  name: string;
+  size: number;
+  mimeType: string | null;
+  mtimeMs: number;
+  kind: SpaceFsFileKind;
+  encoding: SpaceFsEncoding;
+  content: string;
+  delivery?: "inline" | "url";
+  url?: string;
+};
+type SpaceFsReadFilesInput = {
+  paths: string[];
+};
+type SpaceFsReadFilesError = {
+  path: string;
+  code: string;
+  message: string;
+  status: number;
+};
+type SpaceFsPreparingFile = {
+  path: string;
+  name: string;
+  size: number;
+  mimeType: string | null;
+  mtimeMs: number;
+  retryAfterMs: number;
+};
+type SpaceFsReadFilesResponse = {
+  files: SpaceFsFileResponse[];
+  preparing?: SpaceFsPreparingFile[];
+  errors: SpaceFsReadFilesError[];
+};
+type SpaceFsWriteFileInput = {
+  path: string;
+  content: string;
+  encoding: SpaceFsEncoding;
+};
+type SpaceFsMoveInput = {
+  fromPath: string;
+  toPath: string;
+};
+type SpaceFsUploadEntry = {
+  path: string;
+  name: string;
+  size: number;
+  mimeType: string | null;
+  mtimeMs: number;
+};
+type SpaceFsUploadError = {
+  name: string;
+  code: "file_too_large" | "name_invalid" | "path_invalid" | "write_failed" | "object_missing";
+  message: string;
+};
+type SpaceFsUploadResponse = {
+  uploaded: SpaceFsUploadEntry[];
+  errors: SpaceFsUploadError[];
+};
+type SpaceFsUploadPlanEntryInput = {
+  id: string;
+  name: string;
+  relativePath: string;
+  size: number;
+  mimeType?: string | null;
+  lastModified?: number;
+};
+type SpaceFsCreateUploadInput = {
+  targetDir?: string;
+  entries: SpaceFsUploadPlanEntryInput[];
+};
+type SpaceFsUploadPlanEntry = {
+  id: string;
+  objectKey: string;
+  uploadUrl: string;
+  headers?: Record<string, string>;
+};
+type SpaceFsCreateUploadResponse = {
+  uploadId: string;
+  expiresAt: string;
+  entries: SpaceFsUploadPlanEntry[];
+};
+type SpaceFsCompleteUploadInput = {
+  entries: Array<{
+    id: string;
+    etag?: string | null;
+  }>;
+};
+type SpaceFsCompleteUploadResponse = {
+  ok: true;
+  taskRunId: string;
+};
+type SpaceFsUploadProgress = {
+  phase: "queued" | "importing" | "done" | "failed";
+  totalFiles: number;
+  importedFiles: number;
+  totalBytes: number;
+  importedBytes: number;
+  currentPath?: string;
+  errors: SpaceFsUploadError[];
+};
+type SessionBindingRecord = SessionBindingRecord$1;
+type SessionRecord = SessionRecord$1 & {
+  bindings?: SessionBindingRecord[];
+  totalMessages?: number;
+  totalToolCalls?: number;
+  totalInputTokens?: number;
+  totalOutputTokens?: number;
+  totalCost?: string | number | null;
+};
+type SpaceGitInfo = {
+  giteaHost: string;
+  giteaUsername: string;
+};
+type SpaceRecord = {
+  id: string;
+  userUuid: string;
+  name: string | null;
+  description: string | null;
+  storageRepoName?: string | null;
+  baseCheckpointId?: string | null;
+  headCheckpointId?: string | null;
+  title: string | null;
+  status: string | null;
+  meta: Record<string, unknown> | null;
+  createdAt: string;
+  updatedAt: string;
+  channels?: {
+    id: string;
+    name: string | null;
+    provider: string;
+    status: string;
+  }[];
+  accessLevel?: "minimal";
+  ownerProfile?: Pick<UserProfile, "userUuid" | "displayName" | "avatarUrl"> | null;
+  gitInfo?: SpaceGitInfo | null;
+};
+type SpaceBootstrapSource = {
+  type: "blank";
+} | {
+  type: "git_repo";
+  repoUrl?: string;
+  ref?: string | null;
+} | {
+  type: "checkpoint";
+  checkpointId: string;
+};
+type SpaceCreateResponse = {
+  space: SpaceRecord;
+  taskRunId: string;
+};
+type SpaceListItem = SpaceRecord;
+type SessionMessagesResponse = {
+  session: SessionRecord;
+  messages: MessageRecord[];
+};
+type SessionMessageResponse = {
+  session: SessionRecord;
+  message: MessageRecord;
+};
+type SessionMessagesPaginatedResponse = {
+  session: SessionRecord;
+  messages: MessageRecord[];
+  hasMore: boolean;
+  nextCursor: number | undefined;
+};
+type SessionTurnsPaginatedResponse = {
+  session: SessionRecord;
+  turns: SessionTurnRecord[];
+  hasMore: boolean;
+  nextCursor: number | undefined;
+};
+type SessionTurnIndexResponse = {
+  session: SessionRecord;
+  turns: SessionTurnIndexItem[];
+  hasMore: boolean;
+  nextCursor: number | undefined;
+};
+type SessionTurnWindowResponse = {
+  session: SessionRecord;
+  turns: SessionTurnRecord[];
+  hasMoreOlder: boolean;
+  hasMoreNewer: boolean;
+  oldestCursor: number | undefined;
+  newestCursor: number | undefined;
+  anchorSequence: number | undefined;
+};
+type SessionTurnResponse = {
+  session: SessionRecord;
+  turn: SessionTurnRecord;
+};
+type SessionTurnSignedUrlsResponse = {
+  urls: Record<string, string>;
+};
+type SessionTurnStreamSnapshotResponse = {
+  snapshot: {
+    version: 2;
+    spaceId: string;
+    sessionId: string;
+    turnId: string | null;
+    anchorUserMessageId: string | null;
+    seq: number;
+    current: {
+      messageId: string | null;
+      messageOrdinal: number | null;
+      content: ContentBlock[];
+      appendPath: string | null;
+    };
+    intermediateMessages: Array<{
+      messageId: string | null;
+      messageOrdinal: number | null;
+      content: ContentBlock[];
+      id?: string;
+      sessionId?: string;
+      role?: "user" | "assistant" | "system";
+      text?: string | null;
+      provider?: string | null;
+      model?: string | null;
+      stopReason?: string | null;
+      errorMessage?: string | null;
+      usage?: Usage | null;
+      toolCallsObjectKey?: string | null;
+      meta?: Record<string, unknown> | null;
+      createdAt?: string;
+    }>;
+    updatedAt: number;
+  } | null;
+};
+type ModelCatalogEntry = {
+  provider: string;
+  id: string;
+  model: Record<string, unknown>;
+};
+type PromptTemplateCatalogEntry = {
+  name: string;
+  description: string;
+  argumentHint?: string;
+  category?: string;
+  scope: "platform";
+};
+type PromptTemplateCatalogResponse = {
+  prompts: PromptTemplateCatalogEntry[];
+};
+type Channel = {
+  id: string;
+  userUuid: string;
+  provider: string;
+  name: string;
+  status: string;
+  createdAt: string;
+  updatedAt: string;
+  boundSpace: {
+    id: string;
+    title: string | null;
+    status: string;
+  } | null;
+};
+type SpaceEnvInput = {
+  name: string;
+  value: string;
+};
+type SpaceChannelBindingInput = {
+  channelId: string;
+  config?: ChannelConfig | null;
+};
+type GlobalSearchType = "turn" | "session" | "space";
+type GlobalSearchResult = {
+  type: GlobalSearchType;
+  id: string;
+  spaceId: string;
+  sessionId: string | null;
+  turnId: string | null;
+  sequence: number | null;
+  title: string;
+  excerpt: string | null;
+  spaceName: string | null;
+  ownerProfile?: Pick<UserProfile, "userUuid" | "displayName" | "avatarUrl"> | null;
+  sessionTitle: string | null;
+  matchedField: "userText" | "title" | "name" | "description";
+  href: string;
+  score: number;
+  textScore: number;
+  recencyScore: number;
+  typePriorityScore: number;
+  membershipPriorityScore?: number;
+  updatedAt: string | null;
+  source: "remote";
+};
+type GlobalSearchResponse = {
+  items: GlobalSearchResult[];
+  query: string;
+  source: "remote";
+  degraded?: boolean;
+};
+type SpaceSessionsResponse = {
+  sessions: SessionRecord[];
+  forks?: Array<SessionForkRecord & {
+    firstUserTextAfterFork?: string | null;
+    parentTitle?: string | null;
+  }>;
+  pageInfo?: {
+    hasMore: boolean;
+    nextCursor: string | null;
+  };
+};
+type UserSshKey = {
+  id: string;
+  key: string;
+  title: string;
+  giteaKeyId: number;
+  createdAt: string;
+};
+type CreateSpacePromptInput = {
+  sessionId?: string | null;
+  title?: string | null;
+  content: ContentBlock[];
+  model?: string | null;
+  provider?: string | null;
+  clientMessageId?: string | null;
+  schedule?: {
+    mode?: "immediate";
+  } | {
+    mode: "delay";
+    delayMs: number;
+  } | {
+    mode: "at";
+    sendAt: string;
+  } | {
+    mode: "repeat";
+    cronExpression: string;
+    timezone: string;
+  };
+};
+type CreateSpacePromptResponse = {
+  ok: true;
+  mode: "immediate";
+  sessionId: string;
+  userMessageId: string;
+  turnId: string;
+} | {
+  ok: true;
+  mode: "delay" | "at";
+  taskRunId: string;
+  scheduledAt: string;
+  sessionId: string | null;
+} | {
+  ok: true;
+  mode: "repeat";
+  cronJobId: string;
+  nextRunAt: string;
+  timezone: string;
+  sessionId: string | null;
+};
+type CronJobRecord = {
+  id: string;
+  userUuid: string;
+  userProfile?: UserProfile;
+  title: string;
+  taskType: string;
+  payload: Record<string, unknown>;
+  cronExpression: string;
+  timezone: string;
+  bullJobKey: string;
+  spaceId: string | null;
+  sessionId: string | null;
+  enabled: boolean;
+  createdAt: string;
+  updatedAt: string;
+};
+type TaskRunDetailResponse = {
+  run: TaskRunRecord;
+  progress: unknown;
+};
+type TaskRunRecord = {
+  id: string;
+  jobId: string;
+  cronJobId: string | null;
+  taskType: string;
+  status: "pending" | "running" | "completed" | "failed";
+  payload: unknown;
+  result: unknown;
+  errorMessage: string | null;
+  attemptCount: number;
+  spaceId: string | null;
+  sessionId: string | null;
+  userUuid: string | null;
+  scheduledAt: string | null;
+  startedAt: string | null;
+  finishedAt: string | null;
+  createdAt: string;
+  updatedAt: string;
+};
+type CheckpointRecord = {
+  id: string;
+  spaceId: string;
+  commitHash: string;
+  description: string;
+  parentCheckpointId: string | null;
+  forkCount: number;
+  meta: Record<string, unknown> | null;
+  createdAt: string;
+};
+type SpaceCheckpointDetailResponse = {
+  checkpoint: CheckpointRecord;
+};
+type SpaceRole = "host" | "builder" | "guest";
+type SpaceMember = {
+  userId: string;
+  role: SpaceRole;
+  profile: UserProfile;
+  createdAt: string;
+  updatedAt: string;
+};
+type SpaceMarkKind = "pin";
+type SpaceMarkResourceType = "session" | "checkpoint" | "file";
+type SpaceMarkRecord = {
+  id: string;
+  spaceId: string;
+  kind: SpaceMarkKind;
+  resourceType: SpaceMarkResourceType;
+  resourceRef: string;
+  label: string | null;
+  rank: number;
+  createdBy: string;
+  createdAt: string;
+  updatedAt: string;
+};
+type SpaceMarkListItem = SpaceMarkRecord & {
+  href: string;
+  resource: {
+    title: string;
+    subtitle: string | null;
+    status: string | null;
+  } | null;
+};
+type ExploreSpaceItem = {
+  space: SpaceRecord;
+  accessAudience: "anonymous" | "signed_in";
+  explore: {
+    rank: number;
+    category: string | null;
+    label: string | null;
+  };
+  latestCheckpoints: CheckpointRecord[];
+  stats: {
+    pinnedCount: number;
+    checkpointCount: number;
+    forkCount: number;
+  };
+  sandboxStatus: string | null;
+};
+type SpaceAccessPolicy = {
+  signed_in_user: SpaceRole | null;
+  anonymous_user: SpaceRole | null;
+};
+type SpaceUsageHourlyStat = {
+  bucketStartAt: string;
+  totalTokens: number;
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens: number;
+  cacheWriteTokens: number;
+  costInput: number;
+  costOutput: number;
+  costCacheRead: number;
+  costCacheWrite: number;
+  costTotal: number;
+  requestCount: number;
+  successCount: number;
+  errorCount: number;
+  models: string[];
+};
+type SpaceUsageSummary = {
+  totalTokens: number;
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens: number;
+  cacheWriteTokens: number;
+  costInput: number;
+  costOutput: number;
+  costCacheRead: number;
+  costCacheWrite: number;
+  costTotal: number;
+  requestCount: number;
+  successCount: number;
+  errorCount: number;
+};
+type SpaceUsageResponse = {
+  hourly: SpaceUsageHourlyStat[];
+  summary: SpaceUsageSummary;
+  days: number;
+};
+type SpaceInvitation = {
+  token: string;
+  role: SpaceRole;
+  status: "active" | "revoked" | "exhausted";
+  useCount: number;
+  maxUses: number | null;
+  createdAt: string | null;
+  expiresInSeconds: number | null;
+};
+type CreateInvitationInput = {
+  role?: SpaceRole;
+  ttlSeconds?: number;
+  maxUses?: number;
+};
+type CreateInvitationResponse = {
+  token: string;
+  role: SpaceRole;
+  expiresAt: string;
+  maxUses: number | null;
+};
+type InvitationDetail = {
+  token: string;
+  spaceId: string;
+  spaceName: string;
+  role: SpaceRole;
+  expiresInSeconds: number | null;
+};
+type AcceptInvitationResponse = {
+  ok: true;
+  spaceId: string;
+  spaceName: string;
+  role: SpaceRole;
+};
+//#endregion
+//#region src/apis/channels.d.ts
+declare class ChannelsApi {
+  private readonly transport;
+  constructor(transport: HttpTransport);
+  list(customFetch?: Fetch): Promise<Channel[]>;
+  create(data: {
+    provider: string;
+    name: string;
+    credentials: Record<string, unknown>;
+  }): Promise<unknown>;
+  delete(id: string): Promise<unknown>;
+}
+//#endregion
+//#region src/apis/cron-jobs.d.ts
+declare class CronJobsApi {
+  private readonly transport;
+  constructor(transport: HttpTransport);
+  list(spaceId?: string): Promise<{
+    jobs: CronJobRecord[];
+  }>;
+  delete(id: string): Promise<{
+    ok: true;
+  }>;
+  toggle(id: string, enabled: boolean): Promise<{
+    ok: true;
+  }>;
+  runs(cronJobId: string): Promise<{
+    runs: TaskRunRecord[];
+  }>;
+}
+//#endregion
+//#region src/apis/generations.d.ts
+declare class GenerationsApi {
+  private readonly transport;
+  constructor(transport: HttpTransport);
+  create(request: CreateGenerationRequest): Promise<Generation>;
+}
+//#endregion
+//#region src/apis/models.d.ts
+type ModelsCatalog = Record<string, ModelCatalogEntry[]>;
+declare class ModelsApi {
+  private readonly transport;
+  constructor(transport: HttpTransport);
+  list(): Promise<ModelsCatalog>;
+  listMultimodal(): Promise<ListGenerationModelsResponse>;
+}
+//#endregion
+//#region src/apis/prompts.d.ts
+declare class PromptsApi {
+  private readonly transport;
+  constructor(transport: HttpTransport);
+  list(options?: {
+    spaceId?: string;
+  }, customFetch?: Fetch): Promise<PromptTemplateCatalogResponse>;
+}
+//#endregion
+//#region src/apis/search.d.ts
+declare class SearchApi {
+  private readonly transport;
+  constructor(transport: HttpTransport);
+  query(input: {
+    q: string;
+    limit?: number;
+    types?: GlobalSearchType[];
+    spaceId?: string;
+  }, customFetch?: Fetch): Promise<GlobalSearchResponse>;
+}
+//#endregion
+//#region src/apis/session-access.d.ts
+declare class SessionAccessApi {
+  private readonly transport;
+  constructor(transport: HttpTransport);
+  get(sessionId: string): Promise<SpaceAccessPolicy>;
+  set(sessionId: string, body: {
+    anonymous_user?: SpaceRole | null;
+  }): Promise<SpaceAccessPolicy>;
+  remove(sessionId: string): Promise<{
+    ok: true;
+  }>;
+}
+//#endregion
+//#region ../protocol/src/ports/index.d.ts
+type SpacePortStatus = "listening" | "closed";
+type SpacePublicEndpoint = {
+  url: string;
+  status?: SpacePortStatus | "unknown";
+  observedAt?: number;
+};
+type SpacePublicEndpoints = Record<string, SpacePublicEndpoint>;
+//#endregion
+//#region src/session-patch-reducer.d.ts
+type SessionPatchStatus = "idle" | "pending" | "streaming" | "completed" | "failed" | "interrupted";
+type SessionPatchState = {
+  spaceId: string | null;
+  sessionId: string;
+  status: SessionPatchStatus;
+  contentBlocks: ContentBlock[];
+  anchorUserMessageId: string | null;
+  patchSeq: number;
+  turnId: string | null;
+  appendPath: string | null;
+};
+type SessionPatchApplyInput = {
+  spaceId?: string | null;
+  sessionId: string;
+  turnId?: string | null;
+  seq: number;
+  baseSeq: number;
+  ops: RealtimePatchOperation[];
+  anchorUserMessageId?: string | null;
+};
+type SessionPatchApplyResult = {
+  applied: true;
+  state: SessionPatchState;
+} | {
+  applied: false;
+  reason: "duplicate" | "version_mismatch" | "invalid";
+  state: SessionPatchState;
+};
+type SessionPatchSnapshotInput = SessionPatchKeyInput & {
+  turnId?: string | null;
+  seq: number;
+  contentBlocks: ContentBlock[];
+  anchorUserMessageId?: string | null;
+  appendPath?: string | null;
+};
+type SessionPatchKeyInput = {
+  spaceId?: string | null;
+  sessionId: string;
+  turnId?: string | null;
+};
+declare class SessionPatchReducer {
+  private readonly states;
+  private key;
+  get(input: SessionPatchKeyInput): SessionPatchState;
+  start(input: SessionPatchKeyInput): SessionPatchState;
+  replaceTurnId(input: SessionPatchKeyInput & {
+    nextTurnId: string | null;
+  }): SessionPatchState;
+  complete(input: SessionPatchKeyInput): SessionPatchState;
+  fail(input: SessionPatchKeyInput): SessionPatchState;
+  interrupt(input: SessionPatchKeyInput): SessionPatchState;
+  reset(input: SessionPatchKeyInput): void;
+  applySnapshot(input: SessionPatchSnapshotInput): SessionPatchApplyResult;
+  resetAll(): void;
+  applyEvent(event: SessionTurnPatchEvent): SessionPatchApplyResult;
+  applyPatch(input: SessionPatchApplyInput): SessionPatchApplyResult;
+}
+declare const createSessionPatchReducer: () => SessionPatchReducer;
+//#endregion
+//#region src/session-generation-stream.d.ts
+type AssistantMessageCommit = {
+  kind: "intermediate";
+  message: MessageRecord;
+  isFinal: false;
+} | {
+  kind: "final";
+  message: MessageRecord;
+  isFinal: true;
+} | {
+  kind: "error";
+  message: MessageRecord;
+  isFinal: true;
+} | {
+  kind: "ignored";
+  message: MessageRecord;
+  isFinal: false;
+};
+type GenerationStreamIntermediateMessage = {
+  id?: string;
+  sessionId?: string;
+  role?: "user" | "assistant" | "system";
+  messageId: string | null;
+  messageOrdinal: number | null;
+  content: ContentBlock[];
+  text?: string | null;
+  provider?: string | null;
+  model?: string | null;
+  stopReason?: string | null;
+  errorMessage?: string | null;
+  usage?: Usage | null;
+  toolCallsObjectKey?: string | null;
+  meta?: Record<string, unknown> | null;
+  createdAt?: string;
+};
+type GenerationStreamStateEvent = {
+  type: "state";
+  source: "snapshot" | "patch" | "progress";
+  state: SessionPatchState;
+  messageId: string | null;
+  messageOrdinal: number | null;
+  intermediateMessages: GenerationStreamIntermediateMessage[];
+  rawEvent: WebsocketEventPayload;
+};
+type GenerationStreamCommitEvent = {
+  type: "commit";
+  commit: AssistantMessageCommit;
+  rawEvent: WebsocketEventPayload;
+};
+type GenerationStreamFinalizedEvent = {
+  type: "finalized";
+  turn: SessionTurnRecord;
+  rawEvent: WebsocketEventPayload;
+};
+type GenerationStreamTurnUpdatedEvent = {
+  type: "turn_updated";
+  turn: Partial<SessionTurnRecord>;
+  rawEvent: WebsocketEventPayload;
+};
+type GenerationStreamErrorEvent = {
+  type: "error";
+  message: string;
+  rawEvent: WebsocketEventPayload;
+};
+type GenerationStreamOutOfSyncEvent = {
+  type: "out_of_sync";
+  source: "snapshot" | "patch";
+  reason: "duplicate" | "version_mismatch" | "invalid";
+  state: SessionPatchState;
+  rawEvent: WebsocketEventPayload;
+};
+type GenerationStreamEvent = GenerationStreamStateEvent | GenerationStreamCommitEvent | GenerationStreamFinalizedEvent | GenerationStreamTurnUpdatedEvent | GenerationStreamErrorEvent | GenerationStreamOutOfSyncEvent;
+type GenerationStreamSubscriptionHandlers = {
+  event?: (event: GenerationStreamEvent) => void;
+  state?: (event: GenerationStreamStateEvent) => void;
+  commit?: (event: GenerationStreamCommitEvent) => void;
+  finalized?: (event: GenerationStreamFinalizedEvent) => void;
+  turnUpdated?: (event: GenerationStreamTurnUpdatedEvent) => void;
+  error?: (event: GenerationStreamErrorEvent) => void;
+  outOfSync?: (event: GenerationStreamOutOfSyncEvent) => void;
+};
+declare function parseAssistantMessageCommit(message: MessageRecord): AssistantMessageCommit;
+declare class SessionGenerationStreamClient {
+  private readonly websocketClient;
+  private readonly spaceId;
+  private readonly sessionId;
+  private readonly reducer;
+  private messageId;
+  private messageOrdinal;
+  private intermediateMessages;
+  private progressState;
+  constructor(websocketClient: WebsocketClient | null, spaceId: string, sessionId: string);
+  subscribe(handlers: GenerationStreamSubscriptionHandlers): () => void;
+  private emit;
+  private resetCurrentMessage;
+  private appendCurrentMessage;
+  private addIntermediateMessage;
+  private handleAppliedState;
+  private prepareMessageBoundary;
+  private handleSnapshot;
+  private handlePatch;
+  private handleProgress;
+  private handlePersisted;
+  private handleFinalized;
+  private handleEvent;
+}
+declare function createSessionGenerationStreamClient(input: {
+  websocketClient: WebsocketClient | null;
+  spaceId: string;
+  sessionId: string;
+}): SessionGenerationStreamClient;
+//#endregion
+//#region src/apis/invitations.d.ts
+declare class SpaceInvitationsApi {
+  private readonly transport;
+  private readonly spaceId;
+  constructor(transport: HttpTransport, spaceId: string);
+  list(): Promise<{
+    items: SpaceInvitation[];
+  }>;
+  create(input?: CreateInvitationInput): Promise<CreateInvitationResponse>;
+  revoke(token: string): Promise<{
+    ok: true;
+  }>;
+}
+declare class PublicInviteApi {
+  private readonly transport;
+  constructor(transport: HttpTransport);
+  get(token: string): Promise<InvitationDetail>;
+  accept(token: string): Promise<AcceptInvitationResponse>;
+}
+//#endregion
+//#region src/apis/spaces.d.ts
+type SessionSubscriptionHandlers = {
+  patch?: (event: WebsocketEventPayload) => void;
+  /**
+   * @deprecated Use `session.subscribeGeneration({ state })` for normalized
+   * snapshot/patch/progress generation state.
+   */
+  patchState?: (result: SessionPatchApplyResult) => void; /** @deprecated Use `session.subscribeGeneration({ state })`. */
+  snapshot?: (event: WebsocketEventPayload) => void; /** @deprecated Legacy progress events are normalized by `subscribeGeneration`. */
+  progress?: (event: WebsocketEventPayload) => void; /** @deprecated Use `session.subscribeGeneration({ commit, finalized })`. */
+  final?: (event: WebsocketEventPayload) => void;
+  turnUpdated?: (event: WebsocketEventPayload) => void;
+  turnFinalized?: (event: WebsocketEventPayload) => void;
+  error?: (event: WebsocketEventPayload) => void;
+  persisted?: (event: WebsocketEventPayload) => void;
+  event?: (event: WebsocketEventPayload) => void;
+};
+type SessionEventName = "turn.patch" | "turn.snapshot" | "turn.progress" | "turn.final" | "turn.updated" | "turn.error" | "message.persisted";
+type SpaceEventName = SessionEventName | "ports.changed" | "event";
+type SessionSendMessageInput = {
+  content: ContentBlock[];
+  model?: string;
+  provider?: string;
+  clientMessageId?: string;
+};
+declare class SpacesApi {
+  private readonly transport;
+  constructor(transport: HttpTransport);
+  list(customFetch?: Fetch): Promise<SpaceRecord[]>;
+  get(spaceId: string, customFetch?: Fetch): Promise<SpaceRecord>;
+  create(input?: {
+    name?: string;
+    description?: string;
+    source?: string;
+    extraEnv?: SpaceEnvInput[];
+    channelBindings?: SpaceChannelBindingInput[];
+    bootstrapSource?: SpaceBootstrapSource;
+  }, headers?: Record<string, string>): Promise<SpaceCreateResponse>;
+}
+declare class SpaceFilesApi {
+  private readonly transport;
+  private readonly spaceId;
+  constructor(transport: HttpTransport, spaceId: string);
+  list(path?: string, customFetch?: Fetch): Promise<SpaceFsTreeResponse>;
+  read(path: string, customFetch?: Fetch): Promise<SpaceFsFileResponse | SpaceFsPreparingFile>;
+  readMany(paths: string[], customFetch?: Fetch): Promise<SpaceFsReadFilesResponse>;
+  /**
+   * Build a direct download URL. For private files, prefer `download()` so the
+   * SDK can attach authorization headers.
+   */
+  getDownloadUrl(path: string): string;
+  download(path: string, customFetch?: Fetch): Promise<{
+    blob: Blob;
+    filename: string;
+    mimeType: string;
+  }>;
+  write(input: SpaceFsWriteFileInput): Promise<{
+    ok: true;
+    path: string;
+    size: number;
+    mtimeMs: number;
+  }>;
+  createDir(path: string): Promise<{
+    ok: true;
+    path: string;
+    size: number;
+    mtimeMs: number;
+  }>;
+  delete(path: string, recursive?: boolean): Promise<{
+    ok: true;
+    path: string;
+  }>;
+  move(input: SpaceFsMoveInput): Promise<{
+    ok: true;
+    fromPath: string;
+    toPath: string;
+  }>;
+  upload(files: File[], dir?: string): Promise<SpaceFsUploadResponse>;
+  createUpload(input: SpaceFsCreateUploadInput): Promise<SpaceFsCreateUploadResponse>;
+  completeUpload(uploadId: string, input: SpaceFsCompleteUploadInput): Promise<SpaceFsCompleteUploadResponse>;
+}
+declare class SessionMessagesClient {
+  private readonly transport;
+  private readonly sessionId;
+  private lastSentSignature;
+  private lastSentSessionId;
+  private lastSentAt;
+  constructor(transport: HttpTransport, sessionId: string);
+  list(customFetch?: Fetch): Promise<SessionMessagesResponse>;
+  get(messageId: string, optionsOrFetch?: {
+    detail?: "summary" | "full";
+  } | Fetch, customFetch?: Fetch): Promise<SessionMessageResponse>;
+  listPaginated(options?: {
+    cursor?: number;
+    limit?: number;
+    direction?: "older" | "newer";
+  }, customFetch?: Fetch): Promise<SessionMessagesPaginatedResponse>;
+  send(input: SessionSendMessageInput): Promise<{
+    ok: true;
+    userMessageId: string;
+    turnId: string;
+  }>;
+}
+declare class SessionTurnsClient {
+  private readonly transport;
+  private readonly sessionId;
+  constructor(transport: HttpTransport, sessionId: string);
+  listPaginated(options?: {
+    cursor?: number;
+    limit?: number;
+    direction?: "older" | "newer";
+  }, customFetch?: Fetch): Promise<SessionTurnsPaginatedResponse>;
+  index(options?: {
+    cursor?: number;
+    limit?: number;
+  }, customFetch?: Fetch): Promise<SessionTurnIndexResponse>;
+  window(options: {
+    sequence?: number;
+    turnId?: string;
+    before?: number;
+    after?: number;
+  }, customFetch?: Fetch): Promise<SessionTurnWindowResponse>;
+  streamSnapshot(customFetch?: Fetch): Promise<SessionTurnStreamSnapshotResponse>;
+  get(turnId: string, customFetch?: Fetch): Promise<SessionTurnResponse>;
+  signedUrls(turnId: string, objectKeys: string[]): Promise<SessionTurnSignedUrlsResponse>;
+}
+declare class SessionRealtimeClient {
+  private readonly websocketClient;
+  private readonly spaceId;
+  private readonly sessionId;
+  private readonly patchReducer;
+  constructor(websocketClient: WebsocketClient | null, spaceId: string, sessionId: string);
+  subscribe(handlers: SessionSubscriptionHandlers): () => void;
+  on(type: SessionEventName, handler: (event: WebsocketEventPayload) => void): () => void;
+}
+declare class SessionClient {
+  readonly spaceId: string;
+  readonly id: string;
+  private readonly transport;
+  readonly messages: SessionMessagesClient;
+  readonly turns: SessionTurnsClient;
+  readonly realtime: SessionRealtimeClient;
+  readonly generation: SessionGenerationStreamClient;
+  constructor(spaceId: string, id: string, transport: HttpTransport, websocketClient: WebsocketClient | null);
+  get(customFetch?: Fetch): Promise<{
+    space: SpaceRecord;
+    session: SessionRecord;
+  }>;
+  rename(title: string | null, customFetch?: Fetch): Promise<{
+    session: SessionRecord;
+  }>;
+  abort(optionsOrFetch?: {
+    turnId?: string | null;
+  } | Fetch, customFetch?: Fetch): Promise<{
+    ok: true;
+  }>;
+  turn(turnId: string): {
+    fork: (input?: {
+      title?: string | null;
+    }) => Promise<{
+      session: SessionRecord;
+      fork: SessionForkRecord;
+    }>;
+  };
+  subscribe(handlers: SessionSubscriptionHandlers): () => void;
+  subscribeGeneration(handlers: GenerationStreamSubscriptionHandlers): () => void;
+  on(type: SessionEventName, handler: (event: WebsocketEventPayload) => void): () => void;
+}
+declare class SpaceSessionsApi {
+  private readonly transport;
+  private readonly spaceId;
+  private readonly websocketClient;
+  constructor(transport: HttpTransport, spaceId: string, websocketClient: WebsocketClient | null);
+  create(input?: {
+    title?: string;
+    source?: string;
+  }): Promise<{
+    ok: true;
+    session: SessionRecord;
+  }>;
+  list(optionsOrFetch?: {
+    limit?: number;
+    cursor?: string | null;
+    includeForks?: boolean;
+  } | Fetch, customFetch?: Fetch): Promise<SpaceSessionsResponse>;
+  byId(sessionId: string): SessionClient;
+}
+type WebSocketConnectionState = {
+  state: "connecting" | "reconnecting" | "open" | "closed" | "error";
+  willReconnect: boolean;
+  connectionId?: string | null;
+  attempt?: number;
+  delayMs?: number;
+  recoverable?: boolean;
+};
+declare class SpaceMembersApi {
+  private readonly transport;
+  private readonly spaceId;
+  constructor(transport: HttpTransport, spaceId: string);
+  list(): Promise<{
+    items: SpaceMember[];
+  }>;
+  update(userId: string, role: SpaceRole): Promise<SpaceMember>;
+  remove(userId: string): Promise<{
+    ok: true;
+  }>;
+}
+declare class SpaceAccessApi {
+  private readonly transport;
+  private readonly spaceId;
+  constructor(transport: HttpTransport, spaceId: string);
+  get(): Promise<SpaceAccessPolicy>;
+  set(body: {
+    signed_in_user?: SpaceRole | null;
+    anonymous_user?: SpaceRole | null;
+  }): Promise<SpaceAccessPolicy>;
+}
+declare class SpaceUsageApi {
+  private readonly transport;
+  private readonly spaceId;
+  constructor(transport: HttpTransport, spaceId: string);
+  get(days?: number, customFetch?: Fetch): Promise<SpaceUsageResponse>;
+}
+type SpaceChannelBindingRecord = {
+  id: string;
+  spaceId: string;
+  channelId: string;
+  config: Record<string, unknown> | null;
+  createdAt: string;
+  channel: {
+    id: string;
+    userUuid: string;
+    provider: string;
+    name: string;
+    status: string;
+    createdAt: string;
+    updatedAt: string;
+  } | null;
+};
+declare class SpaceChannelsApi {
+  private readonly transport;
+  private readonly spaceId;
+  constructor(transport: HttpTransport, spaceId: string);
+  list(): Promise<SpaceChannelBindingRecord[]>;
+  bind(channelId: string, config?: Record<string, unknown> | null): Promise<SpaceChannelBindingRecord>;
+  unbind(channelId: string): Promise<{
+    ok: true;
+  }>;
+}
+declare class SpaceEnvApi {
+  private readonly transport;
+  private readonly spaceId;
+  constructor(transport: HttpTransport, spaceId: string);
+  list(): Promise<{
+    env: SpaceEnvInput[];
+  }>;
+  create(input: SpaceEnvInput): Promise<{
+    env: SpaceEnvInput[];
+  }>;
+  update(name: string, value: string): Promise<{
+    env: SpaceEnvInput[];
+  }>;
+  remove(name: string): Promise<{
+    env: SpaceEnvInput[];
+  }>;
+}
+type SpaceSandboxRecord = {
+  status: string | null;
+  podName?: string | null;
+  desiredImage?: string | null;
+  reportedImageVersion?: string | null;
+  lastHeartbeatAt?: string | null;
+  reportedAt?: string | null;
+  meta?: Record<string, unknown> | null;
+};
+declare class SpaceSandboxApi {
+  private readonly transport;
+  private readonly spaceId;
+  constructor(transport: HttpTransport, spaceId: string);
+  get(): Promise<{
+    sandbox: SpaceSandboxRecord | null;
+  }>;
+  ports(): Promise<{
+    endpoints: SpacePublicEndpoints;
+  }>;
+  recreate(): Promise<{
+    ok: boolean;
+    status?: string;
+    verified?: boolean;
+    checks?: Record<string, boolean> | null;
+    message?: string;
+  }>;
+}
+declare class SpaceMarksApi {
+  private readonly transport;
+  private readonly spaceId;
+  constructor(transport: HttpTransport, spaceId: string);
+  list(kind?: SpaceMarkKind): Promise<{
+    marks: SpaceMarkListItem[];
+  }>;
+  create(input: {
+    kind?: SpaceMarkKind;
+    resourceType: SpaceMarkResourceType;
+    resourceRef: string;
+    label?: string | null;
+  }): Promise<{
+    mark: SpaceMarkListItem;
+  }>;
+  delete(markId: string): Promise<{
+    ok: true;
+  }>;
+}
+declare class SpaceCheckpointsApi {
+  private readonly transport;
+  private readonly spaceId;
+  constructor(transport: HttpTransport, spaceId: string);
+  create(description?: string | null): Promise<{
+    ok: true;
+    taskRunId: string;
+  }>;
+  list(): Promise<{
+    checkpoints: CheckpointRecord[];
+  }>;
+  get(checkpointId: string, customFetch?: Fetch): Promise<SpaceCheckpointDetailResponse>;
+}
+declare class SpaceClient {
+  readonly id: string;
+  private readonly transport;
+  private readonly websocketClient;
+  readonly files: SpaceFilesApi;
+  readonly sessions: SpaceSessionsApi;
+  readonly members: SpaceMembersApi;
+  readonly access: SpaceAccessApi;
+  readonly checkpoints: SpaceCheckpointsApi;
+  readonly usage: SpaceUsageApi;
+  readonly channels: SpaceChannelsApi;
+  readonly env: SpaceEnvApi;
+  readonly sandbox: SpaceSandboxApi;
+  readonly invitations: SpaceInvitationsApi;
+  readonly marks: SpaceMarksApi;
+  constructor(id: string, transport: HttpTransport, websocketClient: WebsocketClient | null);
+  get(customFetch?: Fetch): Promise<SpaceRecord>;
+  prompt(input: CreateSpacePromptInput): Promise<CreateSpacePromptResponse>;
+  rename(name: string): Promise<{
+    space: SpaceRecord;
+  }>;
+  profile(body: {
+    description?: string | null;
+    pictureUrl?: string | null;
+  }): Promise<{
+    space: SpaceRecord;
+  }>;
+  session(sessionId: string): SessionClient;
+  subscribe(handler: (event: WebsocketEventPayload) => void): () => void;
+  on(type: SpaceEventName, handler: (event: WebsocketEventPayload) => void): () => void;
+}
+//#endregion
+//#region src/apis/tasks.d.ts
+declare class TasksApi {
+  private readonly transport;
+  constructor(transport: HttpTransport);
+  get(taskRunId: string): Promise<TaskRunDetailResponse>;
+  list(filters?: {
+    cronJobId?: string;
+    spaceId?: string;
+  }): Promise<{
+    runs: TaskRunRecord[];
+  }>;
+}
+//#endregion
+//#region src/apis/user.d.ts
+declare class UserApi {
+  private readonly transport;
+  private readonly transportBaseUrl;
+  private readonly setStoredAuthToken?;
+  private readonly clearStoredAuthToken?;
+  constructor(transport: HttpTransport, transportBaseUrl: string, setStoredAuthToken?: ((token: string) => void) | undefined, clearStoredAuthToken?: (() => void) | undefined);
+  getMe(customFetch?: Fetch): Promise<MeResponse>;
+  updateProfile(input: {
+    displayName?: string;
+    avatarUrl?: string | null;
+  }): Promise<{
+    profile: UserProfile;
+  }>;
+  getRules(customFetch?: Fetch): Promise<UserRulesResponse>;
+  setAuthToken(token: string): Promise<any>;
+  clearAuthToken(): Promise<null>;
+  getSshKeys(customFetch?: Fetch): Promise<UserSshKey[]>;
+  createSshKey(data: {
+    key: string;
+    title: string;
+  }): Promise<UserSshKey>;
+  deleteSshKey(id: string): Promise<{
+    ok: true;
+  }>;
+}
+//#endregion
+//#region src/http.d.ts
+declare class CohubHttpClient {
+  readonly spaces: SpacesApi;
+  readonly channels: ChannelsApi;
+  readonly user: UserApi;
+  readonly generations: GenerationsApi;
+  readonly models: ModelsApi;
+  readonly prompts: PromptsApi;
+  readonly sessionAccess: SessionAccessApi;
+  readonly search: SearchApi;
+  readonly tasks: TasksApi;
+  readonly cronJobs: CronJobsApi;
+  readonly invite: PublicInviteApi;
+  private readonly transport;
+  constructor(options?: CohubClientOptions);
+  space(spaceId: string): SpaceClient;
+}
+declare const createHttpClient: (options?: CohubClientOptions) => CohubHttpClient;
+//#endregion
+export { MeResponse as $, SpaceUsageResponse as $t, SessionPatchStatus as A, SpaceFsReadFilesError as At, ApiError as B, SpaceFsWriteFileInput as Bt, SessionGenerationStreamClient as C, SpaceFsCreateUploadResponse as Ct, SessionPatchApplyResult as D, SpaceFsFileResponse as Dt, SessionPatchApplyInput as E, SpaceFsFileKind as Et, ModelsApi as F, SpaceFsUploadError as Ft, CreateSpacePromptInput as G, SpaceMarkListItem as Gt, CheckpointRecord as H, SpaceInvitation as Ht, GenerationsApi as I, SpaceFsUploadPlanEntry as It, ExploreSpaceItem as J, SpaceMember as Jt, CreateSpacePromptResponse as K, SpaceMarkRecord as Kt, CronJobsApi as L, SpaceFsUploadPlanEntryInput as Lt, SessionAccessApi as M, SpaceFsReadFilesResponse as Mt, SearchApi as N, SpaceFsTreeResponse as Nt, SessionPatchReducer as O, SpaceFsMoveInput as Ot, PromptsApi as P, SpaceFsUploadEntry as Pt, InvitationDetail as Q, SpaceUsageHourlyStat as Qt, ChannelsApi as R, SpaceFsUploadProgress as Rt, GenerationStreamTurnUpdatedEvent as S, SpaceFsCreateUploadInput as St, parseAssistantMessageCommit as T, SpaceFsEntry as Tt, CreateInvitationInput as U, SpaceListItem as Ut, Channel as V, SpaceGitInfo as Vt, CreateInvitationResponse as W, SpaceMarkKind as Wt, GlobalSearchResult as X, SpaceRole as Xt, GlobalSearchResponse as Y, SpaceRecord as Yt, GlobalSearchType as Z, SpaceSessionsResponse as Zt, GenerationStreamFinalizedEvent as _, CohubClientOptions as _n, SpaceCheckpointDetailResponse as _t, SessionEventName as a, UserSshKey as an, SessionMessagesPaginatedResponse as at, GenerationStreamStateEvent as b, HttpTransport as bn, SpaceFsCompleteUploadInput as bt, SpaceClient as c, ListGenerationModelsResponse as cn, SessionTurnIndexResponse as ct, WebSocketConnectionState as d, DiscordChannelConfig as dn, SessionTurnStreamSnapshotResponse as dt, SpaceUsageSummary as en, ModelCatalogEntry as et, PublicInviteApi as f, MessageRecord as fn, SessionTurnWindowResponse as ft, GenerationStreamEvent as g, SessionTurnRecord as gn, SpaceChannelBindingInput as gt, GenerationStreamErrorEvent as h, SessionTurnIndexItem as hn, SpaceBootstrapSource as ht, TasksApi as i, UserRulesResponse as in, SessionMessageResponse as it, createSessionPatchReducer as j, SpaceFsReadFilesInput as jt, SessionPatchState as k, SpaceFsPreparingFile as kt, SpaceEventName as l, PublicGenerationDeclaration as ln, SessionTurnResponse as lt, GenerationStreamCommitEvent as m, SessionTurnSegmentRecord as mn, SpaceAccessPolicy as mt, createHttpClient as n, TaskRunRecord as nn, PromptTemplateCatalogResponse as nt, SessionSubscriptionHandlers as o, CreateGenerationRequest as on, SessionMessagesResponse as ot, AssistantMessageCommit as p, SessionForkRecord as pn, SessionTurnsPaginatedResponse as pt, CronJobRecord as q, SpaceMarkResourceType as qt, UserApi as r, UserProfile as rn, SessionBindingRecord as rt, SpaceChannelBindingRecord as s, Generation as sn, SessionRecord as st, CohubHttpClient as t, TaskRunDetailResponse as tn, PromptTemplateCatalogEntry as tt, SpacesApi as u, ChannelConfig as un, SessionTurnSignedUrlsResponse as ut, GenerationStreamIntermediateMessage as v, Fetch as vn, SpaceCreateResponse as vt, createSessionGenerationStreamClient as w, SpaceFsEncoding as wt, GenerationStreamSubscriptionHandlers as x, RawHttpResponse as xn, SpaceFsCompleteUploadResponse as xt, GenerationStreamOutOfSyncEvent as y, HttpError as yn, SpaceEnvInput as yt, AcceptInvitationResponse as z, SpaceFsUploadResponse as zt };