export type InvalidAPIKey = {
  message?: string;
};

export type ChatRequest = {
  messages?: Array<{
  role?: string;
  content?: string;
}>;
  model?: string;
  temperature?: number;
  max_tokens?: number;
};

export type ApproveChannelPairingCodeParams = {
  code: string;
};
export type ApproveChannelPairingCodeQuery = Record<string, never>;
export type ApproveChannelPairingCodeHeaders = {
  "x-app-id"?: string;
};
export type ApproveChannelPairingCodeBody = unknown;
export type ApproveChannelPairingCodeResponse = Record<string, unknown>;
export interface ApproveChannelPairingCodeOptions extends RealtimeXRequestOptions {
  params?: ApproveChannelPairingCodeParams;
  query?: ApproveChannelPairingCodeQuery;
  headers?: ApproveChannelPairingCodeHeaders & Record<string, string>;
  body?: ApproveChannelPairingCodeBody;
}

export type ChatWithTerminalAgentParams = Record<string, never>;
export type ChatWithTerminalAgentQuery = Record<string, never>;
export type ChatWithTerminalAgentHeaders = Record<string, never>;
export type ChatWithTerminalAgentBody = {
  workspaceName?: string;
  threadName?: string;
  agentName?: string;
  agentSearch?: string;
  modelName?: string;
  skipModelSelection?: boolean;
  messageText?: string;
  messageConfirmation?: string;
  workspaceTimeoutMs?: number;
  threadTimeoutMs?: number;
  actionTimeoutMs?: number;
  actionDelayMs?: number;
  recordVideo?: boolean;
  videoPath?: string;
  logProgress?: boolean;
  tour?: boolean;
  tourId?: string;
  tourTts?: string;
  tourLang?: string;
  tourTtsVoice?: string;
  tourSurface?: string;
  tourTtsMaxWaitMs?: number;
  timeoutMs?: number;
  confirmDestructive?: boolean;
};
export type ChatWithTerminalAgentResponse = Record<string, unknown>;
export interface ChatWithTerminalAgentOptions extends RealtimeXRequestOptions {
  params?: ChatWithTerminalAgentParams;
  query?: ChatWithTerminalAgentQuery;
  headers?: ChatWithTerminalAgentHeaders & Record<string, string>;
  body?: ChatWithTerminalAgentBody;
}

export type ClearWorkspaceDefaultAgentParams = {
  workspaceSlug: string;
};
export type ClearWorkspaceDefaultAgentQuery = Record<string, never>;
export type ClearWorkspaceDefaultAgentHeaders = {
  authorization?: string;
  "x-app-id"?: string;
};
export type ClearWorkspaceDefaultAgentBody = unknown;
export type ClearWorkspaceDefaultAgentResponse = Record<string, unknown>;
export interface ClearWorkspaceDefaultAgentOptions extends RealtimeXRequestOptions {
  params?: ClearWorkspaceDefaultAgentParams;
  query?: ClearWorkspaceDefaultAgentQuery;
  headers?: ClearWorkspaceDefaultAgentHeaders & Record<string, string>;
  body?: ClearWorkspaceDefaultAgentBody;
}

export type CreateChannelParams = {
  workspaceSlug: string;
};
export type CreateChannelQuery = Record<string, never>;
export type CreateChannelHeaders = {
  "x-app-id"?: string;
};
export type CreateChannelBody = {
  name?: string;
  plugin_type?: "telegram" | "discord" | "zalo";
  channelType?: "telegram" | "discord" | "zalo";
  type?: "telegram" | "discord" | "zalo";
  botToken?: string;
  thread_id?: number;
  threadId?: number;
  autoStart?: boolean;
  autostart?: boolean;
  start?: boolean;
  enabled?: boolean;
  config?: Record<string, unknown>;
  settings?: Record<string, unknown>;
};
export type CreateChannelResponse = Record<string, unknown>;
export interface CreateChannelOptions extends RealtimeXRequestOptions {
  params?: CreateChannelParams;
  query?: CreateChannelQuery;
  headers?: CreateChannelHeaders & Record<string, string>;
  body?: CreateChannelBody;
}

export type CreateThreadParams = {
  workspaceSlug: string;
};
export type CreateThreadQuery = Record<string, never>;
export type CreateThreadHeaders = {
  "x-app-id"?: string;
};
export type CreateThreadBody = {
  name?: string;
};
export type CreateThreadResponse = Record<string, unknown>;
export interface CreateThreadOptions extends RealtimeXRequestOptions {
  params?: CreateThreadParams;
  query?: CreateThreadQuery;
  headers?: CreateThreadHeaders & Record<string, string>;
  body?: CreateThreadBody;
}

export type CreateWorkspaceParams = Record<string, never>;
export type CreateWorkspaceQuery = Record<string, never>;
export type CreateWorkspaceHeaders = {
  authorization?: string;
  "x-app-id"?: string;
};
export type CreateWorkspaceBody = {
  name: string;
};
export type CreateWorkspaceResponse = Record<string, unknown>;
export interface CreateWorkspaceOptions extends RealtimeXRequestOptions {
  params?: CreateWorkspaceParams;
  query?: CreateWorkspaceQuery;
  headers?: CreateWorkspaceHeaders & Record<string, string>;
  body?: CreateWorkspaceBody;
}

export type CreateWorkspaceAgentSkillParams = {
  workspaceSlug: string;
};
export type CreateWorkspaceAgentSkillQuery = Record<string, never>;
export type CreateWorkspaceAgentSkillHeaders = {
  "x-app-id"?: string;
};
export type CreateWorkspaceAgentSkillBody = {
  displayName: string;
  name?: string;
  description?: string;
};
export type CreateWorkspaceAgentSkillResponse = Record<string, unknown>;
export interface CreateWorkspaceAgentSkillOptions extends RealtimeXRequestOptions {
  params?: CreateWorkspaceAgentSkillParams;
  query?: CreateWorkspaceAgentSkillQuery;
  headers?: CreateWorkspaceAgentSkillHeaders & Record<string, string>;
  body?: CreateWorkspaceAgentSkillBody;
}

export type DeleteChannelParams = {
  channelId: string;
};
export type DeleteChannelQuery = Record<string, never>;
export type DeleteChannelHeaders = {
  "x-app-id"?: string;
};
export type DeleteChannelBody = unknown;
export type DeleteChannelResponse = Record<string, unknown>;
export interface DeleteChannelOptions extends RealtimeXRequestOptions {
  params?: DeleteChannelParams;
  query?: DeleteChannelQuery;
  headers?: DeleteChannelHeaders & Record<string, string>;
  body?: DeleteChannelBody;
}

export type DeleteThreadParams = {
  workspaceSlug: string;
  threadSlug: string;
};
export type DeleteThreadQuery = Record<string, never>;
export type DeleteThreadHeaders = {
  "x-app-id"?: string;
};
export type DeleteThreadBody = unknown;
export type DeleteThreadResponse = Record<string, unknown>;
export interface DeleteThreadOptions extends RealtimeXRequestOptions {
  params?: DeleteThreadParams;
  query?: DeleteThreadQuery;
  headers?: DeleteThreadHeaders & Record<string, string>;
  body?: DeleteThreadBody;
}

export type DeleteWorkspaceParams = {
  workspaceSlug: string;
};
export type DeleteWorkspaceQuery = Record<string, never>;
export type DeleteWorkspaceHeaders = {
  "x-app-id"?: string;
};
export type DeleteWorkspaceBody = unknown;
export type DeleteWorkspaceResponse = Record<string, unknown>;
export interface DeleteWorkspaceOptions extends RealtimeXRequestOptions {
  params?: DeleteWorkspaceParams;
  query?: DeleteWorkspaceQuery;
  headers?: DeleteWorkspaceHeaders & Record<string, string>;
  body?: DeleteWorkspaceBody;
}

export type DisablePluginParams = {
  pluginId: string;
};
export type DisablePluginQuery = Record<string, never>;
export type DisablePluginHeaders = {
  "x-app-id"?: string;
};
export type DisablePluginBody = unknown;
export type DisablePluginResponse = Record<string, unknown>;
export interface DisablePluginOptions extends RealtimeXRequestOptions {
  params?: DisablePluginParams;
  query?: DisablePluginQuery;
  headers?: DisablePluginHeaders & Record<string, string>;
  body?: DisablePluginBody;
}

export type DisableWorkspaceAgentSkillParams = {
  workspaceSlug: string;
  skillId: string;
};
export type DisableWorkspaceAgentSkillQuery = Record<string, never>;
export type DisableWorkspaceAgentSkillHeaders = {
  authorization?: string;
  "x-app-id"?: string;
};
export type DisableWorkspaceAgentSkillBody = unknown;
export type DisableWorkspaceAgentSkillResponse = Record<string, unknown>;
export interface DisableWorkspaceAgentSkillOptions extends RealtimeXRequestOptions {
  params?: DisableWorkspaceAgentSkillParams;
  query?: DisableWorkspaceAgentSkillQuery;
  headers?: DisableWorkspaceAgentSkillHeaders & Record<string, string>;
  body?: DisableWorkspaceAgentSkillBody;
}

export type EnablePluginParams = {
  pluginId: string;
};
export type EnablePluginQuery = Record<string, never>;
export type EnablePluginHeaders = {
  "x-app-id"?: string;
};
export type EnablePluginBody = unknown;
export type EnablePluginResponse = Record<string, unknown>;
export interface EnablePluginOptions extends RealtimeXRequestOptions {
  params?: EnablePluginParams;
  query?: EnablePluginQuery;
  headers?: EnablePluginHeaders & Record<string, string>;
  body?: EnablePluginBody;
}

export type EnableWorkspaceAgentSkillParams = {
  workspaceSlug: string;
  skillId: string;
};
export type EnableWorkspaceAgentSkillQuery = Record<string, never>;
export type EnableWorkspaceAgentSkillHeaders = {
  authorization?: string;
  "x-app-id"?: string;
};
export type EnableWorkspaceAgentSkillBody = unknown;
export type EnableWorkspaceAgentSkillResponse = Record<string, unknown>;
export interface EnableWorkspaceAgentSkillOptions extends RealtimeXRequestOptions {
  params?: EnableWorkspaceAgentSkillParams;
  query?: EnableWorkspaceAgentSkillQuery;
  headers?: EnableWorkspaceAgentSkillHeaders & Record<string, string>;
  body?: EnableWorkspaceAgentSkillBody;
}

export type GetArtifactParams = {
  artifactId: string;
};
export type GetArtifactQuery = Record<string, never>;
export type GetArtifactHeaders = {
  "x-app-id"?: string;
};
export type GetArtifactBody = unknown;
export type GetArtifactResponse = unknown;
export interface GetArtifactOptions extends RealtimeXRequestOptions {
  params?: GetArtifactParams;
  query?: GetArtifactQuery;
  headers?: GetArtifactHeaders & Record<string, string>;
  body?: GetArtifactBody;
}

export type GetThreadParams = {
  workspaceSlug: string;
  threadSlug: string;
};
export type GetThreadQuery = Record<string, never>;
export type GetThreadHeaders = {
  "x-app-id"?: string;
};
export type GetThreadBody = unknown;
export type GetThreadResponse = Record<string, unknown>;
export interface GetThreadOptions extends RealtimeXRequestOptions {
  params?: GetThreadParams;
  query?: GetThreadQuery;
  headers?: GetThreadHeaders & Record<string, string>;
  body?: GetThreadBody;
}

export type GetWorkspaceParams = {
  workspaceSlug: string;
};
export type GetWorkspaceQuery = Record<string, never>;
export type GetWorkspaceHeaders = {
  "x-app-id"?: string;
};
export type GetWorkspaceBody = unknown;
export type GetWorkspaceResponse = Record<string, unknown>;
export interface GetWorkspaceOptions extends RealtimeXRequestOptions {
  params?: GetWorkspaceParams;
  query?: GetWorkspaceQuery;
  headers?: GetWorkspaceHeaders & Record<string, string>;
  body?: GetWorkspaceBody;
}

export type ListAgentSkillsParams = Record<string, never>;
export type ListAgentSkillsQuery = Record<string, never>;
export type ListAgentSkillsHeaders = {
  "x-app-id"?: string;
};
export type ListAgentSkillsBody = unknown;
export type ListAgentSkillsResponse = Record<string, unknown>;
export interface ListAgentSkillsOptions extends RealtimeXRequestOptions {
  params?: ListAgentSkillsParams;
  query?: ListAgentSkillsQuery;
  headers?: ListAgentSkillsHeaders & Record<string, string>;
  body?: ListAgentSkillsBody;
}

export type ListArtifactsParams = {
  workspaceSlug: string;
};
export type ListArtifactsQuery = Record<string, never>;
export type ListArtifactsHeaders = {
  "x-app-id"?: string;
};
export type ListArtifactsBody = unknown;
export type ListArtifactsResponse = unknown;
export interface ListArtifactsOptions extends RealtimeXRequestOptions {
  params?: ListArtifactsParams;
  query?: ListArtifactsQuery;
  headers?: ListArtifactsHeaders & Record<string, string>;
  body?: ListArtifactsBody;
}

export type ListChannelsParams = Record<string, never>;
export type ListChannelsQuery = Record<string, never>;
export type ListChannelsHeaders = {
  "x-app-id"?: string;
};
export type ListChannelsBody = unknown;
export type ListChannelsResponse = Record<string, unknown>;
export interface ListChannelsOptions extends RealtimeXRequestOptions {
  params?: ListChannelsParams;
  query?: ListChannelsQuery;
  headers?: ListChannelsHeaders & Record<string, string>;
  body?: ListChannelsBody;
}

export type ListLlmModelsParams = {
  provider: string;
};
export type ListLlmModelsQuery = Record<string, never>;
export type ListLlmModelsHeaders = {
  "x-app-id"?: string;
};
export type ListLlmModelsBody = unknown;
export type ListLlmModelsResponse = Record<string, unknown>;
export interface ListLlmModelsOptions extends RealtimeXRequestOptions {
  params?: ListLlmModelsParams;
  query?: ListLlmModelsQuery;
  headers?: ListLlmModelsHeaders & Record<string, string>;
  body?: ListLlmModelsBody;
}

export type ListLlmProvidersParams = Record<string, never>;
export type ListLlmProvidersQuery = Record<string, never>;
export type ListLlmProvidersHeaders = {
  "x-app-id"?: string;
};
export type ListLlmProvidersBody = unknown;
export type ListLlmProvidersResponse = Record<string, unknown>;
export interface ListLlmProvidersOptions extends RealtimeXRequestOptions {
  params?: ListLlmProvidersParams;
  query?: ListLlmProvidersQuery;
  headers?: ListLlmProvidersHeaders & Record<string, string>;
  body?: ListLlmProvidersBody;
}

export type ListPluginsParams = Record<string, never>;
export type ListPluginsQuery = Record<string, never>;
export type ListPluginsHeaders = {
  "x-app-id"?: string;
};
export type ListPluginsBody = unknown;
export type ListPluginsResponse = Record<string, unknown>;
export interface ListPluginsOptions extends RealtimeXRequestOptions {
  params?: ListPluginsParams;
  query?: ListPluginsQuery;
  headers?: ListPluginsHeaders & Record<string, string>;
  body?: ListPluginsBody;
}

export type ListTerminalAgentsParams = Record<string, never>;
export type ListTerminalAgentsQuery = Record<string, never>;
export type ListTerminalAgentsHeaders = {
  "x-app-id"?: string;
};
export type ListTerminalAgentsBody = unknown;
export type ListTerminalAgentsResponse = unknown;
export interface ListTerminalAgentsOptions extends RealtimeXRequestOptions {
  params?: ListTerminalAgentsParams;
  query?: ListTerminalAgentsQuery;
  headers?: ListTerminalAgentsHeaders & Record<string, string>;
  body?: ListTerminalAgentsBody;
}

export type ListTerminalSessionsParams = Record<string, never>;
export type ListTerminalSessionsQuery = {
  workspaceSlug?: string;
  threadSlug?: string;
  includeClosed?: boolean;
  limit?: number;
};
export type ListTerminalSessionsHeaders = {
  "x-app-id"?: string;
};
export type ListTerminalSessionsBody = unknown;
export type ListTerminalSessionsResponse = unknown;
export interface ListTerminalSessionsOptions extends RealtimeXRequestOptions {
  params?: ListTerminalSessionsParams;
  query?: ListTerminalSessionsQuery;
  headers?: ListTerminalSessionsHeaders & Record<string, string>;
  body?: ListTerminalSessionsBody;
}

export type ListThreadsParams = {
  workspaceSlug: string;
};
export type ListThreadsQuery = Record<string, never>;
export type ListThreadsHeaders = {
  "x-app-id"?: string;
};
export type ListThreadsBody = unknown;
export type ListThreadsResponse = unknown;
export interface ListThreadsOptions extends RealtimeXRequestOptions {
  params?: ListThreadsParams;
  query?: ListThreadsQuery;
  headers?: ListThreadsHeaders & Record<string, string>;
  body?: ListThreadsBody;
}

export type ListWorkspaceAgentSkillsParams = {
  workspaceSlug: string;
};
export type ListWorkspaceAgentSkillsQuery = Record<string, never>;
export type ListWorkspaceAgentSkillsHeaders = {
  authorization?: string;
  "x-app-id"?: string;
};
export type ListWorkspaceAgentSkillsBody = unknown;
export type ListWorkspaceAgentSkillsResponse = Record<string, unknown>;
export interface ListWorkspaceAgentSkillsOptions extends RealtimeXRequestOptions {
  params?: ListWorkspaceAgentSkillsParams;
  query?: ListWorkspaceAgentSkillsQuery;
  headers?: ListWorkspaceAgentSkillsHeaders & Record<string, string>;
  body?: ListWorkspaceAgentSkillsBody;
}

export type ListWorkspacesParams = Record<string, never>;
export type ListWorkspacesQuery = Record<string, never>;
export type ListWorkspacesHeaders = {
  "x-app-id"?: string;
};
export type ListWorkspacesBody = unknown;
export type ListWorkspacesResponse = unknown;
export interface ListWorkspacesOptions extends RealtimeXRequestOptions {
  params?: ListWorkspacesParams;
  query?: ListWorkspacesQuery;
  headers?: ListWorkspacesHeaders & Record<string, string>;
  body?: ListWorkspacesBody;
}

export type OpenTerminalSessionParams = Record<string, never>;
export type OpenTerminalSessionQuery = Record<string, never>;
export type OpenTerminalSessionHeaders = {
  "x-app-id"?: string;
};
export type OpenTerminalSessionBody = {
  agentName: string;
  workspaceSlug?: string;
  threadSlug?: string;
  providerId?: string;
  modelId?: string;
  message?: string;
  firstTurnDelivery?: "queued" | "launch-args";
  requestedBy?: string;
};
export type OpenTerminalSessionResponse = Record<string, unknown>;
export interface OpenTerminalSessionOptions extends RealtimeXRequestOptions {
  params?: OpenTerminalSessionParams;
  query?: OpenTerminalSessionQuery;
  headers?: OpenTerminalSessionHeaders & Record<string, string>;
  body?: OpenTerminalSessionBody;
}

export type PauseArtifactParams = {
  artifactId: string;
};
export type PauseArtifactQuery = Record<string, never>;
export type PauseArtifactHeaders = {
  "x-app-id"?: string;
};
export type PauseArtifactBody = unknown;
export type PauseArtifactResponse = unknown;
export interface PauseArtifactOptions extends RealtimeXRequestOptions {
  params?: PauseArtifactParams;
  query?: PauseArtifactQuery;
  headers?: PauseArtifactHeaders & Record<string, string>;
  body?: PauseArtifactBody;
}

export type PrepareParams = Record<string, never>;
export type PrepareQuery = {
  workspaceSlug?: string;
  threadSlug?: string;
};
export type PrepareHeaders = {
  "x-app-id"?: string;
};
export type PrepareBody = unknown;
export type PrepareResponse = {
  currentWorkspace?: {
  id?: number;
  slug?: string;
  name?: string;
  missing?: boolean;
};
  currentThread?: {
  id?: number;
  slug?: string;
  name?: string;
  workspaceId?: number;
  workspaceSlug?: string;
  missing?: boolean;
};
  workspaces?: Array<{
  id?: number;
  slug?: string;
  name?: string;
}>;
  threads?: Array<{
  id?: number;
  slug?: string;
  name?: string;
  workspaceId?: number;
  workspaceSlug?: string;
}>;
  providers?: Array<unknown>;
  models?: Array<unknown>;
  agents?: Array<unknown>;
};
export interface PrepareOptions extends RealtimeXRequestOptions {
  params?: PrepareParams;
  query?: PrepareQuery;
  headers?: PrepareHeaders & Record<string, string>;
  body?: PrepareBody;
}

export type PromoteWorkspaceAgentSkillParams = {
  workspaceSlug: string;
  skillId: string;
};
export type PromoteWorkspaceAgentSkillQuery = Record<string, never>;
export type PromoteWorkspaceAgentSkillHeaders = {
  "x-app-id"?: string;
};
export type PromoteWorkspaceAgentSkillBody = {
  displayName?: string;
  name?: string;
  description?: string;
};
export type PromoteWorkspaceAgentSkillResponse = Record<string, unknown>;
export interface PromoteWorkspaceAgentSkillOptions extends RealtimeXRequestOptions {
  params?: PromoteWorkspaceAgentSkillParams;
  query?: PromoteWorkspaceAgentSkillQuery;
  headers?: PromoteWorkspaceAgentSkillHeaders & Record<string, string>;
  body?: PromoteWorkspaceAgentSkillBody;
}

export type PublishArtifactParams = {
  workspaceSlug: string;
};
export type PublishArtifactQuery = Record<string, never>;
export type PublishArtifactHeaders = {
  "x-app-id"?: string;
};
export type PublishArtifactBody = {
  artifactPath: string;
  entryFile?: string;
  expiresAt?: string;
};
export type PublishArtifactResponse = unknown;
export interface PublishArtifactOptions extends RealtimeXRequestOptions {
  params?: PublishArtifactParams;
  query?: PublishArtifactQuery;
  headers?: PublishArtifactHeaders & Record<string, string>;
  body?: PublishArtifactBody;
}

export type ReloadAgentSkillsParams = Record<string, never>;
export type ReloadAgentSkillsQuery = Record<string, never>;
export type ReloadAgentSkillsHeaders = {
  "x-app-id"?: string;
};
export type ReloadAgentSkillsBody = {
  workspaceSlug?: string;
};
export type ReloadAgentSkillsResponse = Record<string, unknown>;
export interface ReloadAgentSkillsOptions extends RealtimeXRequestOptions {
  params?: ReloadAgentSkillsParams;
  query?: ReloadAgentSkillsQuery;
  headers?: ReloadAgentSkillsHeaders & Record<string, string>;
  body?: ReloadAgentSkillsBody;
}

export type ReloadPluginParams = {
  pluginId: string;
};
export type ReloadPluginQuery = Record<string, never>;
export type ReloadPluginHeaders = {
  "x-app-id"?: string;
};
export type ReloadPluginBody = unknown;
export type ReloadPluginResponse = Record<string, unknown>;
export interface ReloadPluginOptions extends RealtimeXRequestOptions {
  params?: ReloadPluginParams;
  query?: ReloadPluginQuery;
  headers?: ReloadPluginHeaders & Record<string, string>;
  body?: ReloadPluginBody;
}

export type RenameThreadParams = {
  workspaceSlug: string;
  threadSlug: string;
};
export type RenameThreadQuery = Record<string, never>;
export type RenameThreadHeaders = {
  "x-app-id"?: string;
};
export type RenameThreadBody = {
  name: string;
};
export type RenameThreadResponse = Record<string, unknown>;
export interface RenameThreadOptions extends RealtimeXRequestOptions {
  params?: RenameThreadParams;
  query?: RenameThreadQuery;
  headers?: RenameThreadHeaders & Record<string, string>;
  body?: RenameThreadBody;
}

export type RenameWorkspaceParams = {
  workspaceSlug: string;
};
export type RenameWorkspaceQuery = Record<string, never>;
export type RenameWorkspaceHeaders = {
  "x-app-id"?: string;
};
export type RenameWorkspaceBody = {
  name: string;
};
export type RenameWorkspaceResponse = Record<string, unknown>;
export interface RenameWorkspaceOptions extends RealtimeXRequestOptions {
  params?: RenameWorkspaceParams;
  query?: RenameWorkspaceQuery;
  headers?: RenameWorkspaceHeaders & Record<string, string>;
  body?: RenameWorkspaceBody;
}

export type ResumeArtifactParams = {
  artifactId: string;
};
export type ResumeArtifactQuery = Record<string, never>;
export type ResumeArtifactHeaders = {
  "x-app-id"?: string;
};
export type ResumeArtifactBody = unknown;
export type ResumeArtifactResponse = unknown;
export interface ResumeArtifactOptions extends RealtimeXRequestOptions {
  params?: ResumeArtifactParams;
  query?: ResumeArtifactQuery;
  headers?: ResumeArtifactHeaders & Record<string, string>;
  body?: ResumeArtifactBody;
}

export type ResumeLatestTerminalSessionParams = Record<string, never>;
export type ResumeLatestTerminalSessionQuery = Record<string, never>;
export type ResumeLatestTerminalSessionHeaders = {
  "x-app-id"?: string;
};
export type ResumeLatestTerminalSessionBody = {
  workspaceSlug: string;
  threadSlug: string;
  requestedBy?: string;
};
export type ResumeLatestTerminalSessionResponse = Record<string, unknown>;
export interface ResumeLatestTerminalSessionOptions extends RealtimeXRequestOptions {
  params?: ResumeLatestTerminalSessionParams;
  query?: ResumeLatestTerminalSessionQuery;
  headers?: ResumeLatestTerminalSessionHeaders & Record<string, string>;
  body?: ResumeLatestTerminalSessionBody;
}

export type ResumeTerminalSessionParams = {
  sessionId: string;
};
export type ResumeTerminalSessionQuery = Record<string, never>;
export type ResumeTerminalSessionHeaders = {
  "x-app-id"?: string;
};
export type ResumeTerminalSessionBody = {
  workspaceSlug?: string;
  threadSlug?: string;
  requestedBy?: string;
};
export type ResumeTerminalSessionResponse = Record<string, unknown>;
export interface ResumeTerminalSessionOptions extends RealtimeXRequestOptions {
  params?: ResumeTerminalSessionParams;
  query?: ResumeTerminalSessionQuery;
  headers?: ResumeTerminalSessionHeaders & Record<string, string>;
  body?: ResumeTerminalSessionBody;
}

export type RevokeArtifactParams = {
  artifactId: string;
};
export type RevokeArtifactQuery = Record<string, never>;
export type RevokeArtifactHeaders = {
  "x-app-id"?: string;
};
export type RevokeArtifactBody = unknown;
export type RevokeArtifactResponse = unknown;
export interface RevokeArtifactOptions extends RealtimeXRequestOptions {
  params?: RevokeArtifactParams;
  query?: RevokeArtifactQuery;
  headers?: RevokeArtifactHeaders & Record<string, string>;
  body?: RevokeArtifactBody;
}

export type RunAutomationFlowParams = {
  command: string;
};
export type RunAutomationFlowQuery = Record<string, never>;
export type RunAutomationFlowHeaders = {
  "x-app-id"?: string;
};
export type RunAutomationFlowBody = {
  options?: Record<string, unknown>;
  timeoutMs?: number;
  confirmDestructive?: boolean;
};
export type RunAutomationFlowResponse = Record<string, unknown>;
export interface RunAutomationFlowOptions extends RealtimeXRequestOptions {
  params?: RunAutomationFlowParams;
  query?: RunAutomationFlowQuery;
  headers?: RunAutomationFlowHeaders & Record<string, string>;
  body?: RunAutomationFlowBody;
}

export type RunAutomationWorkflowParams = Record<string, never>;
export type RunAutomationWorkflowQuery = Record<string, never>;
export type RunAutomationWorkflowHeaders = {
  "x-app-id"?: string;
};
export type RunAutomationWorkflowBody = {
  workflowName: string;
  optionsJson?: string;
  timeoutMs?: number;
  confirmDestructive?: boolean;
};
export type RunAutomationWorkflowResponse = Record<string, unknown>;
export interface RunAutomationWorkflowOptions extends RealtimeXRequestOptions {
  params?: RunAutomationWorkflowParams;
  query?: RunAutomationWorkflowQuery;
  headers?: RunAutomationWorkflowHeaders & Record<string, string>;
  body?: RunAutomationWorkflowBody;
}

export type SendChannelFileParams = Record<string, never>;
export type SendChannelFileQuery = Record<string, never>;
export type SendChannelFileHeaders = {
  "x-app-id"?: string;
};
export type SendChannelFileBody = {
  context: string;
  filePath?: string;
  fileName?: string;
  runtimeSessionId?: string;
  mime?: string;
  contentBase64?: string;
  caption?: string;
};
export type SendChannelFileResponse = Record<string, unknown>;
export interface SendChannelFileOptions extends RealtimeXRequestOptions {
  params?: SendChannelFileParams;
  query?: SendChannelFileQuery;
  headers?: SendChannelFileHeaders & Record<string, string>;
  body?: SendChannelFileBody;
}

export type SendMessageParams = {
  workspaceSlug: string;
  threadSlug: string;
};
export type SendMessageQuery = Record<string, never>;
export type SendMessageHeaders = {
  "x-app-id"?: string;
};
export type SendMessageBody = {
  message: string;
  attachments?: Array<Record<string, unknown>>;
  webSearchEnabled?: boolean;
  broadcastThreadEvents?: boolean;
  stripAgentPrefixForDelivery?: boolean;
  channelTurnId?: string;
};
export type SendMessageResponse = Record<string, unknown>;
export interface SendMessageOptions extends RealtimeXRequestOptions {
  params?: SendMessageParams;
  query?: SendMessageQuery;
  headers?: SendMessageHeaders & Record<string, string>;
  body?: SendMessageBody;
}

export type SetDefaultWorkspaceAgentParams = Record<string, never>;
export type SetDefaultWorkspaceAgentQuery = Record<string, never>;
export type SetDefaultWorkspaceAgentHeaders = Record<string, never>;
export type SetDefaultWorkspaceAgentBody = {
  workspaceName?: string;
  agentName?: string;
  modelName?: string;
  skipModelSelection?: boolean;
  actionTimeoutMs?: number;
  actionDelayMs?: number;
  tour?: boolean;
  tourId?: string;
  tourTts?: string;
  tourLang?: string;
  tourTtsVoice?: string;
  tourSurface?: string;
  tourTtsMaxWaitMs?: number;
  logProgress?: boolean;
  timeoutMs?: number;
  confirmDestructive?: boolean;
};
export type SetDefaultWorkspaceAgentResponse = Record<string, unknown>;
export interface SetDefaultWorkspaceAgentOptions extends RealtimeXRequestOptions {
  params?: SetDefaultWorkspaceAgentParams;
  query?: SetDefaultWorkspaceAgentQuery;
  headers?: SetDefaultWorkspaceAgentHeaders & Record<string, string>;
  body?: SetDefaultWorkspaceAgentBody;
}

export type SetHeartbeatActiveHoursParams = Record<string, never>;
export type SetHeartbeatActiveHoursQuery = Record<string, never>;
export type SetHeartbeatActiveHoursHeaders = {
  "x-app-id"?: string;
};
export type SetHeartbeatActiveHoursBody = {
  scope: "workspace" | "global" | "ambient";
  workspaceSlug?: string;
  start: string;
  end: string;
};
export type SetHeartbeatActiveHoursResponse = Record<string, unknown>;
export interface SetHeartbeatActiveHoursOptions extends RealtimeXRequestOptions {
  params?: SetHeartbeatActiveHoursParams;
  query?: SetHeartbeatActiveHoursQuery;
  headers?: SetHeartbeatActiveHoursHeaders & Record<string, string>;
  body?: SetHeartbeatActiveHoursBody;
}

export type SetHeartbeatAutoPilotParams = Record<string, never>;
export type SetHeartbeatAutoPilotQuery = Record<string, never>;
export type SetHeartbeatAutoPilotHeaders = {
  "x-app-id"?: string;
};
export type SetHeartbeatAutoPilotBody = {
  scope: "workspace" | "global" | "ambient";
  workspaceSlug?: string;
  enabled: boolean;
};
export type SetHeartbeatAutoPilotResponse = Record<string, unknown>;
export interface SetHeartbeatAutoPilotOptions extends RealtimeXRequestOptions {
  params?: SetHeartbeatAutoPilotParams;
  query?: SetHeartbeatAutoPilotQuery;
  headers?: SetHeartbeatAutoPilotHeaders & Record<string, string>;
  body?: SetHeartbeatAutoPilotBody;
}

export type SetHeartbeatDefaultAgentParams = Record<string, never>;
export type SetHeartbeatDefaultAgentQuery = Record<string, never>;
export type SetHeartbeatDefaultAgentHeaders = {
  "x-app-id"?: string;
};
export type SetHeartbeatDefaultAgentBody = {
  scope: "workspace" | "global" | "ambient";
  workspaceSlug?: string;
  canonical: string;
  providerId?: string;
  modelId?: string;
  reasoning_effort?: string;
};
export type SetHeartbeatDefaultAgentResponse = Record<string, unknown>;
export interface SetHeartbeatDefaultAgentOptions extends RealtimeXRequestOptions {
  params?: SetHeartbeatDefaultAgentParams;
  query?: SetHeartbeatDefaultAgentQuery;
  headers?: SetHeartbeatDefaultAgentHeaders & Record<string, string>;
  body?: SetHeartbeatDefaultAgentBody;
}

export type SetHeartbeatEnabledParams = Record<string, never>;
export type SetHeartbeatEnabledQuery = Record<string, never>;
export type SetHeartbeatEnabledHeaders = {
  "x-app-id"?: string;
};
export type SetHeartbeatEnabledBody = {
  scope: "workspace" | "global" | "ambient";
  workspaceSlug?: string;
  enabled: boolean;
};
export type SetHeartbeatEnabledResponse = Record<string, unknown>;
export interface SetHeartbeatEnabledOptions extends RealtimeXRequestOptions {
  params?: SetHeartbeatEnabledParams;
  query?: SetHeartbeatEnabledQuery;
  headers?: SetHeartbeatEnabledHeaders & Record<string, string>;
  body?: SetHeartbeatEnabledBody;
}

export type SetHeartbeatIntervalParams = Record<string, never>;
export type SetHeartbeatIntervalQuery = Record<string, never>;
export type SetHeartbeatIntervalHeaders = {
  "x-app-id"?: string;
};
export type SetHeartbeatIntervalBody = {
  scope: "workspace" | "global" | "ambient";
  workspaceSlug?: string;
  interval: string;
};
export type SetHeartbeatIntervalResponse = Record<string, unknown>;
export interface SetHeartbeatIntervalOptions extends RealtimeXRequestOptions {
  params?: SetHeartbeatIntervalParams;
  query?: SetHeartbeatIntervalQuery;
  headers?: SetHeartbeatIntervalHeaders & Record<string, string>;
  body?: SetHeartbeatIntervalBody;
}

export type SetHeartbeatTimezoneParams = Record<string, never>;
export type SetHeartbeatTimezoneQuery = Record<string, never>;
export type SetHeartbeatTimezoneHeaders = {
  "x-app-id"?: string;
};
export type SetHeartbeatTimezoneBody = {
  scope: "workspace" | "global" | "ambient";
  workspaceSlug?: string;
  timezone: string;
};
export type SetHeartbeatTimezoneResponse = Record<string, unknown>;
export interface SetHeartbeatTimezoneOptions extends RealtimeXRequestOptions {
  params?: SetHeartbeatTimezoneParams;
  query?: SetHeartbeatTimezoneQuery;
  headers?: SetHeartbeatTimezoneHeaders & Record<string, string>;
  body?: SetHeartbeatTimezoneBody;
}

export type SetupHeartbeatTasksParams = Record<string, never>;
export type SetupHeartbeatTasksQuery = {
  workspaceSlug?: string;
  scope: string;
};
export type SetupHeartbeatTasksHeaders = {
  "x-app-id"?: string;
};
export type SetupHeartbeatTasksBody = unknown;
export type SetupHeartbeatTasksResponse = {
  path?: string;
  template?: string;
  files?: {
  heartbeat?: string;
};
  instructions?: Array<string>;
};
export interface SetupHeartbeatTasksOptions extends RealtimeXRequestOptions {
  params?: SetupHeartbeatTasksParams;
  query?: SetupHeartbeatTasksQuery;
  headers?: SetupHeartbeatTasksHeaders & Record<string, string>;
  body?: SetupHeartbeatTasksBody;
}

export type SetupPersonalityParams = Record<string, never>;
export type SetupPersonalityQuery = {
  workspaceSlug?: string;
  scope: string;
};
export type SetupPersonalityHeaders = {
  "x-app-id"?: string;
};
export type SetupPersonalityBody = unknown;
export type SetupPersonalityResponse = {
  path?: string;
  template?: string;
  files?: {
  agents?: string;
  claude?: string;
  suggestedChildren?: Array<string>;
};
  instructions?: Array<string>;
};
export interface SetupPersonalityOptions extends RealtimeXRequestOptions {
  params?: SetupPersonalityParams;
  query?: SetupPersonalityQuery;
  headers?: SetupPersonalityHeaders & Record<string, string>;
  body?: SetupPersonalityBody;
}

export type SetupWorkingDirParams = Record<string, never>;
export type SetupWorkingDirQuery = Record<string, never>;
export type SetupWorkingDirHeaders = Record<string, never>;
export type SetupWorkingDirBody = {
  path?: string;
  description?: string;
  workspaces?: string;
  agents?: string;
  mode?: string;
  resetScopesToAll?: boolean;
  actionTimeoutMs?: number;
  actionDelayMs?: number;
  tour?: boolean;
  tourId?: string;
  tourTts?: string;
  tourLang?: string;
  tourTtsVoice?: string;
  tourSurface?: string;
  tourTtsMaxWaitMs?: number;
  logProgress?: boolean;
  timeoutMs?: number;
  confirmDestructive?: boolean;
};
export type SetupWorkingDirResponse = Record<string, unknown>;
export interface SetupWorkingDirOptions extends RealtimeXRequestOptions {
  params?: SetupWorkingDirParams;
  query?: SetupWorkingDirQuery;
  headers?: SetupWorkingDirHeaders & Record<string, string>;
  body?: SetupWorkingDirBody;
}

export type SetWorkspaceDefaultAgentParams = {
  workspaceSlug: string;
};
export type SetWorkspaceDefaultAgentQuery = Record<string, never>;
export type SetWorkspaceDefaultAgentHeaders = {
  authorization?: string;
  "x-app-id"?: string;
};
export type SetWorkspaceDefaultAgentBody = {
  canonical: string;
  providerId?: string;
  modelId?: string;
  reasoning_effort?: string;
};
export type SetWorkspaceDefaultAgentResponse = Record<string, unknown>;
export interface SetWorkspaceDefaultAgentOptions extends RealtimeXRequestOptions {
  params?: SetWorkspaceDefaultAgentParams;
  query?: SetWorkspaceDefaultAgentQuery;
  headers?: SetWorkspaceDefaultAgentHeaders & Record<string, string>;
  body?: SetWorkspaceDefaultAgentBody;
}

export type StartChannelParams = {
  channelId: string;
};
export type StartChannelQuery = Record<string, never>;
export type StartChannelHeaders = {
  "x-app-id"?: string;
};
export type StartChannelBody = unknown;
export type StartChannelResponse = Record<string, unknown>;
export interface StartChannelOptions extends RealtimeXRequestOptions {
  params?: StartChannelParams;
  query?: StartChannelQuery;
  headers?: StartChannelHeaders & Record<string, string>;
  body?: StartChannelBody;
}

export type StopChannelParams = {
  channelId: string;
};
export type StopChannelQuery = Record<string, never>;
export type StopChannelHeaders = {
  "x-app-id"?: string;
};
export type StopChannelBody = unknown;
export type StopChannelResponse = Record<string, unknown>;
export interface StopChannelOptions extends RealtimeXRequestOptions {
  params?: StopChannelParams;
  query?: StopChannelQuery;
  headers?: StopChannelHeaders & Record<string, string>;
  body?: StopChannelBody;
}

export type StopThreadTerminalSessionParams = Record<string, never>;
export type StopThreadTerminalSessionQuery = Record<string, never>;
export type StopThreadTerminalSessionHeaders = {
  "x-app-id"?: string;
};
export type StopThreadTerminalSessionBody = unknown;
export type StopThreadTerminalSessionResponse = Record<string, unknown>;
export interface StopThreadTerminalSessionOptions extends RealtimeXRequestOptions {
  params?: StopThreadTerminalSessionParams;
  query?: StopThreadTerminalSessionQuery;
  headers?: StopThreadTerminalSessionHeaders & Record<string, string>;
  body?: StopThreadTerminalSessionBody;
}

export type TerminateTerminalSessionParams = {
  sessionId: string;
};
export type TerminateTerminalSessionQuery = Record<string, never>;
export type TerminateTerminalSessionHeaders = {
  "x-app-id"?: string;
};
export type TerminateTerminalSessionBody = unknown;
export type TerminateTerminalSessionResponse = unknown;
export interface TerminateTerminalSessionOptions extends RealtimeXRequestOptions {
  params?: TerminateTerminalSessionParams;
  query?: TerminateTerminalSessionQuery;
  headers?: TerminateTerminalSessionHeaders & Record<string, string>;
  body?: TerminateTerminalSessionBody;
}

export type TriggerWorkspaceHeartbeatParams = {
  workspaceSlug: string;
};
export type TriggerWorkspaceHeartbeatQuery = Record<string, never>;
export type TriggerWorkspaceHeartbeatHeaders = {
  "x-app-id"?: string;
};
export type TriggerWorkspaceHeartbeatBody = unknown;
export type TriggerWorkspaceHeartbeatResponse = Record<string, unknown>;
export interface TriggerWorkspaceHeartbeatOptions extends RealtimeXRequestOptions {
  params?: TriggerWorkspaceHeartbeatParams;
  query?: TriggerWorkspaceHeartbeatQuery;
  headers?: TriggerWorkspaceHeartbeatHeaders & Record<string, string>;
  body?: TriggerWorkspaceHeartbeatBody;
}

export type TriggerWorkspaceHeartbeatTasksParams = {
  workspaceSlug: string;
};
export type TriggerWorkspaceHeartbeatTasksQuery = Record<string, never>;
export type TriggerWorkspaceHeartbeatTasksHeaders = {
  "x-app-id"?: string;
};
export type TriggerWorkspaceHeartbeatTasksBody = {
  tasks: Array<string>;
};
export type TriggerWorkspaceHeartbeatTasksResponse = Record<string, unknown>;
export interface TriggerWorkspaceHeartbeatTasksOptions extends RealtimeXRequestOptions {
  params?: TriggerWorkspaceHeartbeatTasksParams;
  query?: TriggerWorkspaceHeartbeatTasksQuery;
  headers?: TriggerWorkspaceHeartbeatTasksHeaders & Record<string, string>;
  body?: TriggerWorkspaceHeartbeatTasksBody;
}

export type UpdateChannelParams = {
  channelId: string;
};
export type UpdateChannelQuery = Record<string, never>;
export type UpdateChannelHeaders = {
  "x-app-id"?: string;
};
export type UpdateChannelBody = {
  name?: string;
  thread_id?: number;
  threadId?: number;
  terminalProgressRelay?: boolean;
  terminalProgressThrottleSeconds?: number;
  terminalExternalUserContext?: boolean;
  maxFileUploadMb?: number;
  ttsEnabled?: boolean;
  tts_enabled?: boolean;
};
export type UpdateChannelResponse = Record<string, unknown>;
export interface UpdateChannelOptions extends RealtimeXRequestOptions {
  params?: UpdateChannelParams;
  query?: UpdateChannelQuery;
  headers?: UpdateChannelHeaders & Record<string, string>;
  body?: UpdateChannelBody;
}

export interface RealtimeXClientOptions {
  baseUrl?: string;
  appId?: string;
  appIdAuth?: string;
  apiKey?: string;
  token?: string;
  headers?: Record<string, string>;
  fetch?: typeof fetch;
}

export interface RealtimeXRequestOptions {
  params?: Record<string, unknown>;
  query?: Record<string, unknown>;
  headers?: Record<string, string>;
  body?: unknown;
  signal?: AbortSignal;
}

export declare class RealtimeXApiError extends Error {
  status?: number;
  statusText?: string;
  body: unknown;
  response: Response;
}

export declare class RealtimeXClient {
  constructor(options?: RealtimeXClientOptions);
  request(operationName: string, options?: RealtimeXRequestOptions): Promise<unknown>;
  /** Approve one pending channel pairing code by visible 6-digit code or database id. Works for telegram, discord, and zalo channel pairing requests. */
  approveChannelPairingCode(options?: ApproveChannelPairingCodeOptions): Promise<ApproveChannelPairingCodeResponse>;
  approveChannelPairingCode(code: string, options?: Omit<ApproveChannelPairingCodeOptions, 'params'>): Promise<ApproveChannelPairingCodeResponse>;
  /** Guide a user through sending a chat message to the terminal agent. */
  chatWithTerminalAgent(options?: ChatWithTerminalAgentOptions): Promise<ChatWithTerminalAgentResponse>;
  chatWithTerminalAgent(body: ChatWithTerminalAgentBody, options?: Omit<ChatWithTerminalAgentOptions, 'body'>): Promise<ChatWithTerminalAgentResponse>;
  /** Clear the default CLI agent from a workspace. */
  clearWorkspaceDefaultAgent(options?: ClearWorkspaceDefaultAgentOptions): Promise<ClearWorkspaceDefaultAgentResponse>;
  clearWorkspaceDefaultAgent(workspaceSlug: string, options?: Omit<ClearWorkspaceDefaultAgentOptions, 'params'>): Promise<ClearWorkspaceDefaultAgentResponse>;
  /** Create a chat channel in one exact workspace. Defaults to Telegram when plugin_type, channelType, and type are omitted. Use flat botToken and thread_id fields instead of nested config/settings. */
  createChannel(options?: CreateChannelOptions): Promise<CreateChannelResponse>;
  createChannel(workspaceSlug: string, body: CreateChannelBody, options?: Omit<CreateChannelOptions, 'params' | 'body'>): Promise<CreateChannelResponse>;
  /** Create a thread in one workspace. The name is optional but recommended. */
  createThread(options?: CreateThreadOptions): Promise<CreateThreadResponse>;
  createThread(workspaceSlug: string, body: CreateThreadBody, options?: Omit<CreateThreadOptions, 'params' | 'body'>): Promise<CreateThreadResponse>;
  /** Create a workspace. Requires a human-readable workspace name. */
  createWorkspace(options?: CreateWorkspaceOptions): Promise<CreateWorkspaceResponse>;
  createWorkspace(body: CreateWorkspaceBody, options?: Omit<CreateWorkspaceOptions, 'body'>): Promise<CreateWorkspaceResponse>;
  /** Create a managed agent skill owned by one workspace. Terminal agents should use this instead of writing final skill content into runtime skill directories. */
  createWorkspaceAgentSkill(options?: CreateWorkspaceAgentSkillOptions): Promise<CreateWorkspaceAgentSkillResponse>;
  createWorkspaceAgentSkill(workspaceSlug: string, body: CreateWorkspaceAgentSkillBody, options?: Omit<CreateWorkspaceAgentSkillOptions, 'params' | 'body'>): Promise<CreateWorkspaceAgentSkillResponse>;
  /** Delete one chat channel by exact channel id. */
  deleteChannel(options?: DeleteChannelOptions): Promise<DeleteChannelResponse>;
  deleteChannel(channelId: string, options?: Omit<DeleteChannelOptions, 'params'>): Promise<DeleteChannelResponse>;
  /** Delete one thread by exact workspace slug and exact thread slug. */
  deleteThread(options?: DeleteThreadOptions): Promise<DeleteThreadResponse>;
  deleteThread(params: DeleteThreadParams, options?: Omit<DeleteThreadOptions, 'params'>): Promise<DeleteThreadResponse>;
  /** Delete one workspace by exact workspace slug. */
  deleteWorkspace(options?: DeleteWorkspaceOptions): Promise<DeleteWorkspaceResponse>;
  deleteWorkspace(workspaceSlug: string, options?: Omit<DeleteWorkspaceOptions, 'params'>): Promise<DeleteWorkspaceResponse>;
  /** Disable one installed plugin globally and unload it from runtime. Use a plugin id, name, or displayName from list-plugins. */
  disablePlugin(options?: DisablePluginOptions): Promise<DisablePluginResponse>;
  disablePlugin(pluginId: string, options?: Omit<DisablePluginOptions, 'params'>): Promise<DisablePluginResponse>;
  /** Disable one agent skill in a workspace. Use a skill id, name, or displayName from list-workspace-agent-skills. */
  disableWorkspaceAgentSkill(options?: DisableWorkspaceAgentSkillOptions): Promise<DisableWorkspaceAgentSkillResponse>;
  disableWorkspaceAgentSkill(params: DisableWorkspaceAgentSkillParams, options?: Omit<DisableWorkspaceAgentSkillOptions, 'params'>): Promise<DisableWorkspaceAgentSkillResponse>;
  /** Enable one installed plugin globally and load it into runtime. Use a plugin id, name, or displayName from list-plugins. */
  enablePlugin(options?: EnablePluginOptions): Promise<EnablePluginResponse>;
  enablePlugin(pluginId: string, options?: Omit<EnablePluginOptions, 'params'>): Promise<EnablePluginResponse>;
  /** Enable one agent skill in a workspace. Use a skill id, name, or displayName from list-workspace-agent-skills. */
  enableWorkspaceAgentSkill(options?: EnableWorkspaceAgentSkillOptions): Promise<EnableWorkspaceAgentSkillResponse>;
  enableWorkspaceAgentSkill(params: EnableWorkspaceAgentSkillParams, options?: Omit<EnableWorkspaceAgentSkillOptions, 'params'>): Promise<EnableWorkspaceAgentSkillResponse>;
  /** Get one public artifact by artifact id. */
  getArtifact(options?: GetArtifactOptions): Promise<GetArtifactResponse>;
  getArtifact(artifactId: string, options?: Omit<GetArtifactOptions, 'params'>): Promise<GetArtifactResponse>;
  /** Get one thread by exact workspace slug and exact thread slug. */
  getThread(options?: GetThreadOptions): Promise<GetThreadResponse>;
  getThread(params: GetThreadParams, options?: Omit<GetThreadOptions, 'params'>): Promise<GetThreadResponse>;
  /** Get one workspace by exact workspace slug. */
  getWorkspace(options?: GetWorkspaceOptions): Promise<GetWorkspaceResponse>;
  getWorkspace(workspaceSlug: string, options?: Omit<GetWorkspaceOptions, 'params'>): Promise<GetWorkspaceResponse>;
  /** List published agent skills. Use list-workspace-agent-skills to see enabled/disabled state for one workspace. */
  listAgentSkills(options?: ListAgentSkillsOptions): Promise<ListAgentSkillsResponse>;
  /** List public artifacts for one exact workspace slug. Revoked artifacts are hidden unless includeRevoked=true is passed. */
  listArtifacts(options?: ListArtifactsOptions): Promise<ListArtifactsResponse>;
  listArtifacts(workspaceSlug: string, options?: Omit<ListArtifactsOptions, 'params'>): Promise<ListArtifactsResponse>;
  /** List configured chat channels. Use returned channel ids with update-channel. */
  listChannels(options?: ListChannelsOptions): Promise<ListChannelsResponse>;
  /** List models for one provider id. Use an exact model id from this response when configuring workspace or thread LLM settings. */
  listLlmModels(options?: ListLlmModelsOptions): Promise<ListLlmModelsResponse>;
  listLlmModels(provider: string, options?: Omit<ListLlmModelsOptions, 'params'>): Promise<ListLlmModelsResponse>;
  /** List supported LLM providers. Use provider ids from this response when configuring workspace or thread LLM settings. */
  listLlmProviders(options?: ListLlmProvidersOptions): Promise<ListLlmProvidersResponse>;
  /** List installed plugins with enabled state and runtime load status. Use returned ids with enable-plugin, disable-plugin, and reload-plugin. */
  listPlugins(options?: ListPluginsOptions): Promise<ListPluginsResponse>;
  /** List terminal CLI agents that can be used with open-terminal-session. This is the same compact agent catalog returned by prepare.agents. */
  listTerminalAgents(options?: ListTerminalAgentsOptions): Promise<ListTerminalAgentsResponse>;
  /** List terminal runtime sessions known to the desktop app. Optionally filter by workspaceSlug and threadSlug. workspaceSlug is required when threadSlug is provided. */
  listTerminalSessions(options?: ListTerminalSessionsOptions): Promise<ListTerminalSessionsResponse>;
  listTerminalSessions(query?: ListTerminalSessionsQuery, options?: Omit<ListTerminalSessionsOptions, 'query'>): Promise<ListTerminalSessionsResponse>;
  /** List threads for one exact workspace slug. */
  listThreads(options?: ListThreadsOptions): Promise<ListThreadsResponse>;
  listThreads(workspaceSlug: string, options?: Omit<ListThreadsOptions, 'params'>): Promise<ListThreadsResponse>;
  /** List published agent skills with enabled/disabled state for one exact workspace slug. */
  listWorkspaceAgentSkills(options?: ListWorkspaceAgentSkillsOptions): Promise<ListWorkspaceAgentSkillsResponse>;
  listWorkspaceAgentSkills(workspaceSlug: string, options?: Omit<ListWorkspaceAgentSkillsOptions, 'params'>): Promise<ListWorkspaceAgentSkillsResponse>;
  /** List all workspaces visible to the current API caller. Use this before choosing a workspace slug. */
  listWorkspaces(options?: ListWorkspacesOptions): Promise<ListWorkspacesResponse>;
  /** Open a new desktop terminal session for one terminal CLI agent. Use list-terminal-agents or prepare.agents to choose agentName/providerId/modelId. workspaceSlug is required when threadSlug is provided. */
  openTerminalSession(options?: OpenTerminalSessionOptions): Promise<OpenTerminalSessionResponse>;
  openTerminalSession(body: OpenTerminalSessionBody, options?: Omit<OpenTerminalSessionOptions, 'body'>): Promise<OpenTerminalSessionResponse>;
  /** Pause one published artifact by artifact id. Paused artifacts remain listed but stop serving publicly. */
  pauseArtifact(options?: PauseArtifactOptions): Promise<PauseArtifactResponse>;
  pauseArtifact(artifactId: string, options?: Omit<PauseArtifactOptions, 'params'>): Promise<PauseArtifactResponse>;
  /** Return compact workspace, thread, current workspace/thread from explicit workspaceSlug and threadSlug query parameters, LLM provider, model, and CLI agent context for agents before choosing arguments. Agents should pass --workspace-slug "$RTX_WORKSPACE_SLUG" and --thread-slug "$RTX_THREAD_SLUG" when those environment variables exist. */
  prepare(options?: PrepareOptions): Promise<PrepareResponse>;
  prepare(query?: PrepareQuery, options?: Omit<PrepareOptions, 'query'>): Promise<PrepareResponse>;
  /** Promote one workspace-owned agent skill to a global managed skill by copying its files into a new global skill row. */
  promoteWorkspaceAgentSkill(options?: PromoteWorkspaceAgentSkillOptions): Promise<PromoteWorkspaceAgentSkillResponse>;
  promoteWorkspaceAgentSkill(params: PromoteWorkspaceAgentSkillParams, body: PromoteWorkspaceAgentSkillBody, options?: Omit<PromoteWorkspaceAgentSkillOptions, 'params' | 'body'>): Promise<PromoteWorkspaceAgentSkillResponse>;
  /** Publish a browser-viewable file or folder under a workspace artifacts directory. artifactPath is relative to that workspace artifacts directory. */
  publishArtifact(options?: PublishArtifactOptions): Promise<PublishArtifactResponse>;
  publishArtifact(workspaceSlug: string, body: PublishArtifactBody, options?: Omit<PublishArtifactOptions, 'params' | 'body'>): Promise<PublishArtifactResponse>;
  /** Force reload all enabled agent skills into one workspace working directory. Pass workspaceSlug; agents should pass the current RTX_WORKSPACE_SLUG when reloading the current workspace. After files are reloaded, the running agent must reload its own skill context before relying on updated skill instructions. */
  reloadAgentSkills(options?: ReloadAgentSkillsOptions): Promise<ReloadAgentSkillsResponse>;
  reloadAgentSkills(body: ReloadAgentSkillsBody, options?: Omit<ReloadAgentSkillsOptions, 'body'>): Promise<ReloadAgentSkillsResponse>;
  /** Reload one enabled plugin in runtime. Disabled plugins must be enabled before reload. */
  reloadPlugin(options?: ReloadPluginOptions): Promise<ReloadPluginResponse>;
  reloadPlugin(pluginId: string, options?: Omit<ReloadPluginOptions, 'params'>): Promise<ReloadPluginResponse>;
  /** Rename one thread by exact workspace slug and exact thread slug. Only the name is changed. */
  renameThread(options?: RenameThreadOptions): Promise<RenameThreadResponse>;
  renameThread(params: RenameThreadParams, body: RenameThreadBody, options?: Omit<RenameThreadOptions, 'params' | 'body'>): Promise<RenameThreadResponse>;
  /** Rename one workspace by exact workspace slug. Only the name is changed. */
  renameWorkspace(options?: RenameWorkspaceOptions): Promise<RenameWorkspaceResponse>;
  renameWorkspace(workspaceSlug: string, body: RenameWorkspaceBody, options?: Omit<RenameWorkspaceOptions, 'params' | 'body'>): Promise<RenameWorkspaceResponse>;
  /** Resume one paused artifact by artifact id. */
  resumeArtifact(options?: ResumeArtifactOptions): Promise<ResumeArtifactResponse>;
  resumeArtifact(artifactId: string, options?: Omit<ResumeArtifactOptions, 'params'>): Promise<ResumeArtifactResponse>;
  /** Resume the latest terminal runtime session for one exact thread. workspaceSlug and threadSlug are required in the body or query string. */
  resumeLatestTerminalSession(options?: ResumeLatestTerminalSessionOptions): Promise<ResumeLatestTerminalSessionResponse>;
  resumeLatestTerminalSession(body: ResumeLatestTerminalSessionBody, options?: Omit<ResumeLatestTerminalSessionOptions, 'body'>): Promise<ResumeLatestTerminalSessionResponse>;
  /** Resume a terminal runtime session by attaching a CLI controller. If the live session is closed or missing, historical resume metadata is used when available. */
  resumeTerminalSession(options?: ResumeTerminalSessionOptions): Promise<ResumeTerminalSessionResponse>;
  resumeTerminalSession(sessionId: string, body: ResumeTerminalSessionBody, options?: Omit<ResumeTerminalSessionOptions, 'params' | 'body'>): Promise<ResumeTerminalSessionResponse>;
  /** Revoke one artifact by artifact id. Revoked artifacts stop serving publicly and are hidden from list-artifacts by default. */
  revokeArtifact(options?: RevokeArtifactOptions): Promise<RevokeArtifactResponse>;
  revokeArtifact(artifactId: string, options?: Omit<RevokeArtifactOptions, 'params'>): Promise<RevokeArtifactResponse>;
  /** Run one app automation flow or scenario exposed via flowMetadata.cli.enabled=true. The command is the flowMetadata.cli.command value. */
  runAutomationFlow(options?: RunAutomationFlowOptions): Promise<RunAutomationFlowResponse>;
  runAutomationFlow(command: string, body: RunAutomationFlowBody, options?: Omit<RunAutomationFlowOptions, 'params' | 'body'>): Promise<RunAutomationFlowResponse>;
  /** Run any app automation flow or scenario exposed via flowMetadata.cli.enabled=true by passing workflowName. */
  runAutomationWorkflow(options?: RunAutomationWorkflowOptions): Promise<RunAutomationWorkflowResponse>;
  runAutomationWorkflow(body: RunAutomationWorkflowBody, options?: Omit<RunAutomationWorkflowOptions, 'body'>): Promise<RunAutomationWorkflowResponse>;
  /** Send one local CLI file back to an external channel using an explicit channel delivery context id. Channel-linked terminal agents should pass --context "$REALTIMEX_CHANNEL_DELIVERY_CONTEXT_ID". In desktop/local runtime the CLI should send an absolute filePath; contentBase64 remains available as fallback transport. */
  sendChannelFile(options?: SendChannelFileOptions): Promise<SendChannelFileResponse>;
  sendChannelFile(body: SendChannelFileBody, options?: Omit<SendChannelFileOptions, 'body'>): Promise<SendChannelFileResponse>;
  /** Send one message to an exact thread using the same routing as channel replies. Terminal-agent threads are dispatched to the terminal runtime; other threads use the configured LLM chat path. */
  sendMessage(options?: SendMessageOptions): Promise<SendMessageResponse>;
  sendMessage(params: SendMessageParams, body: SendMessageBody, options?: Omit<SendMessageOptions, 'params' | 'body'>): Promise<SendMessageResponse>;
  /** Set a workspace default agent from the desktop workspace chat settings UI. */
  setDefaultWorkspaceAgent(options?: SetDefaultWorkspaceAgentOptions): Promise<SetDefaultWorkspaceAgentResponse>;
  setDefaultWorkspaceAgent(body: SetDefaultWorkspaceAgentBody, options?: Omit<SetDefaultWorkspaceAgentOptions, 'body'>): Promise<SetDefaultWorkspaceAgentResponse>;
  /** Set workspace or global ambient-agent active hours using HH:mm start and end values. */
  setHeartbeatActiveHours(options?: SetHeartbeatActiveHoursOptions): Promise<SetHeartbeatActiveHoursResponse>;
  setHeartbeatActiveHours(body: SetHeartbeatActiveHoursBody, options?: Omit<SetHeartbeatActiveHoursOptions, 'body'>): Promise<SetHeartbeatActiveHoursResponse>;
  /** Turn workspace or global ambient-agent heartbeat auto pilot on or off. */
  setHeartbeatAutoPilot(options?: SetHeartbeatAutoPilotOptions): Promise<SetHeartbeatAutoPilotResponse>;
  setHeartbeatAutoPilot(body: SetHeartbeatAutoPilotBody, options?: Omit<SetHeartbeatAutoPilotOptions, 'body'>): Promise<SetHeartbeatAutoPilotResponse>;
  /** Set workspace or global ambient-agent default terminal agent and optional model for heartbeat defaults and legacy fallback. */
  setHeartbeatDefaultAgent(options?: SetHeartbeatDefaultAgentOptions): Promise<SetHeartbeatDefaultAgentResponse>;
  setHeartbeatDefaultAgent(body: SetHeartbeatDefaultAgentBody, options?: Omit<SetHeartbeatDefaultAgentOptions, 'body'>): Promise<SetHeartbeatDefaultAgentResponse>;
  /** Turn workspace or global ambient-agent heartbeat on or off. */
  setHeartbeatEnabled(options?: SetHeartbeatEnabledOptions): Promise<SetHeartbeatEnabledResponse>;
  setHeartbeatEnabled(body: SetHeartbeatEnabledBody, options?: Omit<SetHeartbeatEnabledOptions, 'body'>): Promise<SetHeartbeatEnabledResponse>;
  /** Set workspace or global ambient-agent scheduler check interval. Supports simple intervals only: m, h, or d, for example 3m, 1h, or 1d. */
  setHeartbeatInterval(options?: SetHeartbeatIntervalOptions): Promise<SetHeartbeatIntervalResponse>;
  setHeartbeatInterval(body: SetHeartbeatIntervalBody, options?: Omit<SetHeartbeatIntervalOptions, 'body'>): Promise<SetHeartbeatIntervalResponse>;
  /** Set workspace or global ambient-agent heartbeat timezone, for example Asia/Saigon or UTC. */
  setHeartbeatTimezone(options?: SetHeartbeatTimezoneOptions): Promise<SetHeartbeatTimezoneResponse>;
  setHeartbeatTimezone(body: SetHeartbeatTimezoneBody, options?: Omit<SetHeartbeatTimezoneOptions, 'body'>): Promise<SetHeartbeatTimezoneResponse>;
  /** Set up HEARTBEAT.md task instructions for a workspace or global ambient agent. Returns the target path, template, file path, and concise editing instructions. */
  setupHeartbeatTasks(options?: SetupHeartbeatTasksOptions): Promise<SetupHeartbeatTasksResponse>;
  setupHeartbeatTasks(query?: SetupHeartbeatTasksQuery, options?: Omit<SetupHeartbeatTasksOptions, 'query'>): Promise<SetupHeartbeatTasksResponse>;
  /** Set up AGENTS.md and CLAUDE.md personality files for a workspace or global ambient agent. Returns the target path, template, file paths, and concise editing instructions. */
  setupPersonality(options?: SetupPersonalityOptions): Promise<SetupPersonalityResponse>;
  setupPersonality(query?: SetupPersonalityQuery, options?: Omit<SetupPersonalityOptions, 'query'>): Promise<SetupPersonalityResponse>;
  /** Add or edit an agent working directory from the desktop settings UI. */
  setupWorkingDir(options?: SetupWorkingDirOptions): Promise<SetupWorkingDirResponse>;
  setupWorkingDir(body: SetupWorkingDirBody, options?: Omit<SetupWorkingDirOptions, 'body'>): Promise<SetupWorkingDirResponse>;
  /** Set the default CLI agent for a workspace. Use prepare first to find a valid agent canonical/providerId and optional modelId. */
  setWorkspaceDefaultAgent(options?: SetWorkspaceDefaultAgentOptions): Promise<SetWorkspaceDefaultAgentResponse>;
  setWorkspaceDefaultAgent(workspaceSlug: string, body: SetWorkspaceDefaultAgentBody, options?: Omit<SetWorkspaceDefaultAgentOptions, 'params' | 'body'>): Promise<SetWorkspaceDefaultAgentResponse>;
  /** Start one chat channel by exact channel id. */
  startChannel(options?: StartChannelOptions): Promise<StartChannelResponse>;
  startChannel(channelId: string, options?: Omit<StartChannelOptions, 'params'>): Promise<StartChannelResponse>;
  /** Stop one chat channel by exact channel id. */
  stopChannel(options?: StopChannelOptions): Promise<StopChannelResponse>;
  stopChannel(channelId: string, options?: Omit<StopChannelOptions, 'params'>): Promise<StopChannelResponse>;
  /** Interrupt the selected or current chat-linked terminal session for one exact thread without closing the underlying terminal session. This uses the same stop dispatcher as channel /stop commands. */
  stopThreadTerminalSession(options?: StopThreadTerminalSessionOptions): Promise<StopThreadTerminalSessionResponse>;
  /** Terminate a terminal runtime session by detaching any controller and closing the underlying PTY session. */
  terminateTerminalSession(options?: TerminateTerminalSessionOptions): Promise<TerminateTerminalSessionResponse>;
  terminateTerminalSession(sessionId: string, options?: Omit<TerminateTerminalSessionOptions, 'params'>): Promise<TerminateTerminalSessionResponse>;
  /** Trigger the default HEARTBEAT.md task for a workspace immediately. Falls back to the legacy heartbeat executor when no tasks are defined. */
  triggerWorkspaceHeartbeat(options?: TriggerWorkspaceHeartbeatOptions): Promise<TriggerWorkspaceHeartbeatResponse>;
  triggerWorkspaceHeartbeat(workspaceSlug: string, body: TriggerWorkspaceHeartbeatBody, options?: Omit<TriggerWorkspaceHeartbeatOptions, 'params' | 'body'>): Promise<TriggerWorkspaceHeartbeatResponse>;
  /** Trigger specified HEARTBEAT.md task names for a workspace immediately. */
  triggerWorkspaceHeartbeatTasks(options?: TriggerWorkspaceHeartbeatTasksOptions): Promise<TriggerWorkspaceHeartbeatTasksResponse>;
  triggerWorkspaceHeartbeatTasks(workspaceSlug: string, body: TriggerWorkspaceHeartbeatTasksBody, options?: Omit<TriggerWorkspaceHeartbeatTasksOptions, 'params' | 'body'>): Promise<TriggerWorkspaceHeartbeatTasksResponse>;
  /** Update one chat channel by exact channel id. Only channel writable fields are changed. */
  updateChannel(options?: UpdateChannelOptions): Promise<UpdateChannelResponse>;
  updateChannel(channelId: string, body: UpdateChannelBody, options?: Omit<UpdateChannelOptions, 'params' | 'body'>): Promise<UpdateChannelResponse>;
}

export declare function createRealtimeXClient(
  options?: RealtimeXClientOptions
): RealtimeXClient;
export declare const createClient: typeof createRealtimeXClient;
export declare const operations: Record<
  string,
  {
    method: string;
    path: string;
    pathParams: string[];
    queryParams: string[];
    headerParams: string[];
    hasBody: boolean;
  }
>;
export declare const version: string;