@todoist/automations-sdk 0.0.0-stage → 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1060 @@
+import { $ as PartialManifestInput, A as ConnectionsClient, At as AutomationVisibility, B as ListWorkspaceAutomationDraftsArgs, Bt as TriggerAutomationResponse, C as ListNotificationsArgs, D as ListConnectorActionsArgs, Dt as AutomationDraftDto, E as ConnectorsClient, Et as AutomationDraftConnectionValidationDto, F as ChatClient, Ft as DraftTestTrigger, G as WorkspaceAutomationDraftConnectionsClient, H as ListWorkspaceAutomationsArgs, Ht as ConnectionType, I as ListChatConversationsArgs, It as DraftTestTriggerSelector, J as ListAutomationsArgs, K as WorkspaceAutomationRunsClient, L as WorkspacesClient, Lt as FinalizeAutomationDraftResponse, M as DeleteConnectionOptions, Mt as DraftTestRunFailedStep, N as ListConnectionsArgs, O as ListConnectorsArgs, Ot as AutomationDraftWithValidationDto, P as getConnectionInUseError, Pt as CreateAutomationDraftConnection, Q as ListAutomationDraftsArgs, R as WorkspaceChatClient, Rt as TestAutomationDraftRequest, S as UserSettingsClient, T as PushSubscriptionsClient, Tt as AutomationDraftConnectionDto, U as WorkspaceAutomationsClient, V as WorkspaceAutomationDraftsClient, Vt as ConnectionStatus, W as WorkspaceCreateOptions, X as AutomationDraftsClient, Y as getOpenDraftConflictError, Z as CreateAutomationDraftOptions, _ as getUsageBillingTopUpRefusal, _t as GetConnectorsResponseDto, a as ListWebhookEventDeliveriesArgs, at as AutomationDraftConnectionsClient, b as isUsageBillingTopUpPlanRequiredError, c as WebhookEventSubscriptionsClient, ct as PromptNotificationStatus, d as ReadUsageSummaryArgs, dt as CursorPaginationResponse, et as getDraftNotReadyError, f as StartTopUpArgs, ft as ManifestSchema, g as UsageBillingTopUpRefusalTag, gt as ConnectorDto, h as UsageBillingTopUpRefusal, ht as TriggerType, i as CreateWebhookEventSubscriptionArgs, it as ListAutomationRunsArgs, j as CreateConnectionArgs, jt as DraftTestRunDetailDto, k as getConnectorActionError, kt as AutomationDto, l as BillingPortalUrlArgs, lt as WorkspaceDto, m as UsageBillingClient, mt as StepSchema, n as AutomationsApiOptions, nt as AutomationRunsClient, o as ListWebhookEventSubscriptionsArgs, ot as AutomationConnectionsClient, p as USAGE_BILLING_TOP_UP_REFUSAL_TAGS, pt as PartialManifestSchema, q as AutomationsClient, r as WebhookSubscriptionsClient, rt as GetAutomationRunDetailsArgs, s as UpdateWebhookEventSubscriptionArgs, st as PromptNotificationDto, t as AutomationsApi, tt as getDraftTestRequestError, u as ReadTransactionsArgs, ut as SampleAutomationDto, v as isKnownUsageBillingTopUpRefusalTag, vt as ConnectionDetailsDto, w as NotificationsClient, wt as AutomationRunDetailDto, x as isUsageBillingTopUpUnavailableError, xt as GetConnectionsResponseDto, y as isUsageBillingAccountNotFoundError, yt as ConnectionDto, z as CreateWorkspaceAutomationDraftOptions, zt as TestAutomationDraftResponse } from "./automations-api-CLcJvEjY.js";
+import { n as DEFAULT_BASE_URL, r as DEFAULT_TODOIST_BASE_URL, s as RequestOptions } from "./context-DsrXdqq8.js";
+import { a as mcpServerHost, i as describeCandidateConnection, n as ConnectionSelection, r as connectionAccountLabel, t as CandidateConnection } from "./connection-selection-C9yMkCvL.js";
+//#region ../core/dist/types/types/failure-category.types.d.ts
+declare const FAILURE_CATEGORY_REGISTRY: {
+  readonly mcp_upstream_unavailable: {
+    readonly reliabilityLabel: "Mcp Upstream Unavailable";
+  };
+  readonly mcp_client_missing: {
+    readonly reliabilityLabel: "Mcp Client Missing";
+  };
+  readonly mcp_tool_missing: {
+    readonly reliabilityLabel: "Mcp Tool Missing";
+  };
+  readonly mcp_tool_call_failed: {
+    readonly reliabilityLabel: "Mcp Tool Call Failed";
+  };
+  readonly llm_schema_validation: {
+    readonly reliabilityLabel: "Llm Schema Validation";
+  };
+  readonly llm_empty_response: {
+    readonly reliabilityLabel: "Llm Empty Response";
+  };
+  readonly llm_provider_error: {
+    readonly reliabilityLabel: "Llm Provider Error";
+  };
+  readonly prompt_too_large: {
+    readonly reliabilityLabel: "Prompt Too Large";
+  };
+  readonly json_parse_error: {
+    readonly reliabilityLabel: "Json Parse Error";
+  };
+  readonly code_execution_error: {
+    readonly reliabilityLabel: "Code Execution Error";
+  };
+  readonly code_generation_error: {
+    readonly reliabilityLabel: "Code Generation Error";
+  };
+  readonly step_execution_error: {
+    readonly reliabilityLabel: "Step Execution Error";
+  };
+  readonly step_failure_pattern: {
+    readonly reliabilityLabel: "Step Failure Pattern";
+  };
+  readonly schema_validation: {
+    readonly reliabilityLabel: "Schema Validation";
+  };
+  readonly template_variable_error: {
+    readonly reliabilityLabel: "Template Variable Error";
+  };
+  readonly invalid_configuration: {
+    readonly reliabilityLabel: "Invalid Configuration";
+  };
+  readonly invalid_manifest: {
+    readonly reliabilityLabel: "Invalid Manifest";
+  };
+  readonly automation_not_found: {
+    readonly reliabilityLabel: "Automation Not Found";
+  };
+  readonly timeout: {
+    readonly reliabilityLabel: "Timeout";
+  };
+  readonly runtime_error: {
+    readonly reliabilityLabel: "Runtime Error";
+  };
+  readonly billing_unavailable: {
+    readonly reliabilityLabel: "Billing Unavailable";
+  };
+  readonly unknown: {
+    readonly reliabilityLabel: "Unknown";
+  };
+};
+type FailureCategory = keyof typeof FAILURE_CATEGORY_REGISTRY;
+/** Persisted authorization denials are skipped runs, not failures. */
+declare const SKIP_CATEGORIES: readonly ["insufficient_credit", "temporarily_unavailable", "plan_required", "billing_paused", "no_billing_account"];
+type SkipCategory = (typeof SKIP_CATEGORIES)[number];
+type RunOutcomeCategory = FailureCategory | SkipCategory;
+//#endregion
+//#region src/errors/request-error.d.ts
+/**
+ * A request that never produced a response: the network was unreachable, or
+ * the browser refused to expose a cross-origin response to the page. There is
+ * no status or body to read, so callers cannot classify these by status code.
+ */
+export declare class AutomationsNetworkError extends Error {
+  constructor(message: string, cause: unknown);
+}
+export declare class AutomationsRequestError extends Error {
+  readonly httpStatusCode: number;
+  readonly responseData: unknown;
+  /**
+   * The `WWW-Authenticate` challenge the response carried, verbatim. Undefined
+   * when it carried none — and in a browser unless the header is listed in
+   * `Access-Control-Expose-Headers`, which is why callers must still work
+   * without it.
+   *
+   * A 403 with a challenge is a refusal of the grant. A 403 without one is a
+   * refusal of something else — a membership, a plan, a waiting list — which
+   * authorizing again cannot fix, so the two must stay distinguishable.
+   */
+  readonly authChallenge: string | undefined;
+  /**
+   * The scope the route asked for, read out of {@link authChallenge}. Undefined
+   * when there was no challenge, and also when there was one that named no
+   * scope: a challenge can say the grant falls short without saying of what.
+   */
+  readonly requiredScope: string | undefined;
+  /**
+   * The `X-Request-Id` the response carried, which the backend logs the request
+   * under. Undefined in a browser unless the header is exposed by CORS.
+   */
+  readonly requestId: string | undefined;
+  constructor(message: string, httpStatusCode: number, responseData: unknown, authChallenge?: string, requestId?: string);
+  isAuthError(): boolean;
+}
+/**
+ * Whether a challenge blames the grant rather than the credential. Only these
+ * are worth answering by authorizing again; every other 403 has its own reason
+ * and its own message, which the caller should show instead of guessing.
+ */
+export declare function isInsufficientScopeChallenge(header: string | null | undefined): boolean;
+//#endregion
+//#region src/summaries/automation-summary.d.ts
+type AutomationConnectionSummary = Pick<ConnectionDetailsDto, 'id' | 'name' | 'connectorId' | 'capabilities' | 'status' | 'createdAt'>;
+type AutomationSummary = Omit<AutomationDto, 'connections'> & {
+  readonly connections: readonly AutomationConnectionSummary[];
+};
+/** Removes provider identity and setup metadata from an automation API response. */
+export declare function summarizeAutomation(automation: AutomationDto): AutomationSummary;
+export declare function summarizeAutomationPage(page: CursorPaginationResponse<AutomationDto>): CursorPaginationResponse<AutomationSummary>;
+//#endregion
+//#region src/links/automation-url.d.ts
+/**
+ * The automation's page in the web app at `appUrl`: `/<id>` for a personal
+ * automation and `/<workspaceId>/<id>` for a workspace one, as the app routes them.
+ */
+export declare function getAutomationUrl(appUrl: string, automation: Pick<AutomationDto, 'id' | 'workspaceId'>): string;
+//#endregion
+//#region src/summaries/run-summary.d.ts
+type RunSummary = ReturnType<typeof summarizeRun>;
+/** Selects the failure-focused fields needed for routine run diagnostics. */
+export declare function summarizeRun(run: AutomationRunDetailDto): {
+  id: string;
+  automationId: string;
+  status: "pending" | "running" | "completed" | "cancelled" | "data-expired" | "failed" | "skipped";
+  createdAt: string;
+  updatedAt: string;
+  failureCategory: RunOutcomeCategory | null;
+  failureReason: string | null;
+  result: {
+    type: "markdown";
+    text: string;
+  } | {
+    type: "markdown";
+    text: string;
+  } | {
+    type: "markdown";
+    text: string;
+  } | {
+    type: "markdown";
+    text: string;
+  } | {
+    type: "markdown";
+    text: string;
+  } | {
+    type: "markdown";
+    text: string;
+  } | {
+    type: "markdown";
+    text: string;
+  } | null;
+  temporalUrl: string | null | undefined;
+  triggeredBy: string | null;
+  steps: {
+    stepId: string;
+    type: string;
+    description: string;
+    status: "pending" | "running" | "completed" | "cancelled" | "failed" | "skipped";
+    startedAt: string | undefined;
+    completedAt: string | undefined;
+    error: string | undefined;
+    toolCalls: {
+      id: string;
+      name: string;
+      argumentKeys: string[];
+      hasResult: boolean;
+      hasError: boolean;
+      resultPreview: string | undefined;
+      errorPreview: string | undefined;
+      timestamp: string;
+    }[] | undefined;
+  }[];
+};
+//#endregion
+//#region src/summaries/draft-test-run-summary.d.ts
+type DraftTestRunSummary = ReturnType<typeof summarizeDraftTestRun>;
+/** The run-summary fields for a draft's test run, plus what failed and that calls were mocked. */
+export declare function summarizeDraftTestRun(run: DraftTestRunDetailDto): {
+  id: string;
+  draftId: string;
+  automationId: string | null;
+  status: "pending" | "running" | "completed" | "cancelled" | "data-expired" | "failed" | "skipped";
+  connectorCalls: "mocked";
+  createdAt: string;
+  updatedAt: string;
+  failureCategory: RunOutcomeCategory | null;
+  failureReason: string | null;
+  failedStep: {
+    stepId: string;
+    description: string;
+    error: string | null;
+  } | {
+    stepId: string;
+    description: string;
+    error: string | null;
+  } | {
+    stepId: string;
+    description: string;
+    error: string | null;
+  } | {
+    stepId: string;
+    description: string;
+    error: string | null;
+  } | {
+    stepId: string;
+    description: string;
+    error: string | null;
+  } | {
+    stepId: string;
+    description: string;
+    error: string | null;
+  } | {
+    stepId: string;
+    description: string;
+    error: string | null;
+  } | null;
+  result: {
+    type: "markdown";
+    text: string;
+  } | {
+    type: "markdown";
+    text: string;
+  } | {
+    type: "markdown";
+    text: string;
+  } | {
+    type: "markdown";
+    text: string;
+  } | {
+    type: "markdown";
+    text: string;
+  } | {
+    type: "markdown";
+    text: string;
+  } | {
+    type: "markdown";
+    text: string;
+  } | null;
+  temporalUrl: string | null | undefined;
+  steps: {
+    stepId: string;
+    type: string;
+    description: string;
+    status: "pending" | "running" | "completed" | "cancelled" | "failed" | "skipped";
+    startedAt: string | undefined;
+    completedAt: string | undefined;
+    error: string | undefined;
+    toolCalls: {
+      id: string;
+      name: string;
+      argumentKeys: string[];
+      hasResult: boolean;
+      hasError: boolean;
+      resultPreview: string | undefined;
+      errorPreview: string | undefined;
+      timestamp: string;
+    }[] | undefined;
+  }[];
+};
+//#endregion
+//#region src/summaries/list-summaries.d.ts
+/**
+ * List shapes for automations and drafts: identity, state and triggers, without
+ * the manifest body. A manifest is untyped on the DTO (a draft can hold a
+ * partial one), so every field is read defensively and a nameless manifest is
+ * reported as such rather than failing the whole list.
+ */
+type AutomationListItem = ReturnType<typeof summarizeAutomationListItem>;
+type DraftListItem = ReturnType<typeof summarizeDraftListItem>;
+type TriggerListItem = {
+  readonly type: TriggerType;
+  readonly schedule?: {
+    interval?: string;
+    cron?: string;
+    timezone?: string;
+  };
+  readonly event?: string;
+};
+type ManifestMetadata = {
+  name?: string;
+  description?: string;
+};
+/** The name and description of an automation, or undefined when it has no manifest. */
+export declare function readManifestMetadata(dto: AutomationDto): ManifestMetadata | undefined;
+/** The type of the trigger that starts an automation, or undefined when it has none. */
+export declare function readPrimaryTriggerType(dto: AutomationDto): TriggerType | undefined;
+/** Whether a run can be started by hand, as the app's Run now allows; an api run starts with empty input. */
+export declare function isManuallyTriggerable(triggerType: TriggerType | undefined): boolean;
+/**
+ * Reduces an automation to its list shape. Connections keep only their
+ * identity and status, so provider identity and setup metadata never leave
+ * with a listing.
+ */
+export declare function summarizeAutomationListItem(dto: AutomationDto): {
+  triggers: TriggerListItem[];
+  connections: {
+    status?: "error" | "pending" | "authorized" | "expired" | undefined;
+    id: string;
+    name: string;
+    connectorId: string;
+  }[];
+  updatedAt: string;
+  disabledReason?: "creator-left-workspace" | "workspace-plan-lapsed" | undefined;
+  updatedBy?: string | undefined;
+  createdBy?: string | undefined;
+  workspaceId?: string | undefined;
+  connectionStatus: "ready" | "almost-ready" | "not-ready";
+  visibility: "private" | "workspace";
+  isOwner: boolean;
+  skipReason?: string | undefined;
+  failureReason?: string | undefined;
+  lastRun?: string | undefined;
+  enabled: boolean;
+  status: "pending" | "running" | "completed" | "cancelled" | "failed" | "skipped";
+  description?: string | undefined;
+  id: string;
+  name: string;
+};
+export declare function summarizeAutomationListPage(page: CursorPaginationResponse<AutomationDto>): CursorPaginationResponse<AutomationListItem>;
+/** Reduces a draft to its list shape: identity and links, without the partial manifest. */
+export declare function summarizeDraftListItem(dto: AutomationDraftDto): {
+  createdAt: string;
+  updatedAt: string;
+  workspaceId?: string | undefined;
+  conversationId?: string | undefined;
+  automationId?: string | undefined;
+  isComplete: boolean;
+  description?: string | undefined;
+  name?: string | undefined;
+  id: string;
+};
+export declare function summarizeDraftListPage(page: CursorPaginationResponse<AutomationDraftDto>): CursorPaginationResponse<DraftListItem>;
+//#endregion
+//#region src/connectors/connector-catalog.d.ts
+/** The capabilities a connector can offer. The `api` connection type is internal and never listed. */
+export declare const CONNECTOR_CAPABILITIES: readonly ["mcp", "trigger"];
+type ConnectorCapability = (typeof CONNECTOR_CAPABILITIES)[number];
+/** A connection as it appears under a connector: enough to tell what is linked and whether it works. */
+type ConnectorConnectionSummary = Pick<ConnectionDto, 'id' | 'status' | 'capabilities' | 'createdAt' | 'mcpServerUrl'>;
+type EnrichedConnector = ConnectorDto & {
+  readonly connections?: readonly ConnectorConnectionSummary[];
+};
+type ConnectorListOptions = {
+  readonly query?: string;
+  readonly capability?: ConnectorCapability;
+  readonly connectionStatus?: ConnectionStatus;
+  /** Whether to fetch the user's connections and join them onto each connector. */
+  readonly connections: boolean;
+  readonly withoutConnections?: boolean;
+};
+type ConnectorListResult = {
+  readonly connectionsIncluded: boolean;
+  readonly data: readonly EnrichedConnector[];
+};
+export declare class ConnectorNotFoundError extends Error {
+  readonly connectorId: string;
+  constructor(connectorId: string);
+}
+/**
+ * Walks the connector catalog one full page at a time, guarding against a
+ * server that hands back a cursor it already served.
+ */
+export declare function iterateConnectorPages(api: AutomationsApi, query: string | undefined, options?: RequestOptions): AsyncGenerator<GetConnectorsResponseDto>;
+/**
+ * Finds one connector by id, stopping at the first page that has it. The API
+ * has no single-connector route and its search matches names, not ids.
+ */
+export declare function findConnector(api: AutomationsApi, connectorId: string, options?: RequestOptions): Promise<ConnectorDto>;
+/**
+ * Fetches the connector catalog, optionally joins the user's connections, and
+ * applies the connector filters. Callers validate that the filter combination
+ * makes sense; a connection filter with `connections: false` is silently a
+ * no-op here.
+ */
+export declare function listConnectors(api: AutomationsApi, options: ConnectorListOptions, requestOptions?: RequestOptions): Promise<ConnectorListResult>;
+/** The capabilities a connector offers, in the order the CLI prints them. */
+export declare function getConnectorCapabilities(connector: ConnectorDto): ConnectorCapability[];
+export declare function connectorSupportsCapability(connector: ConnectorDto, capability: ConnectorCapability | undefined): boolean;
+/** Adds lightweight user connection summaries to one catalog connector. */
+export declare function enrichConnector(connector: ConnectorDto, connections: readonly ConnectionDto[]): EnrichedConnector;
+export declare function groupConnectionsByConnector(connections: readonly ConnectionDto[]): ReadonlyMap<string, ConnectionDto[]>;
+/**
+ * Whether a connector passes the connection filters. `withoutConnections`
+ * wants none; `connectionStatus` wants one in that state which, when a
+ * capability filter is on too, also covers that capability.
+ */
+export declare function matchesConnectionFilters(connector: EnrichedConnector, options: Pick<ConnectorListOptions, 'capability' | 'connectionStatus' | 'withoutConnections'>): boolean;
+//#endregion
+//#region src/connectors/connection-usage.d.ts
+/**
+ * The published personal automations bound to one exact connection. The API
+ * has no connection filter on the automation list, so this walks every page
+ * and keeps only the matches, guarding against a repeated cursor the way the
+ * connector catalog does.
+ */
+export declare function findAutomationsUsingConnection(api: AutomationsApi, connectionId: string, options?: RequestOptions): Promise<AutomationDto[]>;
+//#endregion
+//#region src/templates/template-catalog.d.ts
+/**
+ * Templates are the curated sample automations: ready-made manifests to install or start
+ * a draft from. A summary says everything about one except the manifest body, which is
+ * what keeps the whole catalogue small enough to list.
+ */
+type TemplateTrigger = TriggerListItem & {
+  /** When it runs, in words. */
+  readonly description: string;
+  /** The connector whose event starts it, for a webhook trigger. */
+  readonly connectorId?: string;
+};
+type TemplateConnector = {
+  readonly id: string;
+  readonly name: string;
+  /** "mcp": a step calls it; "trigger": its events start the automation. */
+  readonly usedFor: ConnectorCapability[];
+};
+type TemplateStep = {
+  readonly id: string;
+  readonly type: StepSchema['type'];
+  readonly title?: string;
+  readonly description: string;
+  /** The tools the step may call, by connector. */
+  readonly tools?: Record<string, string[]>;
+};
+type TemplateSummary = {
+  readonly id: string;
+  readonly name: string;
+  readonly description: string;
+  readonly staffPick: boolean;
+  /** Whether it can be installed as it is, without a draft. */
+  readonly oneClickInstall: boolean;
+  readonly triggers: TemplateTrigger[];
+  readonly connectors: TemplateConnector[];
+  readonly steps: TemplateStep[];
+};
+type TemplateDetail = TemplateSummary & {
+  /** Curated guidance on what to keep and what to customise when adapting it. */
+  readonly instructions?: string;
+  readonly manifest: ManifestSchema;
+};
+type TemplateFilters = {
+  /** Matches the name, the description and the names of the connectors it uses. */
+  readonly query?: string;
+  readonly connectorId?: string;
+  readonly triggerType?: TriggerType;
+  readonly staffPick?: boolean;
+};
+export declare class TemplateNotFoundError extends Error {
+  readonly templateId: string;
+  constructor(templateId: string);
+}
+/** Thrown when a template must be adapted in a draft rather than installed as it is. */
+export declare class TemplateNotInstallableError extends Error {
+  readonly templateId: string;
+  constructor(templateId: string);
+}
+/** Lists the published templates as summaries, narrowed by the filters. */
+export declare function listTemplates(api: AutomationsApi, filters?: TemplateFilters, options?: RequestOptions): Promise<TemplateSummary[]>;
+/** One template in full: its summary, its authoring instructions and its manifest. */
+export declare function getTemplate(api: AutomationsApi, templateId: string, options?: RequestOptions): Promise<TemplateDetail>;
+/**
+ * Publishes a template as it is, into the personal space (`workspaceId` null or absent) or a
+ * workspace, where `visibility` defaults to team-visible. The automation stays disabled until
+ * the connections it needs are ready. Throws `TemplateNotInstallableError` for a template
+ * without one-click install, which needs a draft instead.
+ */
+export declare function installTemplate(api: AutomationsApi, { templateId, workspaceId, visibility }: {
+  templateId: string;
+  workspaceId?: string | null;
+  visibility?: AutomationVisibility;
+}, options?: RequestOptions): Promise<AutomationDto>;
+export declare function summarizeTemplate(sample: SampleAutomationDto): TemplateSummary;
+//#endregion
+//#region src/workspaces/creation-scope.d.ts
+/** Where something new is created. */
+type CreationScope = {
+  /** The workspace, or `null` for the personal space. */
+  readonly workspaceId: string | null;
+  /**
+   * The visibility a new workspace automation starts with. Only set when the
+   * user's default space chose the workspace; absent means team-visible.
+   */
+  readonly visibility?: AutomationVisibility;
+  /** Whether the caller named the space or the user's default space chose it. */
+  readonly source: 'explicit' | 'default';
+  /** The workspace's name, for messages. Absent when the workspace list could not be read. */
+  readonly workspaceName?: string;
+};
+/** Workspace names by id, for messages that name a workspace. */
+export declare function workspaceNamesById(workspaces: readonly WorkspaceDto[]): Readonly<Record<string, string>>;
+/**
+ * The names of the caller's workspaces, by id. Empty when the list cannot be read,
+ * so a message that names a workspace falls back to its id instead of failing.
+ */
+export declare function readWorkspaceNames(api: AutomationsApi, options?: RequestOptions): Promise<Readonly<Record<string, string>>>;
+/**
+ * Where a new automation, draft or conversation goes. `explicit` is the space the
+ * caller named: a workspace id, or `null` for personal. Left `undefined`, the
+ * user's default space decides, which lands a workspace automation with the
+ * visibility the user chose for it (private unless they said otherwise).
+ */
+export declare function resolveCreationScope(api: AutomationsApi, explicit: string | null | undefined, options?: RequestOptions): Promise<CreationScope>;
+//#endregion
+//#region src/drafts/draft-api.d.ts
+/**
+ * The draft routes bound to one space, so a caller dispatches on personal versus
+ * workspace once instead of at every call.
+ */
+type DraftApi = {
+  /** The workspace the routes are bound to, or null for the personal space. */
+  readonly workspaceId: string | null;
+  readonly get: (draftId: string) => Promise<AutomationDraftWithValidationDto>;
+  readonly create: (manifest: PartialManifestSchema) => Promise<AutomationDraftWithValidationDto>;
+  readonly update: (draftId: string, manifest: PartialManifestSchema) => Promise<AutomationDraftWithValidationDto>;
+  readonly createAutomationDraft: (automationId: string) => Promise<{
+    draft: AutomationDraftDto;
+  }>;
+  /** A new draft holding a template's manifest, translated into the user's language. */
+  readonly createFromTemplate: (templateId: string) => Promise<AutomationDraftWithValidationDto>;
+  readonly upsertConnection: (draftId: string, body: CreateAutomationDraftConnection) => Promise<AutomationDraftConnectionDto>;
+  readonly getConnectionStatus: (draftId: string) => Promise<AutomationDraftConnectionValidationDto>;
+  /** The caller's own connections, which are not scoped to a space. */
+  readonly listConnections: (args: ListConnectionsArgs) => Promise<GetConnectionsResponseDto>;
+  readonly finalize: (draftId: string) => Promise<FinalizeAutomationDraftResponse>;
+  readonly getAutomation: (automationId: string) => Promise<AutomationDto>;
+  readonly test: (draftId: string, request: TestAutomationDraftRequest) => Promise<TestAutomationDraftResponse>;
+  readonly getTestRun: (draftId: string, runId: string, args?: {
+    includeGeneratedCode?: boolean;
+    includeToolCallPreviews?: boolean;
+  },
+  /** Replaces the bound signal for this request, to bound it more tightly. */
+  requestSignal?: AbortSignal) => Promise<DraftTestRunDetailDto>;
+};
+/**
+ * Binds the draft routes to the personal space (`null`) or a workspace. In a workspace,
+ * `visibility` is what a new automation published from a draft created through this
+ * binding starts with; absent means team-visible.
+ */
+export declare function bindDraftApi(api: AutomationsApi, workspaceId: string | null, { signal, visibility }?: {
+  signal?: AbortSignal;
+  visibility?: AutomationVisibility;
+}): DraftApi;
+//#endregion
+//#region src/drafts/draft-changes.d.ts
+/** What a draft will become when published. */
+type DraftTarget = {
+  readonly kind: 'new';
+} | {
+  readonly kind: 'automation';
+  readonly automationId: string;
+};
+type DraftChangeResult = AutomationDraftWithValidationDto & {
+  readonly action: 'created' | 'updated';
+  readonly target: DraftTarget;
+};
+/**
+ * Creates a draft from a manifest. With `automationId` the draft edits that
+ * automation: the API opens it seeded from the published manifest, then the
+ * given manifest replaces that seed, so publishing later updates the automation
+ * in place.
+ */
+export declare function createDraft(draftApi: DraftApi, { manifest, automationId }: {
+  manifest: unknown;
+  automationId?: string;
+}): Promise<DraftChangeResult>;
+/**
+ * Creates a new draft from a template, by id: the API copies the template's manifest, so
+ * the caller never holds it. Throws `TemplateNotFoundError` for an unknown template.
+ */
+export declare function createDraftFromTemplate(draftApi: DraftApi, { templateId }: {
+  templateId: string;
+}): Promise<DraftChangeResult>;
+/** Replaces a draft's manifest. */
+export declare function updateDraft(draftApi: DraftApi, { draftId, manifest }: {
+  draftId: string;
+  manifest: unknown;
+}): Promise<DraftChangeResult>;
+/**
+ * Checks that a value is at least a partial manifest before it is sent anywhere,
+ * so a malformed one fails with the field paths rather than as an API 400.
+ */
+export declare function parsePartialManifest(value: unknown): PartialManifestSchema;
+//#endregion
+//#region src/drafts/connect-draft.d.ts
+type BoundConnection = {
+  readonly connectorId: string;
+  readonly connectionType: ConnectionType;
+  readonly connectionId: string;
+  /** `explicit` was chosen by the caller; `auto` was the only authorised connection. */
+  readonly mode: 'explicit' | 'auto';
+};
+type UnresolvedConnection = {
+  readonly connectorId: string;
+  readonly connectionType: ConnectionType;
+  readonly reason: 'no_connection' | 'multiple_connections';
+  /** The authorised connections to choose from when there is more than one. */
+  readonly candidateConnections: readonly CandidateConnection[];
+  /** @deprecated The ids of `candidateConnections`. */
+  readonly candidateConnectionIds: readonly string[];
+};
+type DraftConnectResult = {
+  readonly action: 'connected';
+  readonly draftId: string;
+  readonly bound: readonly BoundConnection[];
+  readonly unresolved: readonly UnresolvedConnection[];
+  readonly isValid: boolean;
+  readonly missing: AutomationDraftConnectionValidationDto['missing'];
+};
+/**
+ * Binds connections to a draft. Explicit selections are applied as given; with
+ * `auto`, every required slot with no binding at all is filled when the user has
+ * exactly one authorised connection for it, the same rule the chat agent applies.
+ * A slot that is bound but expired or unauthorised is left alone, since replacing
+ * the account is the caller's decision; it stays in `missing`. Slots `auto`
+ * cannot settle come back as `unresolved`.
+ */
+export declare function connectDraft(draftApi: DraftApi, { draftId, selections, auto }: {
+  draftId: string;
+  selections: readonly ConnectionSelection[];
+  auto: boolean;
+}): Promise<DraftConnectResult>;
+//#endregion
+//#region src/questions/ask-steps.d.ts
+/** Where an automation's runs stop to ask the user, as its manifest declares it. */
+type AskStepSummary = {
+  readonly stepId: string;
+  readonly question: string;
+  readonly options: readonly {
+    readonly label: string;
+    readonly endsRun: boolean;
+  }[];
+  /** How long a run waits for an answer before it stops, such as `1w`. */
+  readonly expiresAfter: string;
+};
+/**
+ * The ask steps of a manifest, in step order. Reads a partial manifest as
+ * readily as a complete one, skipping any ask step too incomplete to describe
+ * (no id or a blank question) and any option with a blank label.
+ */
+export declare function describeAskSteps(manifest: unknown): AskStepSummary[];
+//#endregion
+//#region src/drafts/manifest-diff.d.ts
+/**
+ * A step-level summary of how one manifest differs from another: which top-level
+ * properties changed, which steps were added, removed or changed (and where inside
+ * each changed step), and whether the steps they share run in a different order.
+ * Steps are matched by `id`, so moving a step reports as `reordered`, not as a
+ * removal plus an addition.
+ */
+type ManifestDiff = {
+  readonly changedProperties: readonly string[];
+  readonly steps: {
+    readonly added: readonly string[];
+    readonly removed: readonly string[];
+    readonly changed: readonly string[];
+    /** For each changed step, the paths inside it that differ, such as `input.channel` or `tools[1]`. */
+    readonly changedFields: Readonly<Record<string, readonly string[]>>;
+    /** Steps run in order, so a reshuffle of unchanged steps still changes behaviour. */
+    readonly reordered: boolean;
+  };
+  readonly isEmpty: boolean;
+};
+export declare function diffManifests(before: unknown, after: unknown): ManifestDiff;
+//#endregion
+//#region src/drafts/submitted-manifest.d.ts
+/**
+ * A manifest the way the API hands a published one back: parsed as the API
+ * parses a draft it saves, which fills in defaults such as `overlap` and drops
+ * keys the schema does not know, then migrated, as the API migrates a published
+ * manifest on every read. A manifest that does not parse is only migrated.
+ */
+export declare function normaliseManifest(manifest: unknown): unknown;
+//#endregion
+//#region src/drafts/publish-draft.d.ts
+/** Everything a caller should know before deciding to publish. */
+type PublishSummary = {
+  readonly draftId: string;
+  readonly name: string;
+  readonly scope: {
+    readonly kind: 'personal';
+  } | {
+    readonly kind: 'workspace';
+    readonly workspaceId: string;
+    /** What the automation will be once published; an edit keeps what it has. */
+    readonly visibility: AutomationDto['visibility'];
+  };
+  readonly target: DraftTarget;
+  /** Whether it will be enabled once published: a new one starts enabled, an edit keeps its state. */
+  readonly enabled: boolean;
+  readonly validation: {
+    readonly state: 'incomplete' | 'ready';
+    readonly issues: readonly string[];
+  };
+  readonly connections: {
+    readonly isValid: boolean;
+    readonly connected: readonly Pick<AutomationDraftConnectionDto, 'connectorId' | 'connectionType' | 'connectionId'>[];
+    readonly missing: AutomationDraftConnectionValidationDto['missing'];
+  };
+  /** The schedule in words, or null when the draft runs on something else. */
+  readonly schedule: string | null;
+  /**
+   * Where its runs will stop to ask the user, so they can be told before it
+   * goes live that it will wait on them.
+   */
+  readonly questions: readonly AskStepSummary[];
+  /** How the draft differs from the published automation; null for a new one. */
+  readonly diff: ManifestDiff | null;
+  /** How the saved draft differs from the manifest the caller submitted; null when none was given. */
+  readonly submittedDiff: ManifestDiff | null;
+};
+/**
+ * What the published manifest was compared with: the manifest the caller
+ * submitted, which also catches what the API changed while saving it, or else
+ * the saved draft.
+ */
+type VerificationBasis = 'submitted' | 'draft';
+/**
+ * The published manifest compared with `against`. `unavailable` means reading
+ * the automation back failed after the publish succeeded.
+ */
+type PublishVerification = {
+  readonly status: 'matched';
+  readonly against: VerificationBasis;
+} | {
+  readonly status: 'mismatched';
+  readonly against: VerificationBasis;
+  readonly mismatch: ManifestDiff;
+} | {
+  readonly status: 'unavailable';
+  readonly reason: string;
+};
+type PublishResult = {
+  readonly action: 'publish_preview';
+  readonly summary: PublishSummary;
+} | {
+  readonly action: 'published';
+  readonly summary: PublishSummary;
+  readonly automation: AutomationDto;
+  readonly verification: PublishVerification;
+};
+/**
+ * Publishes a draft, or previews what publishing would do.
+ *
+ * The preview gathers what the API would otherwise only reveal by failing:
+ * validation issues, unbound connections, the schedule in words and, for an
+ * edit draft, how it differs from the published automation. A confirmed publish
+ * lets the API be the judge, then reads the automation back and checks that
+ * what was published is what the draft held, or what `submittedManifest` held
+ * when the caller passes the manifest it created or updated the draft with.
+ * Once finalize succeeds the draft is gone, so a failed read-back is reported
+ * as unverified, never as a failure.
+ */
+export declare function publishDraft(draftApi: DraftApi, { draftId, confirmed, submittedManifest }: {
+  draftId: string;
+  confirmed: boolean;
+  submittedManifest?: unknown;
+}): Promise<PublishResult>;
+/**
+ * What publishing a draft would do, with the draft as it was read for it. With
+ * `submittedManifest`, it also says how the saved draft differs from it.
+ */
+export declare function previewPublish(draftApi: DraftApi, draftId: string, submittedManifest?: unknown): Promise<{
+  summary: PublishSummary;
+  detail: AutomationDraftWithValidationDto;
+}>;
+/** The manifest's schedule trigger in words, or null when it has none. */
+export declare function describeSchedule(manifest: unknown): string | null;
+//#endregion
+//#region src/runs/poll-until-closed.d.ts
+/** How a wait on a started run polls it, and for how long. */
+type PollOptions<T> = {
+  readonly timeoutMs: number;
+  readonly pollIntervalsMs?: {
+    readonly first: number;
+    readonly max: number;
+  };
+  readonly requestGraceMs?: number;
+  /** Sees each state the run is read in, while it is still being waited for. */
+  readonly onPoll?: (run: T) => void;
+  /**
+   * Ends the wait early on a run that is still open but will not move until
+   * someone acts, such as one parked on a question. Asked after each read
+   * that finds the run open.
+   */
+  readonly isParked?: (run: T, requestSignal: AbortSignal) => Promise<boolean>;
+  readonly signal: AbortSignal;
+};
+//#endregion
+//#region src/drafts/draft-test.d.ts
+export declare const DRAFT_TEST_OUTCOMES: readonly ["passed", "failed", "skipped", "cancelled", "timed_out"];
+/** How a waited-for test run ended, from the caller's point of view. */
+type DraftTestOutcome = (typeof DRAFT_TEST_OUTCOMES)[number];
+/** A test run the API accepted, which goes on running whether or not anyone waits for it. */
+type DraftTestStarted = {
+  readonly draftId: string;
+  readonly testRunId: string;
+  readonly trigger: DraftTestTrigger;
+  readonly connectorCalls: 'mocked';
+  readonly status: TestAutomationDraftResponse['status'];
+};
+type DraftTestFinished = {
+  readonly outcome: DraftTestOutcome;
+  readonly status: DraftTestRunDetailDto['status'];
+  readonly failedStep: DraftTestRunFailedStep | null;
+  /** The failed step's error, else why the run failed or was skipped. */
+  readonly error: string | null;
+  readonly result: DraftTestRunDetailDto['result'];
+};
+type DraftTestWaitOptions = Omit<PollOptions<DraftTestRunDetailDto>, 'isParked'>;
+/**
+ * Starts a draft test run. The API's refusal to start one is rethrown as it
+ * came; `getDraftTestRequestError` reads its code.
+ */
+export declare function startDraftTest(draftApi: DraftApi, { draftId, request }: {
+  draftId: string;
+  request: TestAutomationDraftRequest;
+}): Promise<DraftTestStarted>;
+/**
+ * Polls a started test run until it ends or the timeout passes. A run that
+ * ends without passing is still a result, not an error: the caller decides
+ * what it means.
+ */
+export declare function waitForDraftTest(draftApi: DraftApi, { draftId, testRunId }: {
+  draftId: string;
+  testRunId: string;
+}, options: DraftTestWaitOptions): Promise<DraftTestFinished>;
+/** A number, or a string of digits, picks a trigger by position; any other string is a webhook event. */
+export declare function toDraftTestTriggerSelector(value: number | string): DraftTestTriggerSelector;
+//#endregion
+//#region src/questions/questions.d.ts
+/** One way to answer a question, and whether choosing it ends the run that asked. */
+type QuestionOption = {
+  readonly label: string;
+  readonly value: string;
+  readonly endsRun: boolean;
+};
+/** A question an automation's `ask` step put to the user, and its answer once given. */
+type QuestionSummary = {
+  readonly id: string;
+  readonly status: PromptNotificationStatus;
+  readonly question: string;
+  readonly details: string | null;
+  readonly options: readonly QuestionOption[];
+  /** The value of the chosen option, once answered. */
+  readonly answer: string | null;
+  readonly automationId: string | null;
+  readonly workspaceId: string | null;
+  readonly runId: string | null;
+  readonly stepId: string | null;
+  readonly askedAt: string;
+  /** When an unanswered question stops its run. */
+  readonly expiresAt: string | null;
+  readonly answeredAt: string | null;
+};
+type QuestionErrorCode =
+/** The id names a notification that is not a question. */
+'not_a_question' |
+/** Nobody answered in time, so the run that asked has stopped. */
+'expired' |
+/** The question was answered with a different option. */
+'already_answered' |
+/** The choice matches none of the question's options. */
+'unknown_option' |
+/** The choice matches more than one option's label. */
+'ambiguous_option';
+/** A question that cannot take the answer given, with the reason in `code`. */
+export declare class QuestionError extends Error {
+  readonly code: QuestionErrorCode;
+  readonly questionId: string;
+  constructor(code: QuestionErrorCode, message: string, questionId: string);
+}
+export declare function summarizeQuestion(prompt: PromptNotificationDto): QuestionSummary;
+/**
+ * Every question still waiting on the user, oldest first, across both spaces.
+ * Questions belong to the user rather than a space, so there is no workspace
+ * binding; `automationId` narrows the list to one automation.
+ */
+export declare function listPendingQuestions(api: AutomationsApi, { automationId, signal }?: {
+  automationId?: string;
+  signal?: AbortSignal;
+}): Promise<QuestionSummary[]>;
+export declare function getQuestion(api: AutomationsApi, questionId: string, { signal }?: {
+  signal?: AbortSignal;
+}): Promise<QuestionSummary>;
+/** A run as far as finding its question goes: whether it is running, and its latest step. */
+type QuestionRun = {
+  readonly id: string;
+  readonly automationId: string;
+  readonly status: string;
+  readonly steps: readonly {
+    readonly type: string;
+  }[];
+};
+/**
+ * The question a run is parked on, or null when it is not waiting. A parked run
+ * is running and its latest step is the ask, so any other run costs no request.
+ */
+export declare function findRunQuestion(api: AutomationsApi, run: QuestionRun, { signal }?: {
+  signal?: AbortSignal;
+}): Promise<QuestionSummary | null>;
+/**
+ * Like {@link findRunQuestion}, but null when the grant does not let the caller
+ * read questions, for a caller that only adds the question to a run it already
+ * has. Any other failure still throws, so an outage never reads as "not waiting".
+ */
+export declare function findRunQuestionIfReadable(api: AutomationsApi, run: QuestionRun, { signal }?: {
+  signal?: AbortSignal;
+}): Promise<QuestionSummary | null>;
+/** Whether a question request was refused by the grant, as from a login without the notifications scope. */
+export declare function isQuestionReadRefused(error: unknown): boolean;
+/**
+ * The option `choice` picks: its exact value, or failing that the one option
+ * whose value or label matches ignoring case, so both "approve" and "Approve"
+ * work.
+ */
+export declare function findQuestionOption(question: QuestionSummary, choice: string): QuestionOption;
+/**
+ * The option an answer of `choice` would record, or a `QuestionError` when the
+ * question cannot take it. Repeating the answer already given is allowed: the
+ * API treats it as a retry and makes sure the run has received it.
+ */
+export declare function prepareAnswer(question: QuestionSummary, choice: string): QuestionOption;
+/** Records `choice` as the answer, which lets the parked run continue or stop. */
+export declare function answerQuestion(api: AutomationsApi, questionId: string, choice: string, { signal }?: {
+  signal?: AbortSignal;
+}): Promise<{
+  question: QuestionSummary;
+  chosen: QuestionOption;
+}>;
+//#endregion
+//#region src/runs/run-api.d.ts
+/**
+ * The routes for starting and following an automation's runs, bound to one
+ * space so a caller dispatches on personal versus workspace once.
+ */
+type RunApi = {
+  /** The workspace the routes are bound to, or null for the personal space. */
+  readonly workspaceId: string | null;
+  readonly getAutomation: (automationId: string) => Promise<AutomationDto>;
+  /** Starts a run now. Undefined from an API that predates returning the run. */
+  readonly trigger: (automationId: string) => Promise<TriggerAutomationResponse | undefined>;
+  readonly getRun: (automationId: string, runId: string, args?: GetAutomationRunDetailsArgs,
+  /** Replaces the bound signal for this request, to bound it more tightly. */
+  requestSignal?: AbortSignal) => Promise<AutomationRunDetailDto>;
+  /**
+   * The question the run is parked on, or null. Questions belong to the user
+   * rather than a space, so this reads the same route whatever the binding.
+   */
+  readonly findQuestion: (run: AutomationRunDetailDto, requestSignal?: AbortSignal) => Promise<QuestionSummary | null>;
+};
+/** Binds the run routes to the personal space (`null`) or a workspace. */
+export declare function bindRunApi(api: AutomationsApi, workspaceId: string | null, { signal }?: {
+  signal?: AbortSignal;
+}): RunApi;
+//#endregion
+//#region src/runs/run-wait.d.ts
+export declare const RUN_OUTCOMES: readonly ["completed", "failed", "skipped", "cancelled", "timed_out"];
+/** How a waited-for run ended, from the caller's point of view. */
+type RunOutcome = (typeof RUN_OUTCOMES)[number];
+/** The first step of a run that failed, with the error its activity reported. */
+type RunFailedStep = {
+  readonly stepId: string;
+  readonly description: string;
+  readonly error: string | null;
+};
+type RunFinished = {
+  readonly outcome: RunOutcome;
+  readonly status: AutomationRunDetailDto['status'];
+  readonly failedStep: RunFailedStep | null;
+  /** The failed step's error, else why the run failed or was skipped. */
+  readonly error: string | null;
+  readonly result: AutomationRunDetailDto['result'];
+};
+/** A run that stopped at an `ask` step and waits for the user to answer. */
+type RunWaitingForAnswer = {
+  readonly outcome: 'waiting_for_answer';
+  readonly status: AutomationRunDetailDto['status'];
+  readonly question: QuestionSummary;
+};
+type RunWaitOptions = Omit<PollOptions<AutomationRunDetailDto>, 'isParked'>;
+/**
+ * Polls a started run until it ends or the timeout passes. A run that ends
+ * without completing is still a result, not an error: the caller decides what
+ * it means.
+ */
+export declare function waitForRun(runApi: RunApi, { automationId, runId }: {
+  automationId: string;
+  runId: string;
+}, options: RunWaitOptions): Promise<RunFinished>;
+/**
+ * Like {@link waitForRun}, but stops as soon as the run parks on a question,
+ * since it will not move again until someone answers. A question is only
+ * looked up while the run's latest step is the ask (see `findRunQuestion`). A
+ * lookup that fails reads as not parked, so the wait carries on rather than
+ * failing; once the grant refuses one, the wait stops looking.
+ */
+export declare function waitForRunOrQuestion(runApi: RunApi, { automationId, runId }: {
+  automationId: string;
+  runId: string;
+}, options: RunWaitOptions): Promise<RunFinished | RunWaitingForAnswer>;
+//#endregion
+//#region src/drafts/conversation-draft.d.ts
+/**
+ * The newest draft a chat conversation authored, or null. The list filters by
+ * conversation, edit drafts included; an API older than that filter returns the
+ * newest drafts instead, so the match is still checked here.
+ */
+export declare function findConversationDraftId(api: AutomationsApi, { conversationId, workspaceId, signal }: {
+  conversationId: string;
+  workspaceId: string | null;
+  signal?: AbortSignal;
+}): Promise<string | null>;
+//#endregion
+//#region src/drafts/draft-workflow-error.d.ts
+type DraftWorkflowErrorCode =
+/** The manifest is not even a partial manifest; nothing was sent. */
+'manifest_invalid' |
+/** The automation already has an open draft, named by `draftId`. */
+'draft_conflict' |
+/** An edit draft was opened (`draftId`), but the API refused the manifest. */
+'draft_manifest_rejected' |
+/** The API refused to publish a draft that is not ready. */
+'draft_not_ready' |
+/** A connection was chosen for a connector the draft does not use. */
+'connector_not_required';
+/**
+ * A draft workflow step the caller can recover from. `draftId` names the draft
+ * the caller should act on next, which for a conflict is the one already open.
+ */
+export declare class DraftWorkflowError extends Error {
+  readonly code: DraftWorkflowErrorCode;
+  readonly draftId: string | undefined;
+  readonly automationId: string | undefined;
+  constructor(code: DraftWorkflowErrorCode, message: string, options?: {
+    draftId?: string;
+    automationId?: string;
+    cause?: unknown;
+  });
+}
+//#endregion
+export { type AskStepSummary, type AutomationConnectionSummary, AutomationConnectionsClient, AutomationDraftConnectionsClient, AutomationDraftsClient, type AutomationListItem, AutomationRunsClient, type AutomationSummary, AutomationsApi, type AutomationsApiOptions, AutomationsClient, type BillingPortalUrlArgs, type BoundConnection, type CandidateConnection, ChatClient, type ConnectionSelection, ConnectionsClient, type ConnectorCapability, type ConnectorConnectionSummary, type ConnectorListOptions, type ConnectorListResult, ConnectorsClient, type CreateAutomationDraftOptions, type CreateConnectionArgs, type CreateWebhookEventSubscriptionArgs, type CreateWorkspaceAutomationDraftOptions, type CreationScope, DEFAULT_BASE_URL, DEFAULT_TODOIST_BASE_URL, type DeleteConnectionOptions, type DraftApi, type DraftChangeResult, type DraftConnectResult, type DraftListItem, type DraftTarget, type DraftTestFinished, type DraftTestOutcome, type DraftTestRunSummary, type DraftTestStarted, type DraftTestWaitOptions, type DraftWorkflowErrorCode, type EnrichedConnector, type ListAutomationDraftsArgs, type ListAutomationRunsArgs, type ListAutomationsArgs, type ListChatConversationsArgs, type ListConnectionsArgs, type ListConnectorActionsArgs, type ListConnectorsArgs, type ListNotificationsArgs, type ListWebhookEventDeliveriesArgs, type ListWebhookEventSubscriptionsArgs, type ListWorkspaceAutomationDraftsArgs, type ListWorkspaceAutomationsArgs, type ManifestDiff, type ManifestMetadata, NotificationsClient, type PartialManifestInput, type PublishResult, type PublishSummary, type PublishVerification, PushSubscriptionsClient, type QuestionErrorCode, type QuestionOption, type QuestionRun, type QuestionSummary, type ReadTransactionsArgs, type ReadUsageSummaryArgs, type RequestOptions, type RunApi, type RunFailedStep, type RunFinished, type RunOutcome, type RunSummary, type RunWaitOptions, type RunWaitingForAnswer, type StartTopUpArgs, type TemplateConnector, type TemplateDetail, type TemplateFilters, type TemplateStep, type TemplateSummary, type TemplateTrigger, type TriggerListItem, USAGE_BILLING_TOP_UP_REFUSAL_TAGS, type UnresolvedConnection, type UpdateWebhookEventSubscriptionArgs, UsageBillingClient, type UsageBillingTopUpRefusal, type UsageBillingTopUpRefusalTag, UserSettingsClient, type VerificationBasis, WebhookEventSubscriptionsClient, WebhookSubscriptionsClient, WorkspaceAutomationDraftConnectionsClient, WorkspaceAutomationDraftsClient, WorkspaceAutomationRunsClient, WorkspaceAutomationsClient, WorkspaceChatClient, type WorkspaceCreateOptions, WorkspacesClient, connectionAccountLabel, describeCandidateConnection, getConnectionInUseError, getConnectorActionError, getDraftNotReadyError, getDraftTestRequestError, getOpenDraftConflictError, getUsageBillingTopUpRefusal, isKnownUsageBillingTopUpRefusalTag, isUsageBillingAccountNotFoundError, isUsageBillingTopUpPlanRequiredError, isUsageBillingTopUpUnavailableError, mcpServerHost };