@leaflow/sdk 0.0.0-dev.33.g080e5fd → 0.0.0-dev.330.gb996dfa

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

@@ -0,0 +1,1023 @@
+/**
+ * Generated by orval 🍺
+ * Do not edit manually.
+ * Leaflow Assistant API
+ * The AI assistant inside the console: conversations, messages, tool calls and their approval, attachments, and connecting the assistant to instant messaging platforms such as WeChat, Feishu and Telegram.
+ *
+ * ## A conversation
+ *
+ * The path one conversation takes, end to end. It names the operations that path needs, not all of them — the full list is below, and it also covers folders, attachments, memories, skills and the instant messaging side.
+ *
+ * 1. `POST /api/v1/threads` creates one;
+ * 2. `POST /api/v1/threads/{thread}/messages` sends a message and returns a `turnId` at once; the assistant runs in the background;
+ * 3. `GET /api/v1/threads/{thread}` returns the conversation document to render, whose `stream` is where live output arrives;
+ * 4. When the assistant needs the user, the document's `wait` says which kind: approving a batch of tool calls (`POST /api/v1/threads/{thread}/approvals/{batch}`), or answering a few questions (`POST /api/v1/threads/{thread}/questions/{item}`). It continues on its own once that is handled.
+ *
+ * Sending a file takes two steps: `POST /api/v1/attachments` for an id, then put that id in `attachmentIds` when sending the message. Images, text and arbitrary binaries all go through the same two steps; what differs is how the assistant reads them afterwards, which the upload response's `kind` says.
+ *
+ * ## Models
+ *
+ * Canopy owns the model catalogue and capabilities. Model ids in this API, conversation preferences and historical entries are Canopy model ids, with no separate assistant model registration. GET /api/v1/models returns the allowed, usable choices and allowModelSelection. Hide the selector when selection is disabled; the service enforces the same rule.
+ *
+ * preferredModelId is the user's choice. Null follows the platform default, including later changes. Disabled selection preserves but ignores preferences for new turns. A model removed from the allowlist, retired in Canopy or otherwise unusable falls back to the default without clearing the preference.
+ *
+ * Users can switch an existing conversation through PATCH /api/v1/threads/{thread} with preferredModelId. This preserves the transcript, starts no turn and makes no inference request. Null returns to following the default. Changes apply from the next turn; a running or waiting turn and messages queued into it retain their captured choices and fallback policy.
+ *
+ * If the chosen model cannot serve a request, the service may safely fall back to the default without confirmation or an additional switching message. If the default also fails, the turn fails normally; no third model is selected for ordinary answers. Fallback preserves executed tool results and never splices answers from different models. Invalid input, cancellation and a declined tool call do not trigger model fallback. Each entry's model records its actual Canopy author, not the saved preference.
+ *
+ * Users cannot choose a compaction model. Normal compaction reuses the effective model and reasoning settings for context-cache reuse. Only if that model cannot handle the compaction request or produce a summary fitting the target window may the service automatically use another allowed Canopy model with suitable capabilities. This does not change the preference or ordinary answer model, and is permitted even when user model selection is disabled.
+ *
+ * After compaction, the full next request, including instructions, tools and retained messages, must fit the target's usable prompt budget with room left for an answer, respecting its output limit. If still too large, further compaction attempts are bounded; exhaustion fails with CANNOT_FOLD instead of sending an oversized request or silently discarding history or images. The same checks apply when switching models or falling back. Each compaction entry records its actual author.
+ *
+ * An empty allowlist or unavailable default does not prevent reading conversations or saving permitted preference changes. A failed Canopy catalogue read is not evidence that a model was removed: use a valid cached snapshot or return MODEL_CATALOG_UNAVAILABLE, without deleting references or inventing capabilities. Catalogue presence is configuration information, not a live provider health check.
+ *
+ * ## Live output
+ *
+ * ```
+ * GET /api/v1/turns/{turn}/stream?ticket=<ticket>&cursor=<cursor>
+ * ```
+ *
+ * This is a Server-Sent Events stream, which is why it is not in the operation list below and why generated clients have no method for it. Open it with `EventSource`, or any SSE client. It is how live output arrives; polling the document on a timer is not the intended way to follow a conversation.
+ *
+ * - `path` and `ticket` both come from the conversation document's `stream`. `path` is relative, resolved against the address the document was fetched from;
+ * - `cursor` is where to start, from the document's `cursor`. Omit it to start at the beginning of what is still available;
+ * - every event is one incremental edit to that same document, so the same rendering logic applies;
+ * - the connection has a lifetime and closes cleanly when it ends. With `EventSource` the browser reconnects with `Last-Event-ID` and resumes by itself, so nothing needs handling;
+ * - three terminal events: `done` this turn finished (carrying its final status), `paused` the assistant is waiting on the user (fetch the document again and read `wait`), `stalled` execution was interrupted and will not resume — do not reconnect.
+ * OpenAPI spec version: 1.0.0
+ */
+import type { AnswerRequestBody, BindingCodeResponseBody, BindingResource, ChannelResource, ChannelWithSecretResponseBody, CheckSenderParams, CreateChannelRequestBody, CreateFolderRequestBody, CreateThreadRequestBody, DecideRequestBody, DocumentResource, DynamicCallResultRequestBody, EarlierResponseBody, Error, FolderListResponseBody, FolderResource, LengthAwarePageBindingResource, LengthAwarePageChannelResource, ListBindingsParams, ListChannelRejectionsParams, ListChannelsParams, ListEarlierItemsParams, ListThreadsParams, LoginResource, MemoryListResponseBody, ModelListResponseBody, PlatformListResponseBody, RejectionListResponseBody, RevertRequestBody, RevertedCountResponseBody, RotateSecretRequestBody, SendMessageRequestBody, SenderCheckResource, SkillEnabledRequestBody, SkillListResponseBody, SkillRequestBody, SkillResource, ThreadListResponseBody, ThreadSummaryResource, TurnIDResponseBody, UpdateChannelRequestBody, UpdateFolderRequestBody, UpdateThreadRequestBody, UploadAttachmentParams, 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 listModelsResponse200 = {
+    data: ModelListResponseBody;
+    status: 200;
+};
+export type listModelsResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listModelsResponseSuccess = listModelsResponse200 & {
+    headers: Headers;
+};
+export type listModelsResponseError = listModelsResponseDefault & {
+    headers: Headers;
+};
+export type listModelsResponse = listModelsResponseSuccess | listModelsResponseError;
+export declare const getListModelsUrl: () => string;
+/**
+ * Returns Canopy's models filtered by Assistant's saved allowlist and selection policy. There is no separately maintained assistant catalogue. The complete list is not paginated and is ordered by displayName, then id.
+ *
+ * When allowModelSelection is true, models contains allowed Canopy models that remain callable, support tools and have positive context and output limits. When false, only the default is returned if it meets those conditions. defaultModelId is null if no usable default is known. Disallowed, retired and incompatible models are omitted, while saved preferences may still reference them.
+ *
+ * This operation reads capabilities without making an inference request. It does not check live provider health or the inference key's model restrictions. If Canopy cannot be read and no usable cached snapshot exists, it returns 503 with code MODEL_CATALOG_UNAVAILABLE; a failed read is not an empty catalogue. An empty allowlist returns an empty list without needing Canopy. Supplier connection details and credentials are not returned.
+ * @summary List assistant model choices
+ */
+export declare const listModels: (options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listModelsResponse>;
+export type uploadAttachmentResponse201 = {
+    data: UploadedResource;
+    status: 201;
+};
+export type uploadAttachmentResponseDefault = {
+    data: Error;
+    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 kind 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 `kind` 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 downloadAttachmentResponse200 = {
+    data: Blob;
+    status: 200;
+};
+export type downloadAttachmentResponseDefault = {
+    data: Error;
+    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. 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 `kind` 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 listBindingsResponse200 = {
+    data: LengthAwarePageBindingResource;
+    status: 200;
+};
+export type listBindingsResponseDefault = {
+    data: Error;
+    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: Error;
+    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: Error;
+    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: Error;
+    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: Error;
+    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: Error;
+    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: Error;
+    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: Error;
+    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: Error;
+    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: Error;
+    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: Error;
+    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: Error;
+    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: Error;
+    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: Error;
+    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: Error;
+    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: Error;
+    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 submitDynamicCallResultResponse204 = {
+    data: void;
+    status: 204;
+};
+export type submitDynamicCallResultResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type submitDynamicCallResultResponseSuccess = submitDynamicCallResultResponse204 & {
+    headers: Headers;
+};
+export type submitDynamicCallResultResponseError = submitDynamicCallResultResponseDefault & {
+    headers: Headers;
+};
+export type submitDynamicCallResultResponse = submitDynamicCallResultResponseSuccess | submitDynamicCallResultResponseError;
+export declare const getSubmitDynamicCallResultUrl: (call: string) => string;
+/**
+ * The assistant asks the client to run an action by adding a tool call to the conversation
+ * with the namespace `dynamic`; the client acts when that entry turns in_progress and reports
+ * back here.
+ *
+ * The first result is the one that counts. A later one is refused rather than replacing it.
+ * @summary Report what an action produced
+ */
+export declare const submitDynamicCallResult: (call: string, dynamicCallResultRequestBody: DynamicCallResultRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<submitDynamicCallResultResponse>;
+export type listFoldersResponse200 = {
+    data: FolderListResponseBody;
+    status: 200;
+};
+export type listFoldersResponseDefault = {
+    data: Error;
+    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 current account's folders in this project, oldest first. That order is fixed and does not react to what happens inside a folder: a folder is a place on the screen, and a place that moves whenever something is put into it is not one anybody can aim at. Not paginated — there is a cap on how many there can be, 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: Error;
+    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 in the sidebar and does nothing else. The assistant is never told which folder a conversation is in, and a conversation behaves exactly the same inside one as outside: no shared instructions, no shared files, no shared memory.
+ *
+ * Names are unique within an account's folders in this project, because the only way to aim at a folder is to read its name.
+ * @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: Error;
+    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;
+/**
+ * The list returns every folder at once, so this is for the case the list does not cover: a page opened straight at a folder, holding nothing but the id from the address bar. Its conversations are a separate request — `GET /api/v1/threads?folder=<id>`.
+ * @summary Fetch one 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: Error;
+    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 conversations in it are untouched, and none of them move in the list — a folder's name is not part of what any conversation is about.
+ * @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: Error;
+    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 leave the folder and go back to the ungrouped list, where they can be filed again. Emptying a shelf is not the same as throwing out what was on it, and deleting a conversation is a different request.
+ *
+ * Idempotent: deleting a folder that is already gone succeeds and changes nothing.
+ * @summary Delete a folder
+ */
+export declare const deleteFolder: (folder: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteFolderResponse>;
+export type listMemoriesResponse200 = {
+    data: MemoryListResponseBody;
+    status: 200;
+};
+export type listMemoriesResponseDefault = {
+    data: Error;
+    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: Error;
+    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: Error;
+    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: Error;
+    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: Error;
+    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: Error;
+    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: Error;
+    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 listThreadsResponse200 = {
+    data: ThreadListResponseBody;
+    status: 200;
+};
+export type listThreadsResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listThreadsResponseSuccess = listThreadsResponse200 & {
+    headers: Headers;
+};
+export type listThreadsResponseError = listThreadsResponseDefault & {
+    headers: Headers;
+};
+export type listThreadsResponse = listThreadsResponseSuccess | listThreadsResponseError;
+export declare const getListThreadsUrl: (params?: ListThreadsParams) => string;
+/**
+ * Ordered by most recent activity, limited to the current account's conversations in the current project. `archived` selects between two sets rather than widening one: archived conversations are absent from the default list, and turning the flag on shows those instead.
+ *
+ * Pass the returned nextCursor as cursor; omit cursor on the first page. Continue with the same q, archived and folder filters. The cursor marks a position in the activity order, so changing filters between pages does not continue the same list.
+ * @summary List conversations
+ */
+export declare const listThreads: (params?: ListThreadsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listThreadsResponse>;
+export type createThreadResponse201 = {
+    data: ThreadSummaryResource;
+    status: 201;
+};
+export type createThreadResponseDefault = {
+    data: Error;
+    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;
+/**
+ * Omit preferredModelId or set it to null to follow the platform default. A non-null preference is accepted only while model selection is enabled; otherwise the request fails with 403 and code MODEL_SELECTION_DISABLED.
+ *
+ * A well-formed preference for a Canopy model that is no longer allowed or has been retired or removed is retained and uses the default when a turn starts. This also handles a catalogue change between displaying the selector and submitting the choice. Creating a conversation does not contact a model provider and remains possible when generation is unavailable.
+ * @summary Create a conversation
+ */
+export declare const createThread: (createThreadRequestBody: CreateThreadRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<createThreadResponse>;
+export type getThreadResponse200 = {
+    data: DocumentResource;
+    status: 200;
+};
+export type getThreadResponseDefault = {
+    data: Error;
+    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 complete current state of a conversation, for the first render. Its `stream` gives the address and admission ticket for live output, and what that stream pushes are incremental edits to this same document, so the same rendering logic applies.
+ * @summary Fetch the conversation document
+ */
+export declare const getThread: (thread: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<getThreadResponse>;
+export type updateThreadResponse200 = {
+    data: ThreadSummaryResource;
+    status: 200;
+};
+export type updateThreadResponseDefault = {
+    data: Error;
+    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, folder, approval mode, model preference, and whether the conversation is archived. Approval and model preference changes take effect from the next turn; a turn already running keeps the settings it started with.
+ *
+ * Omit preferredModelId to leave the preference unchanged, or set it to null to follow the platform default. A non-null preference is accepted only while model selection is enabled; otherwise the whole request fails with 403 and code MODEL_SELECTION_DISABLED and none of its fields are changed. Clearing a preference remains allowed while selection is disabled. A well-formed preference for a disallowed, retired or removed Canopy model is retained and falls back to the default when used.
+ *
+ * Model switching is allowed on an existing conversation, including while a turn is generating or waiting for approval or an answer. The response immediately returns the saved preferredModelId, while model continues to identify the running turn's effective model until it finishes. Messages queued into that running turn also keep its captured model choices. The next turn uses the latest saved preference.
+ *
+ * Changing the preference does not create a new conversation, start a turn, call a model provider, clear the transcript, or rewrite historical model attribution. Before the next turn sends its first request to the selected model, the service checks that model's input capabilities and usable context budget. A switch to a smaller window may require compaction under the compaction policy above; saving the preference alone does not establish that the conversation fits.
+ *
+ * Archiving makes a conversation read-only: it stays in the list under "archived", stays readable, and the assistant can still find it when it searches past conversations — it just takes no new input. Unarchive it to continue. Archiving fails while a turn is running; stop it first.
+ * @summary Update conversation settings
+ */
+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: Error;
+    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 from every list and makes it unreachable by id. The assistant can no longer find it either — neither by searching past conversations nor by reading one back.
+ *
+ * Deleting is not the same as archiving, and the two are not degrees of the same thing. An archived conversation is still there and still readable, it just takes no new input; a deleted one is gone from view. Archiving can be undone; this cannot.
+ *
+ * What survives is the record itself, because a conversation with this assistant is an account of what was done to real infrastructure — which machine was changed, which disk was removed. That record is kept even though nobody can reach it here.
+ *
+ * Fails while a turn is running: stop it first. Deleting an already deleted conversation succeeds and changes nothing.
+ * @summary Delete a conversation
+ */
+export declare const deleteThread: (thread: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<deleteThreadResponse>;
+export type decideApprovalResponse204 = {
+    data: void;
+    status: 204;
+};
+export type decideApprovalResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 204>;
+};
+export type decideApprovalResponseSuccess = decideApprovalResponse204 & {
+    headers: Headers;
+};
+export type decideApprovalResponseError = decideApprovalResponseDefault & {
+    headers: Headers;
+};
+export type decideApprovalResponse = decideApprovalResponseSuccess | decideApprovalResponseError;
+export declare const getDecideApprovalUrl: (thread: string, batch: string) => string;
+/**
+ * The batch id comes from the conversation document's `wait`. This is idempotent: submitting the same batch again neither changes a decision already in effect nor reports an error. Returns 404 when the batch does not belong to that conversation.
+ * @summary Approve or decline a batch of tool calls
+ */
+export declare const decideApproval: (thread: string, batch: string, decideRequestBody: DecideRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<decideApprovalResponse>;
+export type listEarlierItemsResponse200 = {
+    data: EarlierResponseBody;
+    status: 200;
+};
+export type listEarlierItemsResponseDefault = {
+    data: Error;
+    status: Exclude<HTTPStatusCodes, 200>;
+};
+export type listEarlierItemsResponseSuccess = listEarlierItemsResponse200 & {
+    headers: Headers;
+};
+export type listEarlierItemsResponseError = listEarlierItemsResponseDefault & {
+    headers: Headers;
+};
+export type listEarlierItemsResponse = listEarlierItemsResponseSuccess | listEarlierItemsResponseError;
+export declare const getListEarlierItemsUrl: (thread: string, params: ListEarlierItemsParams) => string;
+/**
+ * The first render only carries the latest stretch of a conversation; anything above it is fetched here, one stretch at a time. Pass the document's earlier.before as `before`; the `earlier` in the response is the cursor for the stretch above that, and null means the top has been reached. The entries have the same shape and the same order (oldest first) as `items` in the document, so they can be prepended as they are.
+ * @summary Fetch earlier parts of a conversation
+ */
+export declare const listEarlierItems: (thread: string, params: ListEarlierItemsParams, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<listEarlierItemsResponse>;
+export type interruptThreadResponse204 = {
+    data: void;
+    status: 204;
+};
+export type interruptThreadResponseDefault = {
+    data: Error;
+    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;
+/**
+ * Calling this on a conversation with no running turn also returns 204 rather than an error — the user pressing stop races with the turn finishing on its own, and both outcomes are the same. This operation remains available while the project is suspended or being cleaned up.
+ * @summary Interrupt a running turn
+ */
+export declare const interruptThread: (thread: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<interruptThreadResponse>;
+export type sendMessageResponse202 = {
+    data: TurnIDResponseBody;
+    status: 202;
+};
+export type sendMessageResponseDefault = {
+    data: Error;
+    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;
+/**
+ * Returns a turnId immediately without waiting for execution — a turn can run for tens of minutes. Progress arrives on the live stream the conversation document's `stream` points at, not in this response. Sending while the assistant is still working is allowed: the message is put in line and `queued` comes back true, to be read at the next step of the turn already running — so the editor should stay open rather than blocking on a busy conversation.
+ * @summary Send a message and start a turn
+ */
+export declare const sendMessage: (thread: string, sendMessageRequestBody: SendMessageRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<sendMessageResponse>;
+export type answerQuestionResponse204 = {
+    data: void;
+    status: 204;
+};
+export type answerQuestionResponseDefault = {
+    data: Error;
+    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;
+/**
+ * The question id comes from the conversation document's `wait`. An already-answered question also returns 204 — another tab may have submitted first, or the auto-answer window may have expired, and in both cases the turn has already continued with an answer.
+ * @summary Answer the assistant's questions
+ */
+export declare const answerQuestion: (thread: string, item: string, answerRequestBody: AnswerRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<answerQuestionResponse>;
+export type markThreadReadResponse204 = {
+    data: void;
+    status: 204;
+};
+export type markThreadReadResponseDefault = {
+    data: Error;
+    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;
+/**
+ * @summary Mark a conversation as read
+ */
+export declare const markThreadRead: (thread: string, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<markThreadReadResponse>;
+export type revertThreadResponse200 = {
+    data: RevertedCountResponseBody;
+    status: 200;
+};
+export type revertThreadResponseDefault = {
+    data: Error;
+    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 entry at `ordinal` and everything after it. Reverted entries stay in the transcript marked `reverted`, and ordinals are not renumbered. Returns how many were actually reverted.
+ * @summary Revert from a given point
+ */
+export declare const revertThread: (thread: string, revertRequestBody: RevertRequestBody, options?: RequestInit, fetchFn?: typeof globalThis.fetch) => Promise<revertThreadResponse>;