@leaflow/sdk 0.0.0-dev.51.g1857c7d → 0.0.0-dev.513.g3807ace

package/dist/assistant/v1/generated/functions.d.ts

@@ -0,0 +1,1790 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Assistant API
+ * Conversations with agents that operate the Leaflow platform, plus their folders, tasks, files and
+ * chat-app channels.
+ *
+ * A conversation is a thread. A person talks to the main thread; the agent in it can start subagents,
+ * which are threads too and run on their own: stopping the main thread does not stop them, and each
+ * subagent tells its parent when it ends. A thread runs in turns; each turn records the model and
+ * reasoning effort it used and its token usage.
+ *
+ * Models come from the Canopy catalogue. A new thread uses the model it names, the caller's default
+ * from /api/v1/settings, or the first catalogue model that can run an agent. Reasoning models take one
+ * of three efforts — low, medium or high — which are sent to the model unchanged.
+ *
+ * Read a thread's state with get-thread and its transcript with list-thread-items. Follow both live
+ * through EventBus by subscribing to assistant.thread.frame and assistant.resource.updated; after a
+ * reconnection or an assistant.workspace.invalidated message, read them again. list-thread-messages
+ * outlines the person's messages for navigating a long conversation.
+ *
+ * Upload large files with /api/v1/uploads: read /api/v1/upload-configuration first, send exact-sized
+ * parts, then complete the upload and send its attachment id in a message.
+ *
+ * Files uploaded that way are listed by search-attachments. Renaming or removing one does not change
+ * the conversations that already use it; downloading keeps working.
+ * OpenAPI spec version: 2.0.0
+ */
+import type { AnswerQuestionRequestBody, AttachmentFileResource, AttachmentListResponseBody, BindingCodeResponseBody, BindingResource, ChannelResource, ChannelWithSecretResponseBody, CheckSenderParams, CompleteUploadRequestBody, CreateChannelRequestBody, CreateFolderRequestBody, CreateTaskRequestBody, CreateThreadRequestBody, CreateThreadResponseBody, CreateUploadRequestBody, DecideToolCallsRequestBody, ErrorResponse, FolderListResponseBody, FolderResource, LengthAwarePageBindingResource, LengthAwarePageChannelResource, ListBindingsParams, ListChannelRejectionsParams, ListChannelsParams, ListTaskRunsParams, ListThreadItemsParams, ListThreadMessagesParams, ListThreadTurnsParams, LoginResource, MemoryListResponseBody, MoveFolderRequestBody, PlaceThreadRequestBody, PlatformListResponseBody, PutUploadPartHeaders, PutUploadPartParams, RejectionListResponseBody, ResumeThreadRequestBody, RevertRequestBody, RevertedCountResponseBody, RotateSecretRequestBody, SearchAttachmentsRequestBody, SearchTasksRequestBody, SearchThreadsRequestBody, SendMessageRequestBody, SendMessageResponseBody, SenderCheckResource, SettingsResource, SkillEnabledRequestBody, SkillListResponseBody, SkillRequestBody, SkillResource, TaskListResponseBody, TaskResource, TaskRunListResponseBody, TaskRunResource, ThreadItemListResponseBody, ThreadItemResource, ThreadListResponseBody, ThreadMessageListResponseBody, ThreadResource, ThreadTurnListResponseBody, ToolResultRequestBody, TurnStartedResponseBody, UpdateAttachmentRequestBody, UpdateChannelRequestBody, UpdateFolderRequestBody, UpdateSettingsRequestBody, UpdateTaskRequestBody, UpdateThreadRequestBody, UpdateUploadRequestBody, UploadAttachmentParams, UploadConfigurationResource, UploadListResponseBody, UploadPartResource, UploadResource, UploadedResource, VerifyCodeRequestBody, WebhookSecretResponseBody } from "./models.js";
+export type HTTPStatusCode1xx = 100 | 101 | 102 | 103;
+export type HTTPStatusCode2xx = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207;
+export type HTTPStatusCode3xx = 300 | 301 | 302 | 303 | 304 | 305 | 307 | 308;
+export type HTTPStatusCode4xx = 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 419 | 420 | 421 | 422 | 423 | 424 | 426 | 428 | 429 | 431 | 451;
+export type HTTPStatusCode5xx = 500 | 501 | 502 | 503 | 504 | 505 | 507 | 511;
+export type HTTPStatusCodes = HTTPStatusCode1xx | HTTPStatusCode2xx | HTTPStatusCode3xx | HTTPStatusCode4xx | HTTPStatusCode5xx;
+export type createThreadResponse201 = {
+    data: CreateThreadResponseBody;
+    status: 201;
+};
+export type createThreadResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 201>;
+};
+export type createThreadResponseSuccess = createThreadResponse201 & {
+    headers: Headers;
+};
+export type createThreadResponseError = createThreadResponseDefault & {
+    headers: Headers;
+};
+export type createThreadResponse = createThreadResponseSuccess | createThreadResponseError;
+export declare const getCreateThreadUrl: () => string;
+/**
+ * Creates a conversation and, when `message` is given, sends it as the first message in the same
+ * request, so starting a task is one round trip.
+ *
+ * The model is chosen in this order: `modelId` from the request, the caller's default from
+ * /api/v1/settings, then the first model in the Canopy catalogue that can run an agent. Fails with
+ * 422 and code MODEL_UNAVAILABLE when the chosen model cannot run an agent, and with 422 and code
+ * REASONING_UNSUPPORTED when `reasoningEffort` is given for a model without reasoning.
+ *
+ * Without `message`, creating a conversation does not contact a model provider.
+ * @summary Create a conversation
+ */
+export declare const createThread: (createThreadRequestBody: CreateThreadRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createThreadResponse>;
+export type searchThreadsResponse200 = {
+    data: ThreadListResponseBody;
+    status: 200;
+};
+export type searchThreadsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type searchThreadsResponseSuccess = searchThreadsResponse200 & {
+    headers: Headers;
+};
+export type searchThreadsResponseError = searchThreadsResponseDefault & {
+    headers: Headers;
+};
+export type searchThreadsResponse = searchThreadsResponseSuccess | searchThreadsResponseError;
+export declare const getSearchThreadsUrl: () => string;
+/**
+ * Lists the caller's conversations in this project with their state, progress and usage. The
+ * criteria travel in the request body. Keep the same criteria when following `nextCursor`.
+ *
+ * Subagents are conversations too. They are excluded unless `parentId` or `role` asks for them.
+ * `ids` reads a bounded batch, including subagents and archived conversations, and cannot be
+ * combined with a cursor.
+ *
+ * Counts over everything the criteria match cost more than the page itself; ask for them with
+ * `include: [counts]`, typically on the first page only.
+ * @summary Search conversations
+ */
+export declare const searchThreads: (searchThreadsRequestBody: SearchThreadsRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<searchThreadsResponse>;
+export type getThreadResponse200 = {
+    data: ThreadResource;
+    status: 200;
+};
+export type getThreadResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getThreadResponseSuccess = getThreadResponse200 & {
+    headers: Headers;
+};
+export type getThreadResponseError = getThreadResponseDefault & {
+    headers: Headers;
+};
+export type getThreadResponse = getThreadResponseSuccess | getThreadResponseError;
+export declare const getGetThreadUrl: (thread: string) => string;
+/**
+ * The conversation's state: model, reasoning effort, approval mode, what it is doing now, its
+ * plan, what it is waiting for, context usage and token usage. The transcript is read separately
+ * from /items.
+ * @summary Get a conversation
+ */
+export declare const getThread: (thread: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getThreadResponse>;
+export type updateThreadResponse200 = {
+    data: ThreadResource;
+    status: 200;
+};
+export type updateThreadResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type updateThreadResponseSuccess = updateThreadResponse200 & {
+    headers: Headers;
+};
+export type updateThreadResponseError = updateThreadResponseDefault & {
+    headers: Headers;
+};
+export type updateThreadResponse = updateThreadResponseSuccess | updateThreadResponseError;
+export declare const getUpdateThreadUrl: (thread: string) => string;
+/**
+ * Changes the title, model, reasoning effort, approval mode, or whether the conversation is
+ * archived. Omitted fields stay as they are.
+ *
+ * Model, reasoning and approval changes apply to the next model request; a request already in
+ * flight keeps its settings. A model that cannot run an agent fails with 422 and code
+ * MODEL_UNAVAILABLE. Switching to a model without reasoning clears `reasoningEffort`.
+ *
+ * Archiving makes the conversation read-only and fails with 409 and code THREAD_RUNNING while a
+ * turn is running.
+ * @summary Update a conversation
+ */
+export declare const updateThread: (thread: string, updateThreadRequestBody: UpdateThreadRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<updateThreadResponse>;
+export type deleteThreadResponse204 = {
+    data: void;
+    status: 204;
+};
+export type deleteThreadResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type deleteThreadResponseSuccess = deleteThreadResponse204 & {
+    headers: Headers;
+};
+export type deleteThreadResponseError = deleteThreadResponseDefault & {
+    headers: Headers;
+};
+export type deleteThreadResponse = deleteThreadResponseSuccess | deleteThreadResponseError;
+export declare const getDeleteThreadUrl: (thread: string) => string;
+/**
+ * Removes the conversation and its subagents from every list and makes them unreachable by id,
+ * including for the assistant. Deleting cannot be undone; archive instead to keep it readable.
+ *
+ * Fails with 409 and code THREAD_RUNNING while a turn is running. Deleting an already deleted
+ * conversation succeeds.
+ * @summary Delete a conversation
+ */
+export declare const deleteThread: (thread: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteThreadResponse>;
+export type interruptThreadResponse204 = {
+    data: void;
+    status: 204;
+};
+export type interruptThreadResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type interruptThreadResponseSuccess = interruptThreadResponse204 & {
+    headers: Headers;
+};
+export type interruptThreadResponseError = interruptThreadResponseDefault & {
+    headers: Headers;
+};
+export type interruptThreadResponse = interruptThreadResponseSuccess | interruptThreadResponseError;
+export declare const getInterruptThreadUrl: (thread: string) => string;
+/**
+ * Stops this conversation's running turn and discards its queued messages. Subagents keep
+ * running; stop them through their own conversations.
+ *
+ * Succeeds when nothing is running, because pressing stop races with the turn finishing on its
+ * own. Available while the project is suspended or being cleaned up.
+ * @summary Stop the running turn
+ */
+export declare const interruptThread: (thread: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<interruptThreadResponse>;
+export type resumeThreadResponse202 = {
+    data: TurnStartedResponseBody;
+    status: 202;
+};
+export type resumeThreadResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 202>;
+};
+export type resumeThreadResponseSuccess = resumeThreadResponse202 & {
+    headers: Headers;
+};
+export type resumeThreadResponseError = resumeThreadResponseDefault & {
+    headers: Headers;
+};
+export type resumeThreadResponse = resumeThreadResponseSuccess | resumeThreadResponseError;
+export declare const getResumeThreadUrl: (thread: string) => string;
+/**
+ * Starts a new turn that continues from where the conversation stopped, for example after it
+ * was interrupted or failed. An optional message is added first.
+ *
+ * Fails with 409 and code THREAD_RUNNING while a turn is running.
+ * @summary Resume a stopped conversation
+ */
+export declare const resumeThread: (thread: string, resumeThreadRequestBody: ResumeThreadRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<resumeThreadResponse>;
+export type compactThreadResponse202 = {
+    data: TurnStartedResponseBody;
+    status: 202;
+};
+export type compactThreadResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 202>;
+};
+export type compactThreadResponseSuccess = compactThreadResponse202 & {
+    headers: Headers;
+};
+export type compactThreadResponseError = compactThreadResponseDefault & {
+    headers: Headers;
+};
+export type compactThreadResponse = compactThreadResponseSuccess | compactThreadResponseError;
+export declare const getCompactThreadUrl: (thread: string) => string;
+/**
+ * Starts a compaction turn that summarizes the history before the latest user message, the same
+ * way the service does automatically when the context window fills up. The result appears in the
+ * transcript as a `compaction` item and the turn reports its own token usage.
+ *
+ * Fails with 409 and code THREAD_RUNNING while a turn is running, and with 409 and code
+ * NOTHING_TO_COMPACT when there is no history to summarize.
+ * @summary Compact the conversation now
+ */
+export declare const compactThread: (thread: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<compactThreadResponse>;
+export type revertThreadResponse200 = {
+    data: RevertedCountResponseBody;
+    status: 200;
+};
+export type revertThreadResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type revertThreadResponseSuccess = revertThreadResponse200 & {
+    headers: Headers;
+};
+export type revertThreadResponseError = revertThreadResponseDefault & {
+    headers: Headers;
+};
+export type revertThreadResponse = revertThreadResponseSuccess | revertThreadResponseError;
+export declare const getRevertThreadUrl: (thread: string) => string;
+/**
+ * Reverts the item at `ordinal` and everything after it. Reverted items stay in the transcript
+ * marked `reverted` and are left out of later model requests; ordinals are not renumbered.
+ * Executed tools and external changes are not undone. Returns how many items were reverted.
+ * @summary Revert from a given point
+ */
+export declare const revertThread: (thread: string, revertRequestBody: RevertRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<revertThreadResponse>;
+export type markThreadReadResponse204 = {
+    data: void;
+    status: 204;
+};
+export type markThreadReadResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type markThreadReadResponseSuccess = markThreadReadResponse204 & {
+    headers: Headers;
+};
+export type markThreadReadResponseError = markThreadReadResponseDefault & {
+    headers: Headers;
+};
+export type markThreadReadResponse = markThreadReadResponseSuccess | markThreadReadResponseError;
+export declare const getMarkThreadReadUrl: (thread: string) => string;
+/**
+ * Clears `unread` until the assistant replies again.
+ * @summary Mark a conversation as read
+ */
+export declare const markThreadRead: (thread: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<markThreadReadResponse>;
+export type listThreadItemsResponse200 = {
+    data: ThreadItemListResponseBody;
+    status: 200;
+};
+export type listThreadItemsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listThreadItemsResponseSuccess = listThreadItemsResponse200 & {
+    headers: Headers;
+};
+export type listThreadItemsResponseError = listThreadItemsResponseDefault & {
+    headers: Headers;
+};
+export type listThreadItemsResponse = listThreadItemsResponseSuccess | listThreadItemsResponseError;
+export declare const getListThreadItemsUrl: (thread: string, params?: ListThreadItemsParams) => string;
+/**
+ * A window of the conversation's transcript, oldest first: messages, reasoning, tool calls and
+ * compaction markers. A window holds whole turns, so a turn's messages and tool calls arrive
+ * together; a single turn larger than the size limit is split across windows.
+ *
+ * Without a position the window ends at the latest item. `before` reads the window above an
+ * ordinal and `after` the window below it; pass `startOrdinal` and `endOrdinal` from the response.
+ * `around` opens a window that contains an ordinal, for jumping to a turn from list-thread-turns or
+ * to a search result.
+ *
+ * Long reasoning and tool arguments are cut to a preview and marked `truncated`; read the item for
+ * all of it. Messages are never cut.
+ *
+ * When the window reaches the end, `queued` holds the messages waiting for the assistant and
+ * `streamCursor` is set: subscribe to `thread:{id}` on /api/v1/realtime from it to follow what is
+ * written next.
+ * @summary List transcript items
+ */
+export declare const listThreadItems: (thread: string, params?: ListThreadItemsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listThreadItemsResponse>;
+export type getThreadItemResponse200 = {
+    data: ThreadItemResource;
+    status: 200;
+};
+export type getThreadItemResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getThreadItemResponseSuccess = getThreadItemResponse200 & {
+    headers: Headers;
+};
+export type getThreadItemResponseError = getThreadItemResponseDefault & {
+    headers: Headers;
+};
+export type getThreadItemResponse = getThreadItemResponseSuccess | getThreadItemResponseError;
+export declare const getGetThreadItemUrl: (thread: string, item: string) => string;
+/**
+ * One item in full, including what list-thread-items cut from it.
+ * @summary Get a transcript item
+ */
+export declare const getThreadItem: (thread: string, item: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getThreadItemResponse>;
+export type listThreadMessagesResponse200 = {
+    data: ThreadMessageListResponseBody;
+    status: 200;
+};
+export type listThreadMessagesResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listThreadMessagesResponseSuccess = listThreadMessagesResponse200 & {
+    headers: Headers;
+};
+export type listThreadMessagesResponseError = listThreadMessagesResponseDefault & {
+    headers: Headers;
+};
+export type listThreadMessagesResponse = listThreadMessagesResponseSuccess | listThreadMessagesResponseError;
+export declare const getListThreadMessagesUrl: (thread: string, params?: ListThreadMessagesParams) => string;
+/**
+ * An outline of the messages the person sent in this conversation, from the console or a chat
+ * app, oldest first: what a timeline needs to place and preview every message without reading
+ * the transcript. Replies, tool calls and messages from subagents, tasks or other conversations
+ * are not included, nor are reverted messages or messages waiting in the queue.
+ *
+ * `index` is the message's position, from 1, and matches `messageIndex` on the transcript item.
+ * Read the message N with `offset` N-1. Open it in the transcript with list-thread-items
+ * `around` its `ordinal`. `total` equals the thread's `messageCount`.
+ * @summary List the person's messages
+ */
+export declare const listThreadMessages: (thread: string, params?: ListThreadMessagesParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listThreadMessagesResponse>;
+export type sendMessageResponse202 = {
+    data: SendMessageResponseBody;
+    status: 202;
+};
+export type sendMessageResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 202>;
+};
+export type sendMessageResponseSuccess = sendMessageResponse202 & {
+    headers: Headers;
+};
+export type sendMessageResponseError = sendMessageResponseDefault & {
+    headers: Headers;
+};
+export type sendMessageResponse = sendMessageResponseSuccess | sendMessageResponseError;
+export declare const getSendMessageUrl: (thread: string) => string;
+/**
+ * Starts a turn and returns at once; a turn can run for tens of minutes and its progress arrives
+ * on /api/v1/realtime. Sending while the assistant is working is allowed: the message is queued
+ * and read at the next step of the running turn, and `queued` is true.
+ *
+ * Fails with 409 and code THREAD_ARCHIVED for an archived conversation.
+ * @summary Send a message
+ */
+export declare const sendMessage: (thread: string, sendMessageRequestBody: SendMessageRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<sendMessageResponse>;
+export type decideToolCallsResponse204 = {
+    data: void;
+    status: 204;
+};
+export type decideToolCallsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type decideToolCallsResponseSuccess = decideToolCallsResponse204 & {
+    headers: Headers;
+};
+export type decideToolCallsResponseError = decideToolCallsResponseDefault & {
+    headers: Headers;
+};
+export type decideToolCallsResponse = decideToolCallsResponseSuccess | decideToolCallsResponseError;
+export declare const getDecideToolCallsUrl: (thread: string) => string;
+/**
+ * Decides the tool calls the conversation is waiting on, listed in `pendingAction.itemIds`. One
+ * decision applies to the whole batch, so `itemIds` must name exactly the calls awaiting approval.
+ *
+ * Repeating a decision that is already in effect succeeds. Fails with 409 and code
+ * APPROVAL_MISMATCH when `itemIds` is not the current batch, for example because another tab
+ * decided first and the assistant has moved on.
+ * @summary Approve or decline tool calls
+ */
+export declare const decideToolCalls: (thread: string, decideToolCallsRequestBody: DecideToolCallsRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<decideToolCallsResponse>;
+export type answerQuestionResponse204 = {
+    data: void;
+    status: 204;
+};
+export type answerQuestionResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type answerQuestionResponseSuccess = answerQuestionResponse204 & {
+    headers: Headers;
+};
+export type answerQuestionResponseError = answerQuestionResponseDefault & {
+    headers: Headers;
+};
+export type answerQuestionResponse = answerQuestionResponseSuccess | answerQuestionResponseError;
+export declare const getAnswerQuestionUrl: (thread: string, item: string) => string;
+/**
+ * Answers an `ask` tool call. Its questions are in the item's `questions`. An item that is already
+ * answered also succeeds: another tab may have answered first, or the auto-answer window may have
+ * passed, and either way the turn has continued.
+ * @summary Answer the assistant's questions
+ */
+export declare const answerQuestion: (thread: string, item: string, answerQuestionRequestBody: AnswerQuestionRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<answerQuestionResponse>;
+export type submitToolResultResponse204 = {
+    data: void;
+    status: 204;
+};
+export type submitToolResultResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type submitToolResultResponseSuccess = submitToolResultResponse204 & {
+    headers: Headers;
+};
+export type submitToolResultResponseError = submitToolResultResponseDefault & {
+    headers: Headers;
+};
+export type submitToolResultResponse = submitToolResultResponseSuccess | submitToolResultResponseError;
+export declare const getSubmitToolResultUrl: (thread: string, item: string) => string;
+/**
+ * The assistant asks the client to run one of the actions it declared by writing a tool call with
+ * the namespace `client`; the client runs it when the item turns in_progress and reports here.
+ *
+ * The first result counts. A later one fails with 409 and code RESULT_ALREADY_SUBMITTED.
+ * @summary Report what a client tool produced
+ */
+export declare const submitToolResult: (thread: string, item: string, toolResultRequestBody: ToolResultRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<submitToolResultResponse>;
+export type listThreadTurnsResponse200 = {
+    data: ThreadTurnListResponseBody;
+    status: 200;
+};
+export type listThreadTurnsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listThreadTurnsResponseSuccess = listThreadTurnsResponse200 & {
+    headers: Headers;
+};
+export type listThreadTurnsResponseError = listThreadTurnsResponseDefault & {
+    headers: Headers;
+};
+export type listThreadTurnsResponse = listThreadTurnsResponseSuccess | listThreadTurnsResponseError;
+export declare const getListThreadTurnsUrl: (thread: string, params?: ListThreadTurnsParams) => string;
+/**
+ * The conversation's turns, newest first, each with the model and reasoning effort it ran with,
+ * how long it took and the tokens it used. Cache hit rate is `cachedInputTokens / inputTokens`.
+ *
+ * Each turn names the ordinals it wrote and the message that started it, so a client can draw a
+ * timeline from this list and open a turn with list-thread-items `around`.
+ *
+ * `ids` reads the turns behind a page of transcript items in one request and cannot be combined
+ * with a cursor.
+ * @summary List turns
+ */
+export declare const listThreadTurns: (thread: string, params?: ListThreadTurnsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listThreadTurnsResponse>;
+export type listFoldersResponse200 = {
+    data: FolderListResponseBody;
+    status: 200;
+};
+export type listFoldersResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listFoldersResponseSuccess = listFoldersResponse200 & {
+    headers: Headers;
+};
+export type listFoldersResponseError = listFoldersResponseDefault & {
+    headers: Headers;
+};
+export type listFoldersResponse = listFoldersResponseSuccess | listFoldersResponseError;
+export declare const getListFoldersUrl: () => string;
+/**
+ * The caller's folders in this project in their own order, inbox first. Every conversation is in
+ * exactly one folder; the inbox holds the ones nobody filed. Not paginated: the number of folders
+ * is capped and all of them come back at once.
+ * @summary List folders
+ */
+export declare const listFolders: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listFoldersResponse>;
+export type createFolderResponse201 = {
+    data: FolderResource;
+    status: 201;
+};
+export type createFolderResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 201>;
+};
+export type createFolderResponseSuccess = createFolderResponse201 & {
+    headers: Headers;
+};
+export type createFolderResponseError = createFolderResponseDefault & {
+    headers: Headers;
+};
+export type createFolderResponse = createFolderResponseSuccess | createFolderResponseError;
+export declare const getCreateFolderUrl: () => string;
+/**
+ * A folder groups conversations on the board and does nothing else: the assistant is never told
+ * which folder a conversation is in. New folders go after the existing ones.
+ *
+ * Names are unique among the caller's folders in this project; a duplicate fails with 409 and
+ * code FOLDER_EXISTS.
+ * @summary Create a folder
+ */
+export declare const createFolder: (createFolderRequestBody: CreateFolderRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createFolderResponse>;
+export type getFolderResponse200 = {
+    data: FolderResource;
+    status: 200;
+};
+export type getFolderResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getFolderResponseSuccess = getFolderResponse200 & {
+    headers: Headers;
+};
+export type getFolderResponseError = getFolderResponseDefault & {
+    headers: Headers;
+};
+export type getFolderResponse = getFolderResponseSuccess | getFolderResponseError;
+export declare const getGetFolderUrl: (folder: string) => string;
+/**
+ * Its conversations are read with search-threads and `folderId`.
+ * @summary Get a folder
+ */
+export declare const getFolder: (folder: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getFolderResponse>;
+export type updateFolderResponse200 = {
+    data: FolderResource;
+    status: 200;
+};
+export type updateFolderResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type updateFolderResponseSuccess = updateFolderResponse200 & {
+    headers: Headers;
+};
+export type updateFolderResponseError = updateFolderResponseDefault & {
+    headers: Headers;
+};
+export type updateFolderResponse = updateFolderResponseSuccess | updateFolderResponseError;
+export declare const getUpdateFolderUrl: (folder: string) => string;
+/**
+ * The inbox cannot be renamed and fails with 409 and code INBOX_READ_ONLY.
+ * @summary Rename a folder
+ */
+export declare const updateFolder: (folder: string, updateFolderRequestBody: UpdateFolderRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<updateFolderResponse>;
+export type deleteFolderResponse204 = {
+    data: void;
+    status: 204;
+};
+export type deleteFolderResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type deleteFolderResponseSuccess = deleteFolderResponse204 & {
+    headers: Headers;
+};
+export type deleteFolderResponseError = deleteFolderResponseDefault & {
+    headers: Headers;
+};
+export type deleteFolderResponse = deleteFolderResponseSuccess | deleteFolderResponseError;
+export declare const getDeleteFolderUrl: (folder: string) => string;
+/**
+ * The conversations inside are not deleted; they move to the end of the inbox. The inbox cannot
+ * be deleted and fails with 409 and code INBOX_READ_ONLY. Deleting a folder that is already gone
+ * succeeds.
+ * @summary Delete a folder
+ */
+export declare const deleteFolder: (folder: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteFolderResponse>;
+export type moveFolderResponse200 = {
+    data: FolderResource;
+    status: 200;
+};
+export type moveFolderResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type moveFolderResponseSuccess = moveFolderResponse200 & {
+    headers: Headers;
+};
+export type moveFolderResponseError = moveFolderResponseDefault & {
+    headers: Headers;
+};
+export type moveFolderResponse = moveFolderResponseSuccess | moveFolderResponseError;
+export declare const getMoveFolderUrl: (folder: string) => string;
+/**
+ * Places the folder before `beforeFolderId`, or last when it is null. The inbox stays first.
+ * Fails with 409 and code ORDER_CHANGED when `expectedVersion` is stale; read the folders again
+ * and retry.
+ * @summary Reorder a folder
+ */
+export declare const moveFolder: (folder: string, moveFolderRequestBody: MoveFolderRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<moveFolderResponse>;
+export type placeThreadResponse200 = {
+    data: ThreadResource;
+    status: 200;
+};
+export type placeThreadResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type placeThreadResponseSuccess = placeThreadResponse200 & {
+    headers: Headers;
+};
+export type placeThreadResponseError = placeThreadResponseDefault & {
+    headers: Headers;
+};
+export type placeThreadResponse = placeThreadResponseSuccess | placeThreadResponseError;
+export declare const getPlaceThreadUrl: (folder: string, thread: string) => string;
+/**
+ * Puts the conversation into this folder at the given position, moving it out of the folder it
+ * was in. Give `beforeThreadId` or `afterThreadId` to place it next to a conversation of this
+ * folder; with neither it goes last. Moving does not change the conversation's activity time.
+ *
+ * Subagents are not filed and fail with 409 and code SUBAGENT_NOT_FILED. Fails with 409 and code
+ * ORDER_CHANGED when `expectedVersion` is stale.
+ * @summary Place a conversation in a folder
+ */
+export declare const placeThread: (folder: string, thread: string, placeThreadRequestBody: PlaceThreadRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<placeThreadResponse>;
+export type createTaskResponse201 = {
+    data: TaskResource;
+    status: 201;
+};
+export type createTaskResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 201>;
+};
+export type createTaskResponseSuccess = createTaskResponse201 & {
+    headers: Headers;
+};
+export type createTaskResponseError = createTaskResponseDefault & {
+    headers: Headers;
+};
+export type createTaskResponse = createTaskResponseSuccess | createTaskResponseError;
+export declare const getCreateTaskUrl: () => string;
+/**
+ * A task does something on a trigger and reports to a conversation. Its action either sends a
+ * prompt to the conversation, which starts a turn there, or runs a command on an instance and
+ * sends the result to the conversation when it ends.
+ *
+ * `trigger.type` `now` runs once immediately; `at` runs once at `runAt`; `interval` repeats every
+ * `intervalSeconds` from `anchorAt`; `cron` repeats on a cron expression in `timezone`. Each
+ * execution is a run, listed under /runs.
+ *
+ * Fails with 404 when the conversation does not exist and with 409 and code THREAD_ARCHIVED when
+ * it is archived.
+ * @summary Create a task
+ */
+export declare const createTask: (createTaskRequestBody: CreateTaskRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createTaskResponse>;
+export type searchTasksResponse200 = {
+    data: TaskListResponseBody;
+    status: 200;
+};
+export type searchTasksResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type searchTasksResponseSuccess = searchTasksResponse200 & {
+    headers: Headers;
+};
+export type searchTasksResponseError = searchTasksResponseDefault & {
+    headers: Headers;
+};
+export type searchTasksResponse = searchTasksResponseSuccess | searchTasksResponseError;
+export declare const getSearchTasksUrl: () => string;
+/**
+ * The caller's tasks in this project, most recently created first.
+ * @summary Search tasks
+ */
+export declare const searchTasks: (searchTasksRequestBody: SearchTasksRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<searchTasksResponse>;
+export type getTaskResponse200 = {
+    data: TaskResource;
+    status: 200;
+};
+export type getTaskResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getTaskResponseSuccess = getTaskResponse200 & {
+    headers: Headers;
+};
+export type getTaskResponseError = getTaskResponseDefault & {
+    headers: Headers;
+};
+export type getTaskResponse = getTaskResponseSuccess | getTaskResponseError;
+export declare const getGetTaskUrl: (task: string) => string;
+/**
+ * @summary Get a task
+ */
+export declare const getTask: (task: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getTaskResponse>;
+export type updateTaskResponse200 = {
+    data: TaskResource;
+    status: 200;
+};
+export type updateTaskResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type updateTaskResponseSuccess = updateTaskResponse200 & {
+    headers: Headers;
+};
+export type updateTaskResponseError = updateTaskResponseDefault & {
+    headers: Headers;
+};
+export type updateTaskResponse = updateTaskResponseSuccess | updateTaskResponseError;
+export declare const getUpdateTaskUrl: (task: string) => string;
+/**
+ * Changes the name, trigger or action. Omitted fields stay as they are; `trigger` and `action`
+ * are replaced as a whole. A run already in progress keeps the settings it started with.
+ * @summary Update a task
+ */
+export declare const updateTask: (task: string, updateTaskRequestBody: UpdateTaskRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<updateTaskResponse>;
+export type deleteTaskResponse204 = {
+    data: void;
+    status: 204;
+};
+export type deleteTaskResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type deleteTaskResponseSuccess = deleteTaskResponse204 & {
+    headers: Headers;
+};
+export type deleteTaskResponseError = deleteTaskResponseDefault & {
+    headers: Headers;
+};
+export type deleteTaskResponse = deleteTaskResponseSuccess | deleteTaskResponseError;
+export declare const getDeleteTaskUrl: (task: string) => string;
+/**
+ * Cancels a run in progress and removes the task. Its runs stay readable in the conversation's transcript.
+ * @summary Delete a task
+ */
+export declare const deleteTask: (task: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteTaskResponse>;
+export type runTaskResponse202 = {
+    data: TaskRunResource;
+    status: 202;
+};
+export type runTaskResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 202>;
+};
+export type runTaskResponseSuccess = runTaskResponse202 & {
+    headers: Headers;
+};
+export type runTaskResponseError = runTaskResponseDefault & {
+    headers: Headers;
+};
+export type runTaskResponse = runTaskResponseSuccess | runTaskResponseError;
+export declare const getRunTaskUrl: (task: string) => string;
+/**
+ * Starts a run immediately, outside its trigger. Fails with 409 and code TASK_RUNNING when a run
+ * is already in progress and the overlap policy is `skip`.
+ * @summary Run a task now
+ */
+export declare const runTask: (task: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<runTaskResponse>;
+export type pauseTaskResponse200 = {
+    data: TaskResource;
+    status: 200;
+};
+export type pauseTaskResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type pauseTaskResponseSuccess = pauseTaskResponse200 & {
+    headers: Headers;
+};
+export type pauseTaskResponseError = pauseTaskResponseDefault & {
+    headers: Headers;
+};
+export type pauseTaskResponse = pauseTaskResponseSuccess | pauseTaskResponseError;
+export declare const getPauseTaskUrl: (task: string) => string;
+/**
+ * Stops future runs from its trigger. A run in progress continues. Pausing a paused task succeeds.
+ * @summary Pause a task
+ */
+export declare const pauseTask: (task: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<pauseTaskResponse>;
+export type resumeTaskResponse200 = {
+    data: TaskResource;
+    status: 200;
+};
+export type resumeTaskResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type resumeTaskResponseSuccess = resumeTaskResponse200 & {
+    headers: Headers;
+};
+export type resumeTaskResponseError = resumeTaskResponseDefault & {
+    headers: Headers;
+};
+export type resumeTaskResponse = resumeTaskResponseSuccess | resumeTaskResponseError;
+export declare const getResumeTaskUrl: (task: string) => string;
+/**
+ * Lets its trigger start runs again. Missed runs within `catchupSeconds` are started. Resuming an active task succeeds.
+ * @summary Resume a task
+ */
+export declare const resumeTask: (task: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<resumeTaskResponse>;
+export type cancelTaskRunResponse200 = {
+    data: TaskResource;
+    status: 200;
+};
+export type cancelTaskRunResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type cancelTaskRunResponseSuccess = cancelTaskRunResponse200 & {
+    headers: Headers;
+};
+export type cancelTaskRunResponseError = cancelTaskRunResponseDefault & {
+    headers: Headers;
+};
+export type cancelTaskRunResponse = cancelTaskRunResponseSuccess | cancelTaskRunResponseError;
+export declare const getCancelTaskRunUrl: (task: string) => string;
+/**
+ * Stops the run in progress. The conversation is told the run was cancelled. Succeeds when nothing is running.
+ * @summary Cancel the running run
+ */
+export declare const cancelTaskRun: (task: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<cancelTaskRunResponse>;
+export type listTaskRunsResponse200 = {
+    data: TaskRunListResponseBody;
+    status: 200;
+};
+export type listTaskRunsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listTaskRunsResponseSuccess = listTaskRunsResponse200 & {
+    headers: Headers;
+};
+export type listTaskRunsResponseError = listTaskRunsResponseDefault & {
+    headers: Headers;
+};
+export type listTaskRunsResponse = listTaskRunsResponseSuccess | listTaskRunsResponseError;
+export declare const getListTaskRunsUrl: (task: string, params?: ListTaskRunsParams) => string;
+/**
+ * Newest first, without output; read a run with get-task-run for it.
+ * @summary List a task's runs
+ */
+export declare const listTaskRuns: (task: string, params?: ListTaskRunsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listTaskRunsResponse>;
+export type getTaskRunResponse200 = {
+    data: TaskRunResource;
+    status: 200;
+};
+export type getTaskRunResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getTaskRunResponseSuccess = getTaskRunResponse200 & {
+    headers: Headers;
+};
+export type getTaskRunResponseError = getTaskRunResponseDefault & {
+    headers: Headers;
+};
+export type getTaskRunResponse = getTaskRunResponseSuccess | getTaskRunResponseError;
+export declare const getGetTaskRunUrl: (task: string, run: string) => string;
+/**
+ * One run with the end of its output.
+ * @summary Get a task run
+ */
+export declare const getTaskRun: (task: string, run: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getTaskRunResponse>;
+export type getSettingsResponse200 = {
+    data: SettingsResource;
+    status: 200;
+};
+export type getSettingsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getSettingsResponseSuccess = getSettingsResponse200 & {
+    headers: Headers;
+};
+export type getSettingsResponseError = getSettingsResponseDefault & {
+    headers: Headers;
+};
+export type getSettingsResponse = getSettingsResponseSuccess | getSettingsResponseError;
+export declare const getGetSettingsUrl: () => string;
+/**
+ * The caller's assistant settings in this project. `defaultModel` is what a new conversation uses
+ * when it names no model: the caller's choice, or the first model in the Canopy catalogue that can
+ * run an agent.
+ * @summary Get settings
+ */
+export declare const getSettings: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getSettingsResponse>;
+export type updateSettingsResponse200 = {
+    data: SettingsResource;
+    status: 200;
+};
+export type updateSettingsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type updateSettingsResponseSuccess = updateSettingsResponse200 & {
+    headers: Headers;
+};
+export type updateSettingsResponseError = updateSettingsResponseDefault & {
+    headers: Headers;
+};
+export type updateSettingsResponse = updateSettingsResponseSuccess | updateSettingsResponseError;
+export declare const getUpdateSettingsUrl: () => string;
+/**
+ * Omitted fields stay as they are; null clears a choice so the catalogue default applies again.
+ * Existing conversations keep their models.
+ *
+ * Fails with 422 and code MODEL_UNAVAILABLE when the model cannot run an agent, and with 422 and
+ * code REASONING_UNSUPPORTED when a reasoning effort is set for a model without reasoning.
+ * @summary Update settings
+ */
+export declare const updateSettings: (updateSettingsRequestBody: UpdateSettingsRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<updateSettingsResponse>;
+export type uploadAttachmentResponse201 = {
+    data: UploadedResource;
+    status: 201;
+};
+export type uploadAttachmentResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 201>;
+};
+export type uploadAttachmentResponseSuccess = uploadAttachmentResponse201 & {
+    headers: Headers;
+};
+export type uploadAttachmentResponseError = uploadAttachmentResponseDefault & {
+    headers: Headers;
+};
+export type uploadAttachmentResponse = uploadAttachmentResponseSuccess | uploadAttachmentResponseError;
+export declare const getUploadAttachmentUrl: (params?: UploadAttachmentParams) => string;
+/**
+ * The body is the file bytes themselves, not multipart, one file per request. The type is determined from the content, not from Content-Type or from the name. Put the returned id in attachmentIds when sending a message.
+ *
+ * An upload that no message ever references is a draft, and drafts are collected — `draftExpiresAt` in the response says when this one goes. Sending a message with the id makes it permanent.
+ *
+ * The returned `type` says how the assistant will see it. An `image` is read directly, and only by models that accept image input. A small `text` file is placed inline in the message. A large `text` file, and anything `binary`, arrives as a reference the assistant reads on demand — for a binary that usually means downloading it onto one of the project's cloud instances.
+ * @summary Upload a file
+ */
+export declare const uploadAttachment: (uploadAttachmentBody: Blob, params?: UploadAttachmentParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<uploadAttachmentResponse>;
+export type searchAttachmentsResponse200 = {
+    data: AttachmentListResponseBody;
+    status: 200;
+};
+export type searchAttachmentsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type searchAttachmentsResponseSuccess = searchAttachmentsResponse200 & {
+    headers: Headers;
+};
+export type searchAttachmentsResponseError = searchAttachmentsResponseDefault & {
+    headers: Headers;
+};
+export type searchAttachmentsResponse = searchAttachmentsResponseSuccess | searchAttachmentsResponseError;
+export declare const getSearchAttachmentsUrl: () => string;
+/**
+ * The caller's files in this project, most recently uploaded first. These are the files
+ * uploaded while composing messages, plus uploads that no message has referenced yet.
+ *
+ * A file with no message referencing it is a draft: `draftExpiresAt` says when it is cleared.
+ * Sending a message with the id makes it permanent and that field becomes null.
+ *
+ * Files removed from the library are not listed, but conversations that already use them keep
+ * them and download-by-id still works.
+ * @summary Search attachments
+ */
+export declare const searchAttachments: (searchAttachmentsRequestBody: SearchAttachmentsRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<searchAttachmentsResponse>;
+export type getAttachmentResponse200 = {
+    data: AttachmentFileResource;
+    status: 200;
+};
+export type getAttachmentResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getAttachmentResponseSuccess = getAttachmentResponse200 & {
+    headers: Headers;
+};
+export type getAttachmentResponseError = getAttachmentResponseDefault & {
+    headers: Headers;
+};
+export type getAttachmentResponse = getAttachmentResponseSuccess | getAttachmentResponseError;
+export declare const getGetAttachmentUrl: (attachment: string) => string;
+/**
+ * Metadata for one attachment. The bytes are at /api/v1/attachments/{attachment}:download.
+ *
+ * Returns 404 when the attachment does not exist, does not belong to the current user, or was
+ * removed from the library. Removed files stay readable through their conversations but are no
+ * longer described here.
+ * @summary Get a file
+ */
+export declare const getAttachment: (attachment: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getAttachmentResponse>;
+export type updateAttachmentResponse200 = {
+    data: AttachmentFileResource;
+    status: 200;
+};
+export type updateAttachmentResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type updateAttachmentResponseSuccess = updateAttachmentResponse200 & {
+    headers: Headers;
+};
+export type updateAttachmentResponseError = updateAttachmentResponseDefault & {
+    headers: Headers;
+};
+export type updateAttachmentResponse = updateAttachmentResponseSuccess | updateAttachmentResponseError;
+export declare const getUpdateAttachmentUrl: (attachment: string) => string;
+/**
+ * Changes the name shown in the library and given to the assistant. The bytes and the attachment
+ * id do not change; conversations that already use it see the new name from their next request
+ * on.
+ * @summary Rename a file
+ */
+export declare const updateAttachment: (attachment: string, updateAttachmentRequestBody: UpdateAttachmentRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<updateAttachmentResponse>;
+export type deleteAttachmentResponse204 = {
+    data: void;
+    status: 204;
+};
+export type deleteAttachmentResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type deleteAttachmentResponseSuccess = deleteAttachmentResponse204 & {
+    headers: Headers;
+};
+export type deleteAttachmentResponseError = deleteAttachmentResponseDefault & {
+    headers: Headers;
+};
+export type deleteAttachmentResponse = deleteAttachmentResponseSuccess | deleteAttachmentResponseError;
+export declare const getDeleteAttachmentUrl: (attachment: string) => string;
+/**
+ * Hides the file from the library. Conversations that already use it keep it: the attachment
+ * stays readable by id and keeps rendering in their history. Its bytes are released when the
+ * project is deleted. A draft is cleared for good when its expiry passes. Idempotent.
+ * @summary Remove a file from the library
+ */
+export declare const deleteAttachment: (attachment: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteAttachmentResponse>;
+export type downloadAttachmentResponse200 = {
+    data: Blob;
+    status: 200;
+};
+export type downloadAttachmentResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type downloadAttachmentResponseSuccess = downloadAttachmentResponse200 & {
+    headers: Headers;
+};
+export type downloadAttachmentResponseError = downloadAttachmentResponseDefault & {
+    headers: Headers;
+};
+export type downloadAttachmentResponse = downloadAttachmentResponseSuccess | downloadAttachmentResponseError;
+export declare const getDownloadAttachmentUrl: (attachment: string) => string;
+/**
+ * Returns the original bytes for an attachment id, including one removed from the library. The response carries long-lived cache headers because the content never changes. Returns 404 when the attachment does not exist or does not belong to the current user.
+ *
+ * Only an attachment whose `type` is `image` comes back with its own image type and is usable as the address of an `<img>`. Everything else is served as `application/octet-stream` with `Content-Disposition: attachment`, deliberately: an uploaded file is arbitrary bytes under a name its uploader chose, and serving it back inline would run it on this origin.
+ * @summary Download a file
+ */
+export declare const downloadAttachment: (attachment: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<downloadAttachmentResponse>;
+export type getUploadConfigurationResponse200 = {
+    data: UploadConfigurationResource;
+    status: 200;
+};
+export type getUploadConfigurationResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getUploadConfigurationResponseSuccess = getUploadConfigurationResponse200 & {
+    headers: Headers;
+};
+export type getUploadConfigurationResponseError = getUploadConfigurationResponseDefault & {
+    headers: Headers;
+};
+export type getUploadConfigurationResponse = getUploadConfigurationResponseSuccess | getUploadConfigurationResponseError;
+export declare const getGetUploadConfigurationUrl: () => string;
+/**
+ * @summary Get upload configuration
+ */
+export declare const getUploadConfiguration: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getUploadConfigurationResponse>;
+export type createUploadResponse200 = {
+    data: UploadResource;
+    status: 200;
+};
+export type createUploadResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type createUploadResponseSuccess = createUploadResponse200 & {
+    headers: Headers;
+};
+export type createUploadResponseError = createUploadResponseDefault & {
+    headers: Headers;
+};
+export type createUploadResponse = createUploadResponseSuccess | createUploadResponseError;
+export declare const getCreateUploadUrl: () => string;
+/**
+ * @summary Create upload
+ */
+export declare const createUpload: (createUploadRequestBody: CreateUploadRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createUploadResponse>;
+export type listUploadsResponse200 = {
+    data: UploadListResponseBody;
+    status: 200;
+};
+export type listUploadsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listUploadsResponseSuccess = listUploadsResponse200 & {
+    headers: Headers;
+};
+export type listUploadsResponseError = listUploadsResponseDefault & {
+    headers: Headers;
+};
+export type listUploadsResponse = listUploadsResponseSuccess | listUploadsResponseError;
+export declare const getListUploadsUrl: () => string;
+/**
+ * @summary List uploads
+ */
+export declare const listUploads: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listUploadsResponse>;
+export type getUploadResponse200 = {
+    data: UploadResource;
+    status: 200;
+};
+export type getUploadResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getUploadResponseSuccess = getUploadResponse200 & {
+    headers: Headers;
+};
+export type getUploadResponseError = getUploadResponseDefault & {
+    headers: Headers;
+};
+export type getUploadResponse = getUploadResponseSuccess | getUploadResponseError;
+export declare const getGetUploadUrl: (upload: string) => string;
+/**
+ * @summary Get upload
+ */
+export declare const getUpload: (upload: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getUploadResponse>;
+export type updateUploadResponse200 = {
+    data: UploadResource;
+    status: 200;
+};
+export type updateUploadResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type updateUploadResponseSuccess = updateUploadResponse200 & {
+    headers: Headers;
+};
+export type updateUploadResponseError = updateUploadResponseDefault & {
+    headers: Headers;
+};
+export type updateUploadResponse = updateUploadResponseSuccess | updateUploadResponseError;
+export declare const getUpdateUploadUrl: (upload: string) => string;
+/**
+ * @summary Update upload
+ */
+export declare const updateUpload: (upload: string, updateUploadRequestBody: UpdateUploadRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<updateUploadResponse>;
+export type deleteUploadResponse200 = {
+    data: void;
+    status: 200;
+};
+export type deleteUploadResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type deleteUploadResponseSuccess = deleteUploadResponse200 & {
+    headers: Headers;
+};
+export type deleteUploadResponseError = deleteUploadResponseDefault & {
+    headers: Headers;
+};
+export type deleteUploadResponse = deleteUploadResponseSuccess | deleteUploadResponseError;
+export declare const getDeleteUploadUrl: (upload: string) => string;
+/**
+ * @summary Delete upload
+ */
+export declare const deleteUpload: (upload: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteUploadResponse>;
+export type cancelUploadResponse200 = {
+    data: void;
+    status: 200;
+};
+export type cancelUploadResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type cancelUploadResponseSuccess = cancelUploadResponse200 & {
+    headers: Headers;
+};
+export type cancelUploadResponseError = cancelUploadResponseDefault & {
+    headers: Headers;
+};
+export type cancelUploadResponse = cancelUploadResponseSuccess | cancelUploadResponseError;
+export declare const getCancelUploadUrl: (upload: string) => string;
+/**
+ * @summary Cancel upload
+ */
+export declare const cancelUpload: (upload: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<cancelUploadResponse>;
+export type completeUploadResponse200 = {
+    data: UploadedResource;
+    status: 200;
+};
+export type completeUploadResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type completeUploadResponseSuccess = completeUploadResponse200 & {
+    headers: Headers;
+};
+export type completeUploadResponseError = completeUploadResponseDefault & {
+    headers: Headers;
+};
+export type completeUploadResponse = completeUploadResponseSuccess | completeUploadResponseError;
+export declare const getCompleteUploadUrl: (upload: string) => string;
+/**
+ * @summary Complete upload
+ */
+export declare const completeUpload: (upload: string, completeUploadRequestBody: CompleteUploadRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<completeUploadResponse>;
+export type putUploadPartResponse200 = {
+    data: UploadPartResource;
+    status: 200;
+};
+export type putUploadPartResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type putUploadPartResponseSuccess = putUploadPartResponse200 & {
+    headers: Headers;
+};
+export type putUploadPartResponseError = putUploadPartResponseDefault & {
+    headers: Headers;
+};
+export type putUploadPartResponse = putUploadPartResponseSuccess | putUploadPartResponseError;
+export declare const getPutUploadPartUrl: (upload: string, part: number, params: PutUploadPartParams) => string;
+/**
+ * @summary Put upload part
+ */
+export declare const putUploadPart: (upload: string, part: number, putUploadPartBody: Blob, params: PutUploadPartParams, headers: PutUploadPartHeaders, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<putUploadPartResponse>;
+export type listMemoriesResponse200 = {
+    data: MemoryListResponseBody;
+    status: 200;
+};
+export type listMemoriesResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listMemoriesResponseSuccess = listMemoriesResponse200 & {
+    headers: Headers;
+};
+export type listMemoriesResponseError = listMemoriesResponseDefault & {
+    headers: Headers;
+};
+export type listMemoriesResponse = listMemoriesResponseSuccess | listMemoriesResponseError;
+export declare const getListMemoriesUrl: () => string;
+/**
+ * Facts the assistant has written down for the current account in this project. They appear at the start of every later conversation. Members of the same project each have their own, and this returns only the current account's. Not paginated: there is a cap on how many there can be, and all of them come back at once.
+ * @summary List what the assistant remembers
+ */
+export declare const listMemories: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listMemoriesResponse>;
+export type deleteMemoryResponse204 = {
+    data: void;
+    status: 204;
+};
+export type deleteMemoryResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type deleteMemoryResponseSuccess = deleteMemoryResponse204 & {
+    headers: Headers;
+};
+export type deleteMemoryResponseError = deleteMemoryResponseDefault & {
+    headers: Headers;
+};
+export type deleteMemoryResponse = deleteMemoryResponseSuccess | deleteMemoryResponseError;
+export declare const getDeleteMemoryUrl: (memory: string) => string;
+/**
+ * The assistant stops remembering this. It takes effect at once, so the next conversation will not carry it. The assistant may well learn the same thing again.
+ * @summary Delete one memory
+ */
+export declare const deleteMemory: (memory: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteMemoryResponse>;
+export type listSkillsResponse200 = {
+    data: SkillListResponseBody;
+    status: 200;
+};
+export type listSkillsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listSkillsResponseSuccess = listSkillsResponse200 & {
+    headers: Headers;
+};
+export type listSkillsResponseError = listSkillsResponseDefault & {
+    headers: Headers;
+};
+export type listSkillsResponse = listSkillsResponseSuccess | listSkillsResponseError;
+export declare const getListSkillsUrl: () => string;
+/**
+ * Everything the assistant can reach in this project, including the ones that are turned off —
+ * an entry that disappeared once it was switched off could not be switched back on.
+ *
+ * `origin` says whether a skill can be edited here. Skills belonging to the project are
+ * visible to everyone in it, whoever wrote them.
+ * @summary List the skills this project can use
+ */
+export declare const listSkills: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listSkillsResponse>;
+export type putSkillResponse200 = {
+    data: SkillResource;
+    status: 200;
+};
+export type putSkillResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type putSkillResponseSuccess = putSkillResponse200 & {
+    headers: Headers;
+};
+export type putSkillResponseError = putSkillResponseDefault & {
+    headers: Headers;
+};
+export type putSkillResponse = putSkillResponseSuccess | putSkillResponseError;
+export declare const getPutSkillUrl: () => string;
+/**
+ * Creates it, or replaces the project's skill of that name. The whole package goes in each
+ * time: files left out of a write are removed, so the stored skill is what was sent and not
+ * what accumulated.
+ *
+ * A project skill takes precedence over a built-in one of the same name for this project only.
+ * The built-in is untouched and reappears if the project's is deleted.
+ * @summary Write a skill for this project
+ */
+export declare const putSkill: (skillRequestBody: SkillRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<putSkillResponse>;
+export type getSkillResponse200 = {
+    data: SkillResource;
+    status: 200;
+};
+export type getSkillResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getSkillResponseSuccess = getSkillResponse200 & {
+    headers: Headers;
+};
+export type getSkillResponseError = getSkillResponseDefault & {
+    headers: Headers;
+};
+export type getSkillResponse = getSkillResponseSuccess | getSkillResponseError;
+export declare const getGetSkillUrl: (skill: string) => string;
+/**
+ * Works for built-in skills too; they simply cannot be written.
+ * @summary Read one skill, with its files
+ */
+export declare const getSkill: (skill: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getSkillResponse>;
+export type setSkillEnabledResponse200 = {
+    data: SkillResource;
+    status: 200;
+};
+export type setSkillEnabledResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type setSkillEnabledResponseSuccess = setSkillEnabledResponse200 & {
+    headers: Headers;
+};
+export type setSkillEnabledResponseError = setSkillEnabledResponseDefault & {
+    headers: Headers;
+};
+export type setSkillEnabledResponse = setSkillEnabledResponseSuccess | setSkillEnabledResponseError;
+export declare const getSetSkillEnabledUrl: (skill: string) => string;
+/**
+ * Separate from writing it, because this is the frequent one: a skill that is off costs
+ * nothing and stays where it is.
+ *
+ * Only skills belonging to the project can be switched. To keep a built-in one out of the
+ * way, write a project skill of the same name and turn that off.
+ * @summary Turn a skill on or off
+ */
+export declare const setSkillEnabled: (skill: string, skillEnabledRequestBody: SkillEnabledRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<setSkillEnabledResponse>;
+export type deleteSkillResponse204 = {
+    data: void;
+    status: 204;
+};
+export type deleteSkillResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type deleteSkillResponseSuccess = deleteSkillResponse204 & {
+    headers: Headers;
+};
+export type deleteSkillResponseError = deleteSkillResponseDefault & {
+    headers: Headers;
+};
+export type deleteSkillResponse = deleteSkillResponseSuccess | deleteSkillResponseError;
+export declare const getDeleteSkillUrl: (skill: string) => string;
+/**
+ * A built-in skill of the same name, if there was one, becomes visible again.
+ * @summary Delete this project's skill
+ */
+export declare const deleteSkill: (skill: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteSkillResponse>;
+export type listBindingsResponse200 = {
+    data: LengthAwarePageBindingResource;
+    status: 200;
+};
+export type listBindingsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listBindingsResponseSuccess = listBindingsResponse200 & {
+    headers: Headers;
+};
+export type listBindingsResponseError = listBindingsResponseDefault & {
+    headers: Headers;
+};
+export type listBindingsResponse = listBindingsResponseSuccess | listBindingsResponseError;
+export declare const getListBindingsUrl: (params?: ListBindingsParams) => string;
+/**
+ * Filter by channelId to show, per channel, who is bound to it.
+ * @summary List bindings
+ */
+export declare const listBindings: (params?: ListBindingsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listBindingsResponse>;
+export type getBindingResponse200 = {
+    data: BindingResource;
+    status: 200;
+};
+export type getBindingResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getBindingResponseSuccess = getBindingResponse200 & {
+    headers: Headers;
+};
+export type getBindingResponseError = getBindingResponseDefault & {
+    headers: Headers;
+};
+export type getBindingResponse = getBindingResponseSuccess | getBindingResponseError;
+export declare const getGetBindingUrl: (binding: string) => string;
+/**
+ * @summary Get a binding
+ */
+export declare const getBinding: (binding: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getBindingResponse>;
+export type deleteBindingResponse204 = {
+    data: void;
+    status: 204;
+};
+export type deleteBindingResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type deleteBindingResponseSuccess = deleteBindingResponse204 & {
+    headers: Headers;
+};
+export type deleteBindingResponseError = deleteBindingResponseDefault & {
+    headers: Headers;
+};
+export type deleteBindingResponse = deleteBindingResponseSuccess | deleteBindingResponseError;
+export declare const getDeleteBindingUrl: (binding: string) => string;
+/**
+ * @summary Remove a binding
+ */
+export declare const deleteBinding: (binding: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteBindingResponse>;
+export type listChannelsResponse200 = {
+    data: LengthAwarePageChannelResource;
+    status: 200;
+};
+export type listChannelsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listChannelsResponseSuccess = listChannelsResponse200 & {
+    headers: Headers;
+};
+export type listChannelsResponseError = listChannelsResponseDefault & {
+    headers: Headers;
+};
+export type listChannelsResponse = listChannelsResponseSuccess | listChannelsResponseError;
+export declare const getListChannelsUrl: (params?: ListChannelsParams) => string;
+/**
+ * @summary List channels
+ */
+export declare const listChannels: (params?: ListChannelsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listChannelsResponse>;
+export type createChannelResponse201 = {
+    data: ChannelWithSecretResponseBody;
+    status: 201;
+};
+export type createChannelResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 201>;
+};
+export type createChannelResponseSuccess = createChannelResponse201 & {
+    headers: Headers;
+};
+export type createChannelResponseError = createChannelResponseDefault & {
+    headers: Headers;
+};
+export type createChannelResponse = createChannelResponseSuccess | createChannelResponseError;
+export declare const getCreateChannelUrl: () => string;
+/**
+ * Which side owns the webhook secret is decided by the platform; see secretSource on list-platforms. For a `generated` platform, do not send webhookSecret — the one we generate is returned exactly once in this response and cannot be retrieved again; miss it and the only way forward is rotating to a new one. For a `supplied` platform you must pass the secret from that platform's own console, and webhookSecret in the response is null.
+ * @summary Create a channel
+ */
+export declare const createChannel: (createChannelRequestBody: CreateChannelRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createChannelResponse>;
+export type getChannelResponse200 = {
+    data: ChannelResource;
+    status: 200;
+};
+export type getChannelResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getChannelResponseSuccess = getChannelResponse200 & {
+    headers: Headers;
+};
+export type getChannelResponseError = getChannelResponseDefault & {
+    headers: Headers;
+};
+export type getChannelResponse = getChannelResponseSuccess | getChannelResponseError;
+export declare const getGetChannelUrl: (channel: string) => string;
+/**
+ * @summary Get a channel
+ */
+export declare const getChannel: (channel: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getChannelResponse>;
+export type updateChannelResponse200 = {
+    data: ChannelResource;
+    status: 200;
+};
+export type updateChannelResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type updateChannelResponseSuccess = updateChannelResponse200 & {
+    headers: Headers;
+};
+export type updateChannelResponseError = updateChannelResponseDefault & {
+    headers: Headers;
+};
+export type updateChannelResponse = updateChannelResponseSuccess | updateChannelResponseError;
+export declare const getUpdateChannelUrl: (channel: string) => string;
+/**
+ * Only the fields present are changed. senderPolicy and allowFrom go together, and senderPolicy decides whether they are replaced. For platforms held open by a long-lived connection the change applies once that connection is rebuilt; for webhook platforms it applies at once.
+ * @summary Update a channel
+ */
+export declare const updateChannel: (channel: string, updateChannelRequestBody: UpdateChannelRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<updateChannelResponse>;
+export type deleteChannelResponse204 = {
+    data: void;
+    status: 204;
+};
+export type deleteChannelResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type deleteChannelResponseSuccess = deleteChannelResponse204 & {
+    headers: Headers;
+};
+export type deleteChannelResponseError = deleteChannelResponseDefault & {
+    headers: Headers;
+};
+export type deleteChannelResponse = deleteChannelResponseSuccess | deleteChannelResponseError;
+export declare const getDeleteChannelUrl: (channel: string) => string;
+/**
+ * The channel stops accepting inbound messages and every binding on it stops working. This operation remains available while the project is suspended or being cleaned up.
+ * @summary Delete a channel
+ */
+export declare const deleteChannel: (channel: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteChannelResponse>;
+export type createBindingCodeResponse201 = {
+    data: BindingCodeResponseBody;
+    status: 201;
+};
+export type createBindingCodeResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 201>;
+};
+export type createBindingCodeResponseSuccess = createBindingCodeResponse201 & {
+    headers: Headers;
+};
+export type createBindingCodeResponseError = createBindingCodeResponseDefault & {
+    headers: Headers;
+};
+export type createBindingCodeResponse = createBindingCodeResponseSuccess | createBindingCodeResponseError;
+export declare const getCreateBindingCodeUrl: (channel: string) => string;
+/**
+ * Produces a single-use code to hand to the person being bound. They send that code to the assistant from their own account on that platform, which completes the binding. A binding can only be established this way, by the person themselves — a platform account cannot be named directly. Codes expire and have to be reissued.
+ * @summary Issue a binding code
+ */
+export declare const createBindingCode: (channel: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createBindingCodeResponse>;
+export type listChannelRejectionsResponse200 = {
+    data: RejectionListResponseBody;
+    status: 200;
+};
+export type listChannelRejectionsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listChannelRejectionsResponseSuccess = listChannelRejectionsResponse200 & {
+    headers: Headers;
+};
+export type listChannelRejectionsResponseError = listChannelRejectionsResponseDefault & {
+    headers: Headers;
+};
+export type listChannelRejectionsResponse = listChannelRejectionsResponseSuccess | listChannelRejectionsResponseError;
+export declare const getListChannelRejectionsUrl: (channel: string, params?: ListChannelRejectionsParams) => string;
+/**
+ * For diagnosing "I sent a message and the assistant never answered". Returns the inbound messages this channel rejected most recently, newest first, each with its reason. The most common reason is that the sender is not bound yet.
+ * @summary List recently rejected inbound messages
+ */
+export declare const listChannelRejections: (channel: string, params?: ListChannelRejectionsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listChannelRejectionsResponse>;
+export type rotateChannelSecretResponse200 = {
+    data: WebhookSecretResponseBody;
+    status: 200;
+};
+export type rotateChannelSecretResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type rotateChannelSecretResponseSuccess = rotateChannelSecretResponse200 & {
+    headers: Headers;
+};
+export type rotateChannelSecretResponseError = rotateChannelSecretResponseDefault & {
+    headers: Headers;
+};
+export type rotateChannelSecretResponse = rotateChannelSecretResponseSuccess | rotateChannelSecretResponseError;
+export declare const getRotateChannelSecretUrl: (channel: string) => string;
+/**
+ * Replaces the webhook secret. The old one stops working immediately and the channel drops back to awaiting confirmation from the platform. Which side owns the secret is decided by the platform; see secretSource on list-platforms. For a `generated` platform, send no body — the new secret is returned in this response only and cannot be retrieved again. For a `supplied` platform you must pass the new secret from that platform's own console.
+ * @summary Rotate the webhook secret
+ */
+export declare const rotateChannelSecret: (channel: string, rotateSecretRequestBody?: RotateSecretRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<rotateChannelSecretResponse>;
+export type checkSenderResponse200 = {
+    data: SenderCheckResource;
+    status: 200;
+};
+export type checkSenderResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type checkSenderResponseSuccess = checkSenderResponse200 & {
+    headers: Headers;
+};
+export type checkSenderResponseError = checkSenderResponseDefault & {
+    headers: Headers;
+};
+export type checkSenderResponse = checkSenderResponseSuccess | checkSenderResponseError;
+export declare const getCheckSenderUrl: (channel: string, params: CheckSenderParams) => string;
+/**
+ * For checking a sender policy after changing it. Sends nothing and changes nothing: it runs exactly the same decision a real inbound message goes through, and says which rule produced the answer. The binding-code rule cannot be tested this way — whether something is a binding code depends on what the sender actually wrote.
+ * @summary Test whether a sender would be let through
+ */
+export declare const checkSender: (channel: string, params: CheckSenderParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<checkSenderResponse>;
+export type beginWeixinLoginResponse201 = {
+    data: LoginResource;
+    status: 201;
+};
+export type beginWeixinLoginResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 201>;
+};
+export type beginWeixinLoginResponseSuccess = beginWeixinLoginResponse201 & {
+    headers: Headers;
+};
+export type beginWeixinLoginResponseError = beginWeixinLoginResponseDefault & {
+    headers: Headers;
+};
+export type beginWeixinLoginResponse = beginWeixinLoginResponseSuccess | beginWeixinLoginResponseError;
+export declare const getBeginWeixinLoginUrl: (channel: string) => string;
+/**
+ * A personal WeChat channel can only send and receive once its owner has signed in by scanning a QR code. This returns that code; poll `GET /v1/weixin-logins/{login}` for progress, and when the status asks for a verification code, submit it with `POST /v1/weixin-logins/{login}/verify-code`.
+ * @summary Begin a WeChat QR login
+ */
+export declare const beginWeixinLogin: (channel: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<beginWeixinLoginResponse>;
+export type listPlatformsResponse200 = {
+    data: PlatformListResponseBody;
+    status: 200;
+};
+export type listPlatformsResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listPlatformsResponseSuccess = listPlatformsResponse200 & {
+    headers: Headers;
+};
+export type listPlatformsResponseError = listPlatformsResponseDefault & {
+    headers: Headers;
+};
+export type listPlatformsResponse = listPlatformsResponseSuccess | listPlatformsResponseError;
+export declare const getListPlatformsUrl: () => string;
+/**
+ * The instant messaging platforms that can currently be connected, along with the flow and the credential fields each one needs. The create-channel form is driven entirely by this response: setupMethod decides between a credential form and a QR flow, credentialFields is what to ask for, and secretSource decides whether there is a webhook secret field at all.
+ * @summary List platforms that can be connected
+ */
+export declare const listPlatforms: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listPlatformsResponse>;
+export type getWeixinLoginResponse200 = {
+    data: LoginResource;
+    status: 200;
+};
+export type getWeixinLoginResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type getWeixinLoginResponseSuccess = getWeixinLoginResponse200 & {
+    headers: Headers;
+};
+export type getWeixinLoginResponseError = getWeixinLoginResponseDefault & {
+    headers: Headers;
+};
+export type getWeixinLoginResponse = getWeixinLoginResponseSuccess | getWeixinLoginResponseError;
+export declare const getGetWeixinLoginUrl: (login: string) => string;
+/**
+ * Poll this until the status is success or failure. When the status asks for a verification code, submit it with the verification-code operation.
+ * @summary Get the state of a QR login
+ */
+export declare const getWeixinLogin: (login: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getWeixinLoginResponse>;
+export type submitWeixinVerifyCodeResponse200 = {
+    data: LoginResource;
+    status: 200;
+};
+export type submitWeixinVerifyCodeResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type submitWeixinVerifyCodeResponseSuccess = submitWeixinVerifyCodeResponse200 & {
+    headers: Headers;
+};
+export type submitWeixinVerifyCodeResponseError = submitWeixinVerifyCodeResponseDefault & {
+    headers: Headers;
+};
+export type submitWeixinVerifyCodeResponse = submitWeixinVerifyCodeResponseSuccess | submitWeixinVerifyCodeResponseError;
+export declare const getSubmitWeixinVerifyCodeUrl: (login: string) => string;
+/**
+ * For when WeChat asks for an SMS or device code after the scan. The person who started the login gets that code on their own phone.
+ * @summary Submit a login verification code
+ */
+export declare const submitWeixinVerifyCode: (login: string, verifyCodeRequestBody: VerifyCodeRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<submitWeixinVerifyCodeResponse>;
+export type renewThreadPresenceResponse204 = {
+    data: void;
+    status: 204;
+};
+export type renewThreadPresenceResponseDefault = {
+    data: ErrorResponse;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type renewThreadPresenceResponseSuccess = renewThreadPresenceResponse204 & {
+    headers: Headers;
+};
+export type renewThreadPresenceResponseError = renewThreadPresenceResponseDefault & {
+    headers: Headers;
+};
+export type renewThreadPresenceResponse = renewThreadPresenceResponseSuccess | renewThreadPresenceResponseError;
+export declare const getRenewThreadPresenceUrl: (thread: string) => string;
+/**
+ * Renews an already announced browser client while the thread is open. It does not create or replace the client catalogue.
+ * @summary Renew client presence
+ */
+export declare const renewThreadPresence: (thread: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<renewThreadPresenceResponse>;