@realtimex/sdk 2.0.18 → 2.0.20

package/index.d.ts

@@ -0,0 +1,1448 @@
+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;