@work-shape/catalyst-asset-schemas 0.0.0-stage → 0.8.0-rc.10

package/dist/index.d.ts

@@ -0,0 +1,2896 @@
+import { z } from 'zod';
+
+/**
+ * The shape of an agent and of a skill as a file holds it. These are the public half of the
+ * asset model: a working copy, the command line tool and the instance read the same types.
+ */
+/** The configuration rights reported for an asset; publish applies to draft/published kinds. */
+declare const ASSET_ACCESS_VERBS: readonly ["read", "write", "delete", "publish"];
+declare const localeCodes: readonly ["en", "de"];
+type LocaleCode = (typeof localeCodes)[number];
+type LocalizedStringConfig = string | {
+    en?: string;
+    de?: string;
+};
+declare const REASONING_EFFORTS: readonly ["none", "low", "medium", "high", "xhigh", "max"];
+type ReasoningEffortConfig = (typeof REASONING_EFFORTS)[number];
+interface AgentInitialPromptConfig {
+    title: LocalizedStringConfig;
+    prompt: LocalizedStringConfig;
+}
+interface AgentConfig {
+    name: string;
+    displayName: LocalizedStringConfig;
+    description?: LocalizedStringConfig;
+    welcomeMessage?: LocalizedStringConfig;
+    welcomeSubtitle?: LocalizedStringConfig;
+    instructions: string;
+    modelProviderId?: string;
+    modelBindingId?: string;
+    reasoningEffort?: ReasoningEffortConfig;
+    fastMode?: boolean;
+    /** Bindings users may pick for this agent in the chat, besides its own `modelBindingId`. */
+    userSelectableModelBindingIds?: string[];
+    /**
+     * Reasoning effort per user-selectable binding. `reasoningEffort` stays the effort of the
+     * agent's own model and is not applied to a model a user picked instead.
+     */
+    modelReasoningEfforts?: Record<string, ReasoningEffortConfig>;
+    maxSteps?: number;
+    toolNames: string[];
+    /**
+     * The other agents this agent may start as subagents with `run_agent`, besides itself. Each
+     * is started only where the person may use it in the conversation's workspace.
+     */
+    subagentNames?: string[];
+    skillNames: string[];
+    /**
+     * The Knowledge Bases the agent answers from, by id. However many it lists, the agent has one
+     * tool over those of tables, `knowledge.query`, and one over those of documents,
+     * `knowledge.search`. Missing means none.
+     */
+    knowledgeBases?: string[];
+    initialPrompts: AgentInitialPromptConfig[];
+    /**
+     * An agent that ships with the platform: its fields as the release shipped them last. Only
+     * the release seed writes it; every other write keeps it as stored.
+     */
+    shipped?: Record<string, unknown>;
+}
+interface SkillConfig {
+    name: string;
+    title: string;
+    /** For the agent: when to use the skill. */
+    description: string;
+    /**
+     * For people: one sentence on one line that says what an agent with the skill knows how to
+     * do. Lists and choosers show it under the title.
+     */
+    summary?: string;
+    /** Up to `SKILL_STARTERS_MAX` first requests the empty chat offers for an agent with the skill. */
+    starters?: SkillStarterConfig[];
+    content: string;
+    resources?: SkillResourceConfig[];
+    /**
+     * The files of the skill's folder that the config does not hold itself: everything beside
+     * `SKILL.md` and the text resources, such as a script, a PDF or an image. An index and no
+     * content. The platform writes it with the files; what a caller sends here is not read.
+     */
+    files?: SkillFileEntry[];
+    /**
+     * The keys of the frontmatter of `SKILL.md` that are not fields of the skill
+     * (`SKILL_FRONTMATTER_FIELDS`), such as `license`, `metadata` and `allowed-tools` of the
+     * public skill convention, as JSON values. They are kept and returned and never read by the
+     * platform.
+     */
+    frontmatter?: Record<string, unknown>;
+    /**
+     * `release` on a skill that ships with the platform. Only the release seed writes it: every
+     * other write of a skill that carries it is refused, and a stored one is read-only.
+     */
+    origin?: "release";
+    /** The key of the interface's icon registry. Only a skill that ships with the platform has one. */
+    icon?: string;
+}
+/** One file of a skill's folder as its index names it. */
+interface SkillFileEntry {
+    /** Relative to the folder of the skill, with `/` between segments. */
+    path: string;
+    /** Lower-case hex. */
+    sha256: string;
+    bytes: number;
+    mediaType: string;
+}
+/** How many starters one skill carries at most. */
+declare const SKILL_STARTERS_MAX = 2;
+/** How many starters the empty chat shows for one agent at most. */
+declare const AGENT_STARTERS_MAX = 4;
+/** The most characters a starter's `title` and its `hint` hold, in each language. */
+declare const SKILL_STARTER_LINE_MAX_LENGTH = 60;
+/** One first request a skill offers on the empty chat. Choosing it fills the composer. */
+interface SkillStarterConfig {
+    title: LocalizedStringConfig;
+    /** One short line under the title. */
+    hint?: LocalizedStringConfig;
+    /** The text that fills the composer. */
+    prompt: LocalizedStringConfig;
+    /**
+     * The tools the request needs. The starter shows only for an agent that holds every one of
+     * them, so it never offers what the agent cannot do.
+     */
+    tools?: string[];
+}
+/** The most characters a skill's `summary` holds. */
+declare const SKILL_SUMMARY_MAX_LENGTH = 120;
+/**
+ * Who ships a skill, as a list says it: `instance` for a skill of the instance's own, `release`
+ * for one that ships with the platform, which the release seed alone writes.
+ */
+declare const SKILL_ORIGINS: readonly ["instance", "release"];
+type SkillOrigin = (typeof SKILL_ORIGINS)[number];
+declare const SKILL_RESOURCE_MEDIA_TYPES: readonly ["text/markdown", "text/plain", "application/json", "application/yaml"];
+type SkillResourceMediaType = (typeof SKILL_RESOURCE_MEDIA_TYPES)[number];
+interface SkillResourceConfig {
+    path: string;
+    mediaType: SkillResourceMediaType;
+    content: string;
+}
+/** Ordered from the narrowest App audience to the widest. */
+declare const APP_AUDIENCES: readonly ["self", "workspace", "instance"];
+
+/**
+ * The values the HTTP contract of an instance is written with: scopes, actions, error codes
+ * and the limits a request is checked against. They hold no behaviour. The private packages
+ * of the platform read them from here, so that the contract and what enforces it cannot
+ * drift apart.
+ */
+declare const AUTH_SCOPE_WILDCARD: "*";
+declare const CHAT_SESSION_AUTH_SCOPES: readonly ["me:read", "me:delete", "config:read", "conversation:read", "conversation:write", "run:start", "run:observe", "run:cancel", "run:command"];
+declare const FIRST_PARTY_AUTH_SCOPES: readonly ["*", "me:read", "me:delete", "config:read", "conversation:read", "conversation:write", "run:start", "run:observe", "run:cancel", "run:command", "collaboration_workspace:read", "collaboration_workspace:manage", "me:write", "governance:read", "governance:write", "user_admin:read", "user_admin:write", "api_access:read", "api_access:write", "config_assets:read", "config_assets:write", "config_assets:publish", "config_assets:release", "data_store_rows:read", "data_store_rows:write"];
+type ChatSessionAuthScope = (typeof CHAT_SESSION_AUTH_SCOPES)[number];
+type FirstPartyAuthScope = (typeof FIRST_PARTY_AUTH_SCOPES)[number];
+type OperationScope = Exclude<FirstPartyAuthScope, "*">;
+/**
+ * Every right of the platform, one file per domain under `contract-values/`. The order is kept:
+ * `GRANTABLE_ACTIONS` filters it, and the rights dialog lists rights in it.
+ */
+declare const ACTIONS: readonly ["agent.read", "agent.write", "agent.publish", "agent.approve", "agent.delete", "agent.use", "skill.read", "skill.write", "skill.delete", "skill.approve", "connection.read", "connection.use", "connection.write", "connection.delete", "connection.approve", "app.read", "app.write", "app.publish", "app.approve", "app.delete", "app.use", "workflow.read", "workflow.write", "workflow.publish", "workflow.approve", "workflow.delete", "workflow.use", "workflow.read_run_data", "data_store.read", "data_store.write", "data_store.publish", "data_store.delete", "data_store.insert", "data_store.execute", "data_store.records", "knowledge_base.read", "knowledge_base.write", "knowledge_base.ingest", "knowledge_base.publish", "knowledge_base.delete", "knowledge_base.use", "mail_sender.use", "guardrail.read", "guardrail.write", "guardrail.publish", "guardrail.delete", "operations.approve", "feedback.review", "users.manage", "users.delete", "usage.view", "limits.manage", "usage.view_users", "audit.view", "system.view", "jobs.retry", "api_access.manage", "service_principals.manage", "agent_models.manage", "roles.edit_built_in", "assets.release", "builder", "publisher"];
+type PlatformAction = (typeof ACTIONS)[number];
+type AppErrorCode = (typeof APP_ERROR_CODES)[number];
+/** The HTTP status every error code answers with. */
+declare const APP_ERROR_STATUS_CODES: Record<AppErrorCode, number>;
+type OperationEffect = (typeof OPERATION_EFFECTS)[number];
+/**
+ * The longest `Idempotency-Key` a caller may send, in characters. It protects the index the
+ * key is looked up in. A longer key is refused with VALIDATION_FAILED naming this limit.
+ */
+declare const IDEMPOTENCY_KEY_MAX_LENGTH = 255;
+/** What an instance takes from outside its own processes. A closed list. */
+declare const PROVIDER_PORTS: readonly ["models", "mail", "objectStorage", "sandbox", "secrets"];
+type ProviderPort = (typeof PROVIDER_PORTS)[number];
+/**
+ * Where a provider processes the data an instance sends it. Only `eu` admits personal
+ * Connections; other short strings describe routes outside that boundary.
+ */
+declare const PROVIDER_REGIONS: readonly ["eu", "global"];
+type ProviderRegion = string;
+/**
+ * Why a check failed. Product-owned and closed: it is all of a failure that reaches a log, the
+ * API or a page, so a provider's own error text, which can repeat a key or an address, cannot.
+ */
+declare const PROVIDER_CHECK_ERROR_CLASSES: readonly ["unreachable", "timeout", "access_denied", "not_found", "bucket_missing", "rejected", "failed"];
+type ProviderCheckErrorClass = (typeof PROVIDER_CHECK_ERROR_CLASSES)[number];
+/**
+ * The immutable machine name. It is part of every operation name of the Connection
+ * (`connection.<name>.<operation>`), so it holds no dot.
+ */
+declare const CONNECTION_NAME_PATTERN: RegExp;
+declare const CONNECTION_NAME_MAX_LENGTH = 64;
+/**
+ * The immutable machine name of a Guardrail. An approval request keeps it as the id of the
+ * check that answered, and its hits are kept under it.
+ */
+declare const GUARDRAIL_NAME_PATTERN: RegExp;
+declare const GUARDRAIL_NAME_MAX_LENGTH = 64;
+/**
+ * Who may call an accepted operation. An operation exposed to nobody is callable by nobody.
+ * `outside` admits the CLI and the platform MCP server, a caller with an API credential whose
+ * results leave the instance; no operation has it unless an admin turns it on.
+ */
+declare const CONNECTION_EXPOSURES: readonly ["agent", "bridge", "workflow", "outside"];
+type ConnectionExposure = (typeof CONNECTION_EXPOSURES)[number];
+/** The health of a Connection as its page and its list show it. */
+declare const CONNECTION_HEALTH_STATES: readonly ["unknown", "ok", "failed", "needs_configuration", "secret_unreadable"];
+type ConnectionHealth = (typeof CONNECTION_HEALTH_STATES)[number];
+declare const GRANT_HOLDER_KINDS: readonly ["user", "service_principal", "role", "group"];
+type GrantHolderKind = (typeof GRANT_HOLDER_KINDS)[number];
+declare const GRANT_SCOPE_KINDS: readonly ["instance", "workspace", "asset"];
+type GrantScopeKind = (typeof GRANT_SCOPE_KINDS)[number];
+/** Where a role's grant lies: the whole instance, one workspace or one asset. */
+declare const ROLE_GRANT_SCOPE_KINDS: readonly ["instance", "workspace", "asset"];
+type RoleGrantScopeKind = (typeof ROLE_GRANT_SCOPE_KINDS)[number];
+/** What a release did to an action of a built-in role's default that waits for a decision. */
+declare const ROLE_PENDING_CHANGES: readonly ["added", "removed"];
+/** The decision on a pending action: apply what the release did, or dismiss it. */
+declare const ROLE_PENDING_DECISIONS: readonly ["apply", "dismiss"];
+type RolePendingDecision = (typeof ROLE_PENDING_DECISIONS)[number];
+declare const GRANT_EFFECTS: readonly ["allow", "deny"];
+type GrantEffect = (typeof GRANT_EFFECTS)[number];
+declare const ACCESS_SOURCES: readonly ["role", "legacy_ref", "grant", "membership"];
+type AccessSource = (typeof ACCESS_SOURCES)[number];
+declare const POLICY_VALUES: readonly ["allow", "confirm", "approval", "deny"];
+type PolicyValue = (typeof POLICY_VALUES)[number];
+declare const AUTH_PRINCIPAL_KINDS: readonly ["user", "service"];
+type AuthPrincipalKind = (typeof AUTH_PRINCIPAL_KINDS)[number];
+declare const ADMINISTERED_USER_STATUSES: readonly ["active", "disabled", "deleting"];
+type AdministeredUserStatus = (typeof ADMINISTERED_USER_STATUSES)[number];
+declare const SERVICE_PRINCIPAL_STATUSES: readonly ["active", "disabled"];
+type ServicePrincipalStatus = (typeof SERVICE_PRINCIPAL_STATUSES)[number];
+/**
+ * When the account a Workflow runs as needs a right its definition names. `publish`: the
+ * publish is refused without it. `run`: the step that needs it fails when it runs.
+ */
+declare const WORKFLOW_RIGHT_NEEDED_FOR: readonly ["publish", "run"];
+/** The revision of a publish's Workflow the rights are read from: the one published, or a live child. */
+declare const WORKFLOW_RIGHTS_REVISIONS: readonly ["draft", "published"];
+/** How the account a Workflow names stands: a principal's status, or no principal of the name. */
+declare const WORKFLOW_RUN_ACCOUNT_STATUSES: readonly ["active", "disabled", "unknown"];
+/**
+ * Why a reader cannot give an account a right it lacks. `not_grantable`: nobody can give it to
+ * an account here. `not_administrator`: giving needs someone who administers technical
+ * accounts. `not_held`: the reader does not hold it there. `account_unavailable`: the account
+ * is missing or disabled. `asset_unavailable`: no active asset of the name exists.
+ */
+declare const WORKFLOW_RIGHT_REFUSALS: readonly ["not_grantable", "not_administrator", "not_held", "account_unavailable", "asset_unavailable", "not_visible"];
+declare const SERVICE_PRINCIPAL_PERMISSIONS: readonly ["config_assets.read", "config_assets.release"];
+type ServicePrincipalPermission = (typeof SERVICE_PRINCIPAL_PERMISSIONS)[number];
+declare const API_CREDENTIAL_SCOPES: readonly ["config_assets:read", "config_assets:release"];
+type ApiCredentialScope = (typeof API_CREDENTIAL_SCOPES)[number];
+declare const APP_ERROR_CODES: readonly ["BAD_REQUEST", "UNAUTHENTICATED", "FORBIDDEN", "NOT_FOUND", "CONFLICT", "REVISION_CONFLICT", "PRECONDITION_REQUIRED", "TIMEOUT", "VALIDATION_FAILED", "RATE_LIMITED", "POLICY_DENIED", "GUARDRAIL_BLOCKED", "DECLINED", "IDEMPOTENCY_KEY_REUSED", "OPERATION_IN_PROGRESS", "OPERATION_EXPIRED", "OUTPUT_NOT_RETAINED", "INTERNAL"];
+declare const OPERATION_EFFECTS: readonly ["reading", "changing"];
+/** The parts a catalogue entry can bring: tools agents call, or a Knowledge Base source. */
+declare const CATALOGUE_PARTS: readonly ["tools", "source"];
+type CataloguePart = (typeof CATALOGUE_PARTS)[number];
+/** The categories a catalogue entry's card is filed under. */
+declare const CATALOGUE_CATEGORIES: readonly ["mail", "files", "accounting", "databases", "other"];
+type CatalogueCategory = (typeof CATALOGUE_CATEGORIES)[number];
+declare const OPERATION_TARGETS: readonly ["live", "test", "dry_run"];
+type OperationTarget = (typeof OPERATION_TARGETS)[number];
+declare const OPERATION_RUN_STATUSES: readonly ["running", "pending_confirmation", "pending_approval", "done", "failed", "denied", "expired"];
+type OperationRunStatus = (typeof OPERATION_RUN_STATUSES)[number];
+declare const OPERATION_ORIGIN_KINDS: readonly ["agent", "user", "cli", "mcp", "app", "workflow", "schedule"];
+type OperationOriginKind = (typeof OPERATION_ORIGIN_KINDS)[number];
+declare const OPERATION_RUN_DECISION_MODES: readonly ["direct", "confirmed", "approved", "declined"];
+type OperationRunDecisionMode = (typeof OPERATION_RUN_DECISION_MODES)[number];
+declare const OPERATION_RUN_DECISION_REASONS: readonly ["inherited_approval_not_applied", "workflow_publish", "approved_by_caller"];
+type OperationRunDecisionReason = (typeof OPERATION_RUN_DECISION_REASONS)[number];
+declare const OPERATION_DENIAL_REASONS: readonly ["no_grant", "denied", "unknown_action", "holder_inactive", "holder_not_administrable", "user_only", "outside_key_scope"];
+type OperationDenialReason = (typeof OPERATION_DENIAL_REASONS)[number];
+declare const APPROVAL_REQUEST_STATUSES: readonly ["pending", "approved", "rejected", "changes_requested", "superseded", "withdrawn", "reverted"];
+type ApprovalRequestStatus = (typeof APPROVAL_REQUEST_STATUSES)[number];
+declare const APPROVAL_CHECK_STATUSES: readonly ["passed", "warned", "blocked"];
+type ApprovalCheckStatus = (typeof APPROVAL_CHECK_STATUSES)[number];
+declare const APPROVAL_EXECUTIONS: readonly ["queued", "done", "failed", "interrupted", "refused", "expired", "held"];
+type ApprovalExecution = (typeof APPROVAL_EXECUTIONS)[number];
+declare const SKILL_CHANGE_TYPES: readonly ["replace", "add", "new_resource"];
+type SkillChangeType = (typeof SKILL_CHANGE_TYPES)[number];
+declare const GUARDRAIL_OUTCOMES: readonly ["allow", "warn", "require_approval", "block"];
+type GuardrailOutcome = (typeof GUARDRAIL_OUTCOMES)[number];
+declare const APP_MODES: readonly ["published", "draft"];
+type AppMode = (typeof APP_MODES)[number];
+declare const ASSET_NAME_REFUSAL_REASONS: readonly ["name_invalid", "name_taken"];
+type AssetNameRefusalReason = (typeof ASSET_NAME_REFUSAL_REASONS)[number];
+declare const ASSET_SYNC_CHANGE_TYPES: readonly ["put", "delete"];
+type AssetSyncChangeType = (typeof ASSET_SYNC_CHANGE_TYPES)[number];
+declare const ASSET_LIFECYCLES: readonly ["active", "draft_published"];
+type AssetLifecycle = (typeof ASSET_LIFECYCLES)[number];
+declare const ASSET_REPRESENTATIONS: readonly ["config", "files"];
+type AssetRepresentation = (typeof ASSET_REPRESENTATIONS)[number];
+declare const CONFIG_ASSET_KINDS: readonly ["agent", "skill"];
+type ConfigAssetKind = (typeof CONFIG_ASSET_KINDS)[number];
+declare const CONFIG_ASSET_CHANGE_OPERATIONS: readonly ["create", "update", "delete", "revert"];
+type ConfigAssetChangeOperation = (typeof CONFIG_ASSET_CHANGE_OPERATIONS)[number];
+declare const AGENT_AVAILABILITY_MODES: readonly ["all", "selected"];
+type AgentAvailabilityMode = (typeof AGENT_AVAILABILITY_MODES)[number];
+/**
+ * Who uses an agent where it is available (AGENT-USE-1): everyone who may work there, or only
+ * those `agent.use` allows on it. Every agent starts at `everyone`.
+ */
+declare const AGENT_USE_SETTINGS: readonly ["everyone", "granted"];
+type AgentUse = (typeof AGENT_USE_SETTINGS)[number];
+declare const AGENT_EDITABLE_FIELDS: readonly ["displayName", "description", "welcomeMessage", "welcomeSubtitle", "instructions", "modelBindingId", "reasoningEffort", "maxSteps", "toolNames", "skillNames", "knowledgeBases", "initialPrompts"];
+type AgentEditableField = (typeof AGENT_EDITABLE_FIELDS)[number];
+declare const ASSET_REPO_BUNDLE_KINDS: readonly ["full", "incremental"];
+type AssetRepoBundleKind = (typeof ASSET_REPO_BUNDLE_KINDS)[number];
+declare const WORKSPACE_FILE_KINDS: readonly ["page", "upload", "generated_file"];
+type WorkspaceFileKind = (typeof WORKSPACE_FILE_KINDS)[number];
+declare const WORKSPACE_VISIBILITIES: readonly ["discoverable", "private"];
+type WorkspaceVisibility = (typeof WORKSPACE_VISIBILITIES)[number];
+declare const WORKSPACE_MEMBERSHIP_ROLES: readonly ["owner", "admin", "member"];
+type WorkspaceMembershipRole = (typeof WORKSPACE_MEMBERSHIP_ROLES)[number];
+declare const WORKSPACE_ACCENT_COLORS: readonly ["garnet", "ruby", "mahogany", "copper", "amber", "olive", "jade", "emerald", "teal", "turquoise", "azure", "sapphire", "indigo", "violet", "magenta", "rose", "stone", "slate"];
+type WorkspaceAccentColor = (typeof WORKSPACE_ACCENT_COLORS)[number];
+declare const COLLABORATION_WORKSPACE_KINDS: readonly ["personal", "shared"];
+type CollaborationWorkspaceKind = (typeof COLLABORATION_WORKSPACE_KINDS)[number];
+declare const WORKSPACE_ACCESS_STATES: readonly ["member", "request_pending", "can_request"];
+type WorkspaceAccessState = (typeof WORKSPACE_ACCESS_STATES)[number];
+declare const DELETION_STATES: readonly ["deleting", "deleted"];
+type DeletionState = (typeof DELETION_STATES)[number];
+declare const WORKSPACE_SECTIONS: readonly ["agents", "apps"];
+type WorkspaceSection = (typeof WORKSPACE_SECTIONS)[number];
+declare const MODEL_USAGE_TIERS: readonly ["very_low", "low", "moderate", "elevated", "high", "very_high"];
+type ModelUsageTier = (typeof MODEL_USAGE_TIERS)[number];
+declare const THEME_MODE_PREFERENCES: readonly ["light", "dark", "system"];
+type ThemeModePreference = (typeof THEME_MODE_PREFERENCES)[number];
+declare const TOOL_GROUPS: readonly ["documents", "web", "files", "results", "skills", "platform", "instance"];
+type ToolGroup = (typeof TOOL_GROUPS)[number];
+declare const INFRASTRUCTURE_SECRET_STATES: readonly ["set", "missing"];
+type InfrastructureSecretState = (typeof INFRASTRUCTURE_SECRET_STATES)[number];
+declare const INFRASTRUCTURE_WITHHELD_FIELDS: readonly ["endpointHost", "bucket"];
+type InfrastructureWithheldField = (typeof INFRASTRUCTURE_WITHHELD_FIELDS)[number];
+declare const OPENAI_COMPATIBLE_APIS: readonly ["chat_completions", "responses"];
+type OpenaiCompatibleApi = (typeof OPENAI_COMPATIBLE_APIS)[number];
+declare const MODEL_PROVIDER_AUTH_MODES: readonly ["bearer", "api-key"];
+type ModelProviderAuthMode = (typeof MODEL_PROVIDER_AUTH_MODES)[number];
+declare const CONVERSATION_VISIBILITIES: readonly ["workspace", "private"];
+/** A conversation a person has, or the run thread of a Child Agent Run. */
+declare const CONVERSATION_KINDS: readonly ["chat", "run_thread"];
+type ConversationKind = (typeof CONVERSATION_KINDS)[number];
+type ConversationVisibility = (typeof CONVERSATION_VISIBILITIES)[number];
+declare const WEB_SOURCE_PROVIDERS: readonly ["openai-native", "serper", "tavily", "firecrawl", "browserbase", "direct"];
+type WebSourceProvider = (typeof WEB_SOURCE_PROVIDERS)[number];
+declare const CHAT_MESSAGE_ROLES: readonly ["user", "assistant", "system", "tool"];
+type ChatMessageRole = (typeof CHAT_MESSAGE_ROLES)[number];
+declare const CONVERSATION_ATTACHMENT_STATUSES: readonly ["queued", "preprocessing", "ready", "failed", "unsupported", "deleted"];
+type ConversationAttachmentStatus = (typeof CONVERSATION_ATTACHMENT_STATUSES)[number];
+declare const ATTACHMENT_CREATE_OUTCOMES: readonly ["created", "already_available"];
+type AttachmentCreateOutcome = (typeof ATTACHMENT_CREATE_OUTCOMES)[number];
+declare const STRUCTURED_DATA_REVIEW_REASONS: readonly ["uncertain", "conflicting"];
+type StructuredDataReviewReason = (typeof STRUCTURED_DATA_REVIEW_REASONS)[number];
+/** Queued: sent as the next turn. Steer: taken in by the author's own running turn (FU-2). */
+declare const FOLLOW_UP_MODES: readonly ["queue", "steer"];
+/** `consumed`: a steer the running turn took in; `dispatched`: started as a turn of its own. */
+declare const FOLLOW_UP_STATUSES: readonly ["pending", "dispatched", "consumed", "cancelled"];
+declare const AGENT_RUN_STATUSES: readonly ["queued", "running", "waiting_for_decision", "waiting_for_subagents", "cancelling", "completed", "cancelled", "failed"];
+type AgentRunStatus = (typeof AGENT_RUN_STATUSES)[number];
+declare const AGENT_RUN_FAILURE_CATEGORIES: readonly ["app_error", "internal_error", "runtime_interrupted", "abort_error", "unknown_error"];
+type AgentRunFailureCategory = (typeof AGENT_RUN_FAILURE_CATEGORIES)[number];
+declare const TOOL_INPUT_PARSE_ERROR_CODES: readonly ["invalid_json", "invalid_text"];
+type ToolInputParseErrorCode = (typeof TOOL_INPUT_PARSE_ERROR_CODES)[number];
+declare const WAITING_OPERATION_RUN_STATUSES: readonly ["pending_confirmation", "pending_approval"];
+declare const OPERATION_CONFIRMATION_DECISIONS: readonly ["confirm", "decline"];
+/** A person's own value for an operation (OP-6): Always allow, Ask me, Never. */
+declare const PERSON_POLICY_SETTINGS: readonly ["always_allow", "ask", "never"];
+/** How far a changing operation reaches. One that declares none counts as `irreversible`. */
+declare const OPERATION_CHANGE_CLASSES: readonly ["reversible", "irreversible", "outward"];
+declare const TOOL_DECISION_MODES: readonly ["confirm", "approval"];
+declare const TOOL_DECISION_OUTCOMES: readonly ["confirmed", "declined", "expired", "cancelled"];
+declare const TOOL_CALL_STATES: readonly ["input_available", "waiting_for_decision", "output_available", "output_error"];
+type ToolCallState = (typeof TOOL_CALL_STATES)[number];
+declare const SUPPORTED_IMAGE_MIME_TYPES: readonly ["image/png", "image/jpeg", "image/webp", "image/gif"];
+type SupportedImageMimeType = (typeof SUPPORTED_IMAGE_MIME_TYPES)[number];
+declare const ARTIFACT_PREVIEW_IMAGE_FORMATS: readonly ["png", "webp", "jpeg"];
+type ArtifactPreviewImageFormat = (typeof ARTIFACT_PREVIEW_IMAGE_FORMATS)[number];
+declare const ARTIFACT_PREVIEW_STATUSES: readonly ["ready", "pending", "failed", "unsupported"];
+type ArtifactPreviewStatus = (typeof ARTIFACT_PREVIEW_STATUSES)[number];
+declare const WORKSPACE_COMMAND_STATUSES: readonly ["queued", "running", "cancelling", "completed", "failed", "cancelled"];
+type WorkspaceCommandStatus = (typeof WORKSPACE_COMMAND_STATUSES)[number];
+declare const TOOL_DISPLAY_MODES: readonly ["inline", "side_panel", "fullscreen"];
+type ToolDisplayMode = (typeof TOOL_DISPLAY_MODES)[number];
+declare const JOB_STATUSES: readonly ["queued", "running", "succeeded", "failed", "dead", "cancelled"];
+type JobStatus = (typeof JOB_STATUSES)[number];
+declare const AUDIT_ACTOR_KINDS: readonly ["user", "assistant", "service", "system"];
+type AuditActorKind = (typeof AUDIT_ACTOR_KINDS)[number];
+declare const AUDIT_TIERS: readonly ["governance", "workflow", "runtime", "telemetry"];
+type AuditTier = (typeof AUDIT_TIERS)[number];
+declare const AUDIT_OUTCOMES: readonly ["success", "failed", "denied", "warning"];
+type AuditOutcome = (typeof AUDIT_OUTCOMES)[number];
+declare const MODEL_USAGE_EVENT_STATUSES: readonly ["pending", "settled", "failed", "abandoned"];
+type ModelUsageEventStatus = (typeof MODEL_USAGE_EVENT_STATUSES)[number];
+declare const MODEL_USAGE_SOURCES: readonly ["provider_reported", "not_reported", "estimated"];
+type ModelUsageSource = (typeof MODEL_USAGE_SOURCES)[number];
+declare const USAGE_COST_STATUSES: readonly ["settled", "incomplete", "unpriced"];
+type UsageCostStatus = (typeof USAGE_COST_STATUSES)[number];
+declare const CONNECTION_OPERATION_STATUSES: readonly ["ready", "awaiting_discovery", "needs_review", "unknown", "disabled"];
+type ConnectionOperationStatus = (typeof CONNECTION_OPERATION_STATUSES)[number];
+declare const CONNECTION_SECRET_STATES: readonly ["set", "not_set", "unreadable"];
+type ConnectionSecretState = (typeof CONNECTION_SECRET_STATES)[number];
+declare const CONNECTOR_TEST_STATUSES: readonly ["ready", "unauthorized", "network_denied", "unavailable", "oauth_required"];
+type ConnectorTestStatus = (typeof CONNECTOR_TEST_STATUSES)[number];
+/** Shared account, or the acting person's own account. */
+declare const CONNECTION_CREDENTIAL_MODES: readonly ["shared", "user"];
+type ConnectionCredentialMode = (typeof CONNECTION_CREDENTIAL_MODES)[number];
+/**
+ * The state of a Connection's sign-in. `connected`: calls use it. `needs_reconnect`: the
+ * outside system refused it and a new sign-in is needed. `revoked`: someone disconnected it,
+ * or its Connection went away.
+ */
+declare const CONNECTION_BINDING_STATES: readonly ["connected", "needs_reconnect", "revoked"];
+type ConnectionBindingState = (typeof CONNECTION_BINDING_STATES)[number];
+/** What a chat Connection proposal's card needs to start setup or sign-in. */
+declare const CONNECTION_PROPOSAL_STATES: readonly ["ready", "needs_setup"];
+type ConnectionProposalState = (typeof CONNECTION_PROPOSAL_STATES)[number];
+declare const CONNECTION_PROPOSAL_BINDING_STATES: readonly ["connected", "needs_reconnect", "not_connected"];
+type ConnectionProposalBindingState = (typeof CONNECTION_PROPOSAL_BINDING_STATES)[number];
+/** What a refused call of a personal Connection needs of its person: a first or a new sign-in. */
+declare const CONNECTION_SIGN_IN_NEEDS: readonly ["not_connected", "needs_reconnect"];
+type ConnectionSignInNeed = (typeof CONNECTION_SIGN_IN_NEEDS)[number];
+/**
+ * How a Connection that signs in with OAuth has its client: registered by the platform
+ * (Dynamic Client Registration), issued by the provider and named in the settings, or the
+ * operator's managed client of release config (`infrastructure.oauthClients`, MS-APP-1).
+ */
+declare const CONNECTION_OAUTH_REGISTRATIONS: readonly ["dcr", "preregistered", "managed"];
+type ConnectionOAuthRegistration = (typeof CONNECTION_OAUTH_REGISTRATIONS)[number];
+/**
+ * What the provider answered to the revocation of a sign-in (RFC 7009): it confirmed, it
+ * failed or was not reached, or it lists no revocation endpoint and was sent nothing.
+ */
+declare const CONNECTION_PROVIDER_REVOCATIONS: readonly ["confirmed", "failed", "not_offered"];
+type ConnectionProviderRevocation = (typeof CONNECTION_PROVIDER_REVOCATIONS)[number];
+declare const CONNECTION_ORIGINS: readonly ["release", "runtime"];
+type ConnectionOrigin = (typeof CONNECTION_ORIGINS)[number];
+declare const CONNECTION_NETWORKS: readonly ["public", "private"];
+type ConnectionNetwork = (typeof CONNECTION_NETWORKS)[number];
+declare const DATA_STORE_SCALAR_TYPES: readonly ["text", "integer", "number", "boolean", "date", "timestamp"];
+type DataStoreScalarType = (typeof DATA_STORE_SCALAR_TYPES)[number];
+declare const DATA_STORE_LOAD_CONFLICT_MODES: readonly ["fail", "skip", "update"];
+type DataStoreLoadConflictMode = (typeof DATA_STORE_LOAD_CONFLICT_MODES)[number];
+declare const DATA_STORE_INSERT_CONFLICT_MODES: readonly ["fail", "skip"];
+type DataStoreInsertConflictMode = (typeof DATA_STORE_INSERT_CONFLICT_MODES)[number];
+declare const DATA_STORE_CONDITIONS: readonly ["server_databases_open", "sessions_open", "temp_files_unbounded"];
+type DataStoreCondition = (typeof DATA_STORE_CONDITIONS)[number];
+declare const DATA_STORE_STATUSES: readonly ["provisioning", "ready", "retired"];
+type DataStoreStatus = (typeof DATA_STORE_STATUSES)[number];
+declare const DATA_STORE_MIGRATION_OUTCOMES: readonly ["none", "pending", "applied", "failed"];
+type DataStoreMigrationOutcome = (typeof DATA_STORE_MIGRATION_OUTCOMES)[number];
+/**
+ * `unchecked` until the first check; `preparing` while the store a Knowledge Base of documents
+ * owns is still being made; then `ok` or `needs_attention`.
+ */
+declare const KNOWLEDGE_BASE_STATUSES: readonly ["unchecked", "preparing", "ok", "needs_attention"];
+type KnowledgeBaseStatus = (typeof KNOWLEDGE_BASE_STATUSES)[number];
+/**
+ * The embedding of a Knowledge Base that searches by meaning. `current`: its index embeds with
+ * the model it is set to. `reindex_needed`: the index's model is gone from the instance, so
+ * search answers by words and titles alone. `reindex_available`: it is set to another model
+ * than its index uses. `reindexing`: a new index is being built beside the one search reads.
+ * `none`: nothing is embedded yet.
+ */
+declare const KNOWLEDGE_EMBEDDING_STATES: readonly ["current", "reindex_needed", "reindex_available", "reindexing", "none"];
+/**
+ * What the page of a Knowledge Base shows of one document. `pending` is added and not yet
+ * searchable: waiting for its index job, being indexed or waiting for extraction. `indexed` is
+ * found by search. `failed` carries one of `KNOWLEDGE_DOCUMENT_FAILURE_CODES`; Retry puts it
+ * back to `pending`.
+ */
+declare const KNOWLEDGE_DOCUMENT_STATES: readonly ["pending", "indexed", "failed"];
+type KnowledgeDocumentState = (typeof KNOWLEDGE_DOCUMENT_STATES)[number];
+/**
+ * The largest file a Knowledge Base takes, as document processing takes it. A larger file is
+ * refused when it is added, with this limit named.
+ */
+declare const KNOWLEDGE_FILE_MAX_BYTES: number;
+/**
+ * Why a document was not indexed. The first five and `knowledge_file_too_many_pages` can also
+ * come from the extraction of a PDF or DOCX (`KNOWLEDGE_EXTRACTION_FAILURE_CODES` in core); the
+ * rest are the index job's own. The list only gains members.
+ */
+declare const KNOWLEDGE_DOCUMENT_FAILURE_CODES: readonly ["knowledge_file_format_unsupported", "knowledge_file_over_limit", "knowledge_file_unreadable", "knowledge_file_missing", "knowledge_extraction_failed", "knowledge_file_format_unavailable", "knowledge_text_unreadable", "knowledge_text_empty", "knowledge_index_failed", "knowledge_file_too_many_pages", "knowledge_processor_output_invalid", "knowledge_conversion_timeout"];
+type KnowledgeDocumentFailureCode = (typeof KNOWLEDGE_DOCUMENT_FAILURE_CODES)[number];
+/**
+ * Why a `pending` document waits, where it waits for something other than its turn. It goes on
+ * by itself once the cause is gone.
+ */
+declare const KNOWLEDGE_DOCUMENT_WAIT_CODES: readonly ["knowledge_usage_limit_reached"];
+type KnowledgeDocumentWaitCode = (typeof KNOWLEDGE_DOCUMENT_WAIT_CODES)[number];
+/**
+ * Why a synced source of a Knowledge Base, or one item of it, did not come in. Beside the
+ * document codes: an item over the size limit or of a format the instance does not read is
+ * recorded with `knowledge_file_over_limit` or `knowledge_file_format_unsupported` and never
+ * fetched. Spec: Synced sources, Contract freezes (SRC-0).
+ */
+declare const KNOWLEDGE_SOURCE_FAILURE_CODES: readonly ["knowledge_source_unreachable", "knowledge_source_refused", "knowledge_fetch_failed", "knowledge_source_limit_reached", "knowledge_item_invalid", "knowledge_fetch_not_allowed", "knowledge_ingest_cancelled", "knowledge_item_removed"];
+type KnowledgeSourceFailureCode = (typeof KNOWLEDGE_SOURCE_FAILURE_CODES)[number];
+/** The code a failed item of a synced source carries: a source code, or one it shares with a file added by hand. */
+declare const KNOWLEDGE_SOURCE_ITEM_FAILURE_CODES: readonly ["knowledge_source_unreachable", "knowledge_source_refused", "knowledge_fetch_failed", "knowledge_source_limit_reached", "knowledge_item_invalid", "knowledge_fetch_not_allowed", "knowledge_ingest_cancelled", "knowledge_item_removed", "knowledge_file_over_limit", "knowledge_file_format_unsupported"];
+type KnowledgeSourceItemFailureCode = (typeof KNOWLEDGE_SOURCE_ITEM_FAILURE_CODES)[number];
+/**
+ * The state of an item of a synced source as the sync keeps it. It ends at `fetched`: from
+ * then on the item shows its document's state. `withdrawn` is out of search.
+ */
+declare const KNOWLEDGE_SOURCE_ITEM_STATES: readonly ["discovered", "fetched", "failed", "withdrawn"];
+type KnowledgeSourceItemState = (typeof KNOWLEDGE_SOURCE_ITEM_STATES)[number];
+/**
+ * How a sync of a source walks it: `initial` and `full` list every item below its folders,
+ * `changes` reads the source's change feed from the stored cursor, and `ingest` is one call
+ * of `knowledge.<id>.ingest` from a Workflow into its Workflow-fed source.
+ */
+declare const KNOWLEDGE_SYNC_MODES: readonly ["initial", "changes", "full", "ingest"];
+type KnowledgeSyncMode = (typeof KNOWLEDGE_SYNC_MODES)[number];
+declare const KNOWLEDGE_SYNC_RUN_STATES: readonly ["running", "done", "failed", "superseded"];
+type KnowledgeSyncRunState = (typeof KNOWLEDGE_SYNC_RUN_STATES)[number];
+/** What a sync run counts, in this order wherever it shows them. */
+declare const KNOWLEDGE_SYNC_COUNTS: readonly ["discovered", "added", "changed", "moved", "withdrawn", "failed", "skipped"];
+type KnowledgeSyncCount = (typeof KNOWLEDGE_SYNC_COUNTS)[number];
+/**
+ * The ranked lists a search on the built-in backend fuses: cosine distance to the query's
+ * embedding, German and English full text, and the words of a document's title and file name.
+ */
+declare const KNOWLEDGE_SEARCH_SIGNALS: readonly ["semantic", "keyword", "title"];
+type KnowledgeSearchSignal = (typeof KNOWLEDGE_SEARCH_SIGNALS)[number];
+declare const DATABASE_RELATION_TYPES: readonly ["table", "view", "materialized_view", "foreign_table"];
+type DatabaseRelationType = (typeof DATABASE_RELATION_TYPES)[number];
+declare const WORKFLOW_RUN_STATUSES: readonly ["continued", "queued", "running", "waiting", "done", "failed", "cancelled", "limit_reached"];
+type WorkflowRunStatus = (typeof WORKFLOW_RUN_STATUSES)[number];
+declare const WORKFLOW_STEP_TYPES: readonly ["trigger", "operation", "loop", "code", "output", "agent", "notify", "workflow"];
+type WorkflowStepType = (typeof WORKFLOW_STEP_TYPES)[number];
+/**
+ * The step types this release executes. The engine accepts no definition that names another,
+ * and the interface offers no other in its palette (workflow-canvas 9.6). A list of its own, so
+ * it can be narrower than `WORKFLOW_STEP_TYPES` while a known type is not run yet.
+ */
+declare const WORKFLOW_EXECUTED_STEP_TYPES: readonly ["trigger", "operation", "loop", "code", "output", "agent", "notify", "workflow"];
+declare const WORKFLOW_RESERVED_STEP_TYPES: readonly ["condition", "parallel"];
+type WorkflowReservedStepType = (typeof WORKFLOW_RESERVED_STEP_TYPES)[number];
+declare const WORKFLOW_TRIGGER_KINDS: readonly ["manual", "schedule", "parent"];
+type WorkflowTriggerKind = (typeof WORKFLOW_TRIGGER_KINDS)[number];
+declare const NOTIFY_CHANNELS: readonly ["inbox", "mail"];
+/**
+ * What an operation step's facts name as its source (`stepFacts`, workflow-canvas.md 9.8). A
+ * step on `mail.send` names its sender as `mail_sender`, with the sender's icon key as
+ * `service` (`MAIL_SENDER_SYSTEM_ICON`, or a Connection's service).
+ */
+declare const WORKFLOW_STEP_SOURCE_KINDS: readonly ["connection", "data_store", "knowledge_base", "workflow", "mail_sender", "other"];
+type WorkflowStepSourceKind = (typeof WORKFLOW_STEP_SOURCE_KINDS)[number];
+/**
+ * What an operation a step may call belongs to (`operations.list_callable`, WF-EDIT-3). `other`
+ * is an operation of the release.
+ */
+declare const OPERATION_SOURCE_KINDS: readonly ["connection", "data_store", "knowledge_base", "workflow", "other"];
+type OperationSourceKind = (typeof OPERATION_SOURCE_KINDS)[number];
+type NotifyChannel = (typeof NOTIFY_CHANNELS)[number];
+declare const PRINCIPAL_HOLDER_KINDS: readonly ["user", "service_principal"];
+type PrincipalHolderKind = (typeof PRINCIPAL_HOLDER_KINDS)[number];
+declare const ASSET_OWNER_KINDS: readonly ["instance", "workspace"];
+type AssetOwnerKind = (typeof ASSET_OWNER_KINDS)[number];
+declare const READING_POLICY_VALUES: readonly ["allow", "deny"];
+type ReadingPolicyValue = (typeof READING_POLICY_VALUES)[number];
+declare const CONNECTION_OPERATION_POLICIES: readonly ["deny", "approval"];
+type ConnectionOperationPolicy = (typeof CONNECTION_OPERATION_POLICIES)[number];
+declare const WORKFLOW_RUN_MODES: readonly ["live", "test"];
+type WorkflowRunMode = (typeof WORKFLOW_RUN_MODES)[number];
+/**
+ * Which revision of a Workflow a test run an App's draft started ran (DP-1): its draft, for a
+ * tester who may write it, or its published revision.
+ */
+declare const WORKFLOW_TEST_REVISIONS: readonly ["draft", "published"];
+type WorkflowTestRevision = (typeof WORKFLOW_TEST_REVISIONS)[number];
+declare const APP_ACTION_CALL_STATUSES: readonly ["done", "pending_approval"];
+type AppActionCallStatus = (typeof APP_ACTION_CALL_STATUSES)[number];
+declare const OPERATIONS_AUDIENCES: readonly ["workflow", "app"];
+type OperationsAudience = (typeof OPERATIONS_AUDIENCES)[number];
+declare const DECIDED_APPROVAL_REQUEST_STATUSES: readonly ["approved", "rejected", "changes_requested", "superseded", "withdrawn", "reverted"];
+type DecidedApprovalRequestStatus = (typeof DECIDED_APPROVAL_REQUEST_STATUSES)[number];
+declare const ENDED_APPROVAL_EXECUTIONS: readonly ["done", "failed", "interrupted", "refused", "expired", "held"];
+type EndedApprovalExecution = (typeof ENDED_APPROVAL_EXECUTIONS)[number];
+declare const GUARDRAIL_HIT_OUTCOMES: readonly ["warn", "require_approval", "block"];
+type GuardrailHitOutcome = (typeof GUARDRAIL_HIT_OUTCOMES)[number];
+declare const APPROVAL_CHECK_FAILURE_OUTCOMES: readonly ["warn", "block"];
+type ApprovalCheckFailureOutcome = (typeof APPROVAL_CHECK_FAILURE_OUTCOMES)[number];
+declare const THEME_MODES: readonly ["light", "dark"];
+type ThemeMode = (typeof THEME_MODES)[number];
+declare const USER_STATUSES: readonly ["active", "disabled"];
+type UserStatus = (typeof USER_STATUSES)[number];
+declare const MESSAGE_FINISH_STATUSES: readonly ["completed", "cancelled"];
+type MessageFinishStatus = (typeof MESSAGE_FINISH_STATUSES)[number];
+declare const ENDED_AGENT_RUN_STATUSES: readonly ["completed", "cancelled", "failed"];
+type EndedAgentRunStatus = (typeof ENDED_AGENT_RUN_STATUSES)[number];
+declare const ACTIVE_AGENT_RUN_STATUSES: readonly ["queued", "running", "waiting_for_decision", "waiting_for_subagents", "cancelling"];
+type ActiveAgentRunStatus = (typeof ACTIVE_AGENT_RUN_STATUSES)[number];
+declare const ARTIFACT_PREVIEW_IMAGE_MIME_TYPES: readonly ["image/png", "image/jpeg", "image/webp"];
+type ArtifactPreviewImageMimeType = (typeof ARTIFACT_PREVIEW_IMAGE_MIME_TYPES)[number];
+declare const LIVE_JOB_STATUSES: readonly ["queued", "running"];
+type LiveJobStatus = (typeof LIVE_JOB_STATUSES)[number];
+declare const FAILED_JOB_STATUSES: readonly ["failed", "dead"];
+type FailedJobStatus = (typeof FAILED_JOB_STATUSES)[number];
+declare const AUDIT_EVENT_STATUSES: readonly ["success", "failed", "denied"];
+type AuditEventStatus = (typeof AUDIT_EVENT_STATUSES)[number];
+declare const LISTED_DATA_STORE_STATUSES: readonly ["provisioning", "ready"];
+type ListedDataStoreStatus = (typeof LISTED_DATA_STORE_STATUSES)[number];
+declare const KNOWLEDGE_CHECK_STATUSES: readonly ["preparing", "ok", "needs_attention"];
+type KnowledgeCheckStatus = (typeof KNOWLEDGE_CHECK_STATUSES)[number];
+declare const WORKFLOW_STEP_RUN_STATUSES: readonly ["queued", "running", "waiting", "done", "failed", "cancelled"];
+type WorkflowStepRunStatus = (typeof WORKFLOW_STEP_RUN_STATUSES)[number];
+declare const WORKFLOW_ENDED_STATUSES: readonly ["continued", "done", "failed", "cancelled", "limit_reached"];
+type WorkflowEndedStatus = (typeof WORKFLOW_ENDED_STATUSES)[number];
+/** A released Managed File keeps its identity; original bytes live at the synced source. */
+declare const MANAGED_FILE_STATUSES: readonly ["available", "released", "deleted"];
+/** A Workflow automates a process unless it fills or processes data. */
+declare const WORKFLOW_KINDS: readonly ["process", "data"];
+type WorkflowKind = (typeof WORKFLOW_KINDS)[number];
+/** Wire formats for a streamed Workflow result dataset. */
+declare const WORKFLOW_DATASET_DOWNLOAD_FORMATS: readonly ["jsonl", "csv"];
+type WorkflowDatasetDownloadFormat = (typeof WORKFLOW_DATASET_DOWNLOAD_FORMATS)[number];
+/** Instance resources whose use may be inherited through workspace availability. */
+declare const WORKSPACE_USE_ASSET_KINDS: readonly ["knowledge_base", "connection"];
+/** Published assets that consume Connections or stored data. Agents hold tools separately. */
+declare const PUBLISHED_DATA_CONSUMER_KINDS: readonly ["app", "workflow", "knowledge_base"];
+type PublishedDataConsumerKind = (typeof PUBLISHED_DATA_CONSUMER_KINDS)[number];
+/** State of a scheduled prompt. */
+declare const SCHEDULED_START_STATES: readonly ["active", "paused"];
+/** Which revision answered an agent preview turn. */
+declare const AGENT_PREVIEW_SOURCES: readonly ["draft", "live"];
+
+/** A short operator declaration of where a provider processes data. */
+declare const providerRegionSchema: z.ZodString;
+declare const localizedStringSchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    en: z.ZodOptional<z.ZodString>;
+    de: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>]>;
+declare const SKILL_NAME_PATTERN: RegExp;
+declare const SKILL_NAME_RULE = "Skill name must start with a letter or a number and contain only letters, numbers, dots, underscores, or hyphens";
+/** How long a name of the public skill convention is at most, in characters. */
+declare const SKILL_PORTABLE_NAME_MAX_CHARS = 64;
+/** How long a description of the public skill convention is at most, in characters. */
+declare const SKILL_PORTABLE_DESCRIPTION_MAX_CHARS = 1024;
+/**
+ * What keeps a skill from being taken as it is into a tool that reads the public skill
+ * convention: a name that is not lowercase letters, digits and single hyphens or is longer
+ * than 64 characters, and a description longer than 1,024. Each is a warning with a code and
+ * refuses nothing: such a skill works here.
+ */
+declare function skillPortabilityIssues(skill: {
+    name?: unknown;
+    description?: unknown;
+}): {
+    code: string;
+    message: string;
+}[];
+declare const skillNameSchema: z.ZodString;
+declare const skillResourcePathSchema: z.ZodString;
+declare function skillResourceMediaTypeForPath(path: string): SkillResourceMediaType | undefined;
+declare const skillResourceConfigSchema: z.ZodObject<{
+    path: z.ZodString;
+    mediaType: z.ZodEnum<{
+        "text/markdown": "text/markdown";
+        "text/plain": "text/plain";
+        "application/json": "application/json";
+        "application/yaml": "application/yaml";
+    }>;
+    content: z.ZodString;
+}, z.core.$strip>;
+declare const skillStarterSchema: z.ZodObject<{
+    title: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        en: z.ZodOptional<z.ZodString>;
+        de: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>]>;
+    hint: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        en: z.ZodOptional<z.ZodString>;
+        de: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>]>>;
+    prompt: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        en: z.ZodOptional<z.ZodString>;
+        de: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>]>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+/**
+ * How much frontmatter a `SKILL.md` holds beside the keys the platform reads, as JSON, in
+ * characters. The keys of the public skill convention are a few lines.
+ */
+declare const SKILL_FRONTMATTER_MAX_BYTES = 8192;
+/** How deep the frontmatter of a `SKILL.md` nests at most. */
+declare const SKILL_FRONTMATTER_MAX_DEPTH = 8;
+/**
+ * The keys of the frontmatter of a `SKILL.md` that are fields of the skill. Every other key is
+ * kept apart as its further `frontmatter`.
+ */
+declare const SKILL_FRONTMATTER_FIELDS: readonly ["name", "title", "description", "summary", "starters"];
+/** One file of a skill's folder as its index names it: no content. */
+declare const skillFileEntrySchema: z.ZodObject<{
+    path: z.ZodString;
+    sha256: z.ZodString;
+    bytes: z.ZodNumber;
+    mediaType: z.ZodString;
+}, z.core.$strip>;
+declare const skillConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    title: z.ZodString;
+    description: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+    starters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        title: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            en: z.ZodOptional<z.ZodString>;
+            de: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>;
+        hint: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            en: z.ZodOptional<z.ZodString>;
+            de: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>>;
+        prompt: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            en: z.ZodOptional<z.ZodString>;
+            de: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>;
+        tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>>;
+    content: z.ZodString;
+    resources: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        mediaType: z.ZodEnum<{
+            "text/markdown": "text/markdown";
+            "text/plain": "text/plain";
+            "application/json": "application/json";
+            "application/yaml": "application/yaml";
+        }>;
+        content: z.ZodString;
+    }, z.core.$strip>>>;
+    files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        sha256: z.ZodString;
+        bytes: z.ZodNumber;
+        mediaType: z.ZodString;
+    }, z.core.$strip>>>;
+    frontmatter: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    origin: z.ZodOptional<z.ZodLiteral<"release">>;
+    icon: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * The frontmatter of a `SKILL.md`. `description` is required. `name` may be left to the folder
+ * and `title` to the content; `summary` and `starters` are read as the config holds them.
+ * Every other key is kept as it is and never refused: the public skill convention has keys of
+ * its own, such as `license` and `metadata`, and a library may add more. A skill file is the
+ * instance's own: what only a shipped skill carries, `origin` and `icon`, is no field of it.
+ */
+declare const skillFileFrontmatterSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    description: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+    starters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        title: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            en: z.ZodOptional<z.ZodString>;
+            de: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>;
+        hint: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            en: z.ZodOptional<z.ZodString>;
+            de: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>>;
+        prompt: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            en: z.ZodOptional<z.ZodString>;
+            de: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>;
+        tools: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>>;
+}, z.core.$loose>;
+declare const agentConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    displayName: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        en: z.ZodOptional<z.ZodString>;
+        de: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>]>;
+    description: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        en: z.ZodOptional<z.ZodString>;
+        de: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>]>>;
+    welcomeMessage: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        en: z.ZodOptional<z.ZodString>;
+        de: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>]>>;
+    welcomeSubtitle: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        en: z.ZodOptional<z.ZodString>;
+        de: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>]>>;
+    instructions: z.ZodString;
+    modelProviderId: z.ZodOptional<z.ZodString>;
+    modelBindingId: z.ZodOptional<z.ZodString>;
+    reasoningEffort: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        max: "max";
+    }>>;
+    fastMode: z.ZodOptional<z.ZodBoolean>;
+    userSelectableModelBindingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    modelReasoningEfforts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<{
+        none: "none";
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        max: "max";
+    }>>>;
+    maxSteps: z.ZodOptional<z.ZodNumber>;
+    toolNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    subagentNames: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    skillNames: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    knowledgeBases: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    initialPrompts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        title: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            en: z.ZodOptional<z.ZodString>;
+            de: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>;
+        prompt: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            en: z.ZodOptional<z.ZodString>;
+            de: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>;
+    }, z.core.$strip>>>;
+    shipped: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/** The id of a Workflow, which is the name of its asset: part of `workflow.<id>.start`. */
+declare const WORKFLOW_NAME_PATTERN: RegExp;
+declare const WORKFLOW_NAME_RULE = "A Workflow id starts with a lowercase letter and holds lowercase letters, digits, '_' and '-', at most 63 characters";
+/**
+ * What a revision of a Workflow holds as its config: the id the asset is addressed by,
+ * `workflow.yaml` as an object under `manifest`, and the files of its `steps/` folder under
+ * `files`, each with its path in the Workflow's folder and its text. This is the shape alone,
+ * which every stored revision keeps whatever a later engine accepts. Whether the engine of the
+ * instance runs the manifest and takes the files is asked of the engine when a revision is
+ * saved and when one is published.
+ */
+declare const workflowConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    manifest: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>;
+    files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        content: z.ZodString;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+type WorkflowAssetConfig = z.infer<typeof workflowConfigSchema>;
+
+/**
+ * Why a frontmatter is refused before its fields are read: for an alias, for its depth, or
+ * for the size of what it holds beside the name, the title and the description.
+ */
+type SkillFrontmatterRefusal = "skill_frontmatter_alias" | "skill_frontmatter_too_deep" | "skill_frontmatter_too_large";
+/**
+ * One thing that is wrong in a skill file: an invalid field by its path, or the place of the
+ * file, by line and column, where its frontmatter stops being YAML.
+ */
+interface SkillMarkdownIssue {
+    message: string;
+    path: PropertyKey[];
+    line?: number;
+    column?: number;
+}
+/**
+ * A skill file that cannot be read as a skill. `details.issues` names each invalid field, and
+ * `reason` what refused the frontmatter as a whole.
+ */
+declare class SkillMarkdownError extends Error {
+    readonly details?: {
+        issues: SkillMarkdownIssue[];
+    };
+    readonly reason?: SkillFrontmatterRefusal;
+    constructor(message: string, details?: {
+        issues: SkillMarkdownIssue[];
+    }, reason?: SkillFrontmatterRefusal);
+}
+/**
+ * Reads a `SKILL.md`: YAML frontmatter with title and description, then the content. A file
+ * without a name takes it from its folder, or from its own file name. `skillPath` separates
+ * its segments with `/`. This module runs in a browser too, so it reads the path as text.
+ */
+declare function parseSkillMarkdown(contents: string, skillFile: string, skillPath: string): unknown;
+/**
+ * The title a skill is shown under where its `SKILL.md` names none, as the public skill
+ * convention does not: the first Markdown heading of its content, or else its name with
+ * spaces for hyphens and underscores and a capital first letter.
+ */
+declare function deriveSkillTitle(name: string, content: string): string;
+/**
+ * A `SKILL.md` of a skill's config: what `parseSkillMarkdown` reads back as the same name,
+ * title, description, summary, starters, content and further frontmatter. A title the content
+ * or the name gives anyway is left out, as a file of the public skill convention has none. It
+ * is what a skill that was written as its config has for a file.
+ */
+declare function formatSkillMarkdown(skill: {
+    name: string;
+    title: string;
+    description: string;
+    summary?: string;
+    starters?: SkillStarterConfig[];
+    content: string;
+    frontmatter?: Record<string, unknown>;
+}): string;
+
+/**
+ * Why a value read from YAML is not taken, or nothing where it is. `alias`: an object or a
+ * list is in it more than once, which only an anchor with an alias or a merge makes; no file
+ * the platform reads needs one, so none is taken, and no count of them has to be right.
+ * `depth`: it nests deeper than `maxDepth`, where its reader names one; a file whose own
+ * rules say how deep it nests, as a Workflow's blocks do, names none. The walk is linear in
+ * what the file holds: it visits each object once and ends at the first one it meets twice.
+ */
+declare function yamlValueIssue(value: unknown, maxDepth?: number): "alias" | "depth" | undefined;
+/** The sentence a reader of a YAML file answers for an issue of its value. */
+declare function yamlValueIssueSentence(issue: "alias" | "depth", maxDepth?: number): string;
+
+/**
+ * How many values a YAML file holds once every alias is followed. It stops a file of a few
+ * hundred bytes whose aliases expand to a billion values ("billion laughs"), which hung the
+ * server on its first walk. The largest honest manifest holds a few thousand.
+ */
+declare const YAML_DATA_MAX_VALUES = 100000;
+type YamlDataIssueCode = "yaml_invalid" | "yaml_alias" | "yaml_too_deep" | "yaml_too_large" | "text_invalid";
+interface YamlDataIssue {
+    code: YamlDataIssueCode;
+    /** One sentence that names the file. */
+    message: string;
+    /** The line of the file, from 1, where the reader stopped. */
+    line?: number;
+    /** The column of that line, from 1. */
+    column?: number;
+}
+interface YamlDataOptions {
+    /**
+     * Refuses an anchor with an alias or a merge key, before anything walks the value. The
+     * readers of an asset's own files ask for it: none of those files needs one.
+     */
+    refuseAliases?: boolean;
+}
+type YamlDataResult = {
+    ok: true;
+    value: unknown;
+} | {
+    ok: false;
+    issue: YamlDataIssue;
+};
+/**
+ * Whether Postgres can store a text, in a `text` column or in `jsonb`: it holds neither a NUL
+ * character nor half of a surrogate pair. With the `u` flag a whole pair is one code point, so
+ * only half of one matches `\p{Surrogate}`.
+ */
+declare function isStorableText(text: string): boolean;
+/**
+ * Whether every text and key of a JSON-like value can be stored. It walks at most `maxValues`
+ * values, a value reached twice counted twice, and answers `too_large` beyond that. It walks
+ * without recursion, so no nesting ends it.
+ */
+declare function checkStorableTexts(value: unknown, maxValues: number): "storable" | "unstorable" | "too_large";
+/**
+ * Reads YAML that an author or an agent wrote as data: the schema knows JSON types alone and
+ * builds nothing else. A file that does not parse, nests too deep, expands too far through its
+ * aliases or holds text that cannot be stored is answered as an issue, never thrown.
+ */
+declare function readYamlData(text: string, file: string, options?: YamlDataOptions): YamlDataResult;
+/** A YAML file `loadYamlData` refused. `issue` says why. */
+declare class YamlDataError extends Error {
+    readonly issue: YamlDataIssue;
+    constructor(issue: YamlDataIssue);
+}
+/** `readYamlData` for a caller that reports a refused file as an error: it throws `YamlDataError`. */
+declare function loadYamlData(text: string, file: string): unknown;
+
+declare const knowledgeSyncInputSchema: z.ZodObject<{
+    source: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    mode: z.ZodOptional<z.ZodEnum<{
+        full: "full";
+        changes: "changes";
+    }>>;
+    confirm: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+type KnowledgeSyncInput = z.infer<typeof knowledgeSyncInputSchema>;
+/** What a sync run ends with: the result of its Operation Run, and a Workflow step's output. */
+declare const knowledgeSyncResultSchema: z.ZodObject<{
+    syncRunId: z.ZodString;
+    source: z.ZodString;
+    mode: z.ZodEnum<{
+        full: "full";
+        initial: "initial";
+        changes: "changes";
+        ingest: "ingest";
+    }>;
+    reason: z.ZodOptional<z.ZodEnum<{
+        cursor_expired: "cursor_expired";
+    }>>;
+    state: z.ZodEnum<{
+        failed: "failed";
+        running: "running";
+        done: "done";
+        superseded: "superseded";
+    }>;
+    counts: z.ZodObject<{
+        discovered: z.ZodNumber;
+        added: z.ZodNumber;
+        changed: z.ZodNumber;
+        moved: z.ZodNumber;
+        withdrawn: z.ZodNumber;
+        failed: z.ZodNumber;
+        skipped: z.ZodNumber;
+    }, z.core.$strict>;
+    bytesFetched: z.ZodNumber;
+    failureCode: z.ZodOptional<z.ZodEnum<{
+        knowledge_source_unreachable: "knowledge_source_unreachable";
+        knowledge_source_refused: "knowledge_source_refused";
+        knowledge_fetch_failed: "knowledge_fetch_failed";
+        knowledge_source_limit_reached: "knowledge_source_limit_reached";
+        knowledge_item_invalid: "knowledge_item_invalid";
+        knowledge_fetch_not_allowed: "knowledge_fetch_not_allowed";
+        knowledge_ingest_cancelled: "knowledge_ingest_cancelled";
+        knowledge_item_removed: "knowledge_item_removed";
+    }>>;
+    startedAt: z.ZodString;
+    endedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type KnowledgeSyncResult = z.infer<typeof knowledgeSyncResultSchema>;
+/**
+ * What the page shows of an item: its own state up to `fetched`, then its document's.
+ * "Gefunden", "Geladen", "Durchsuchbar", "Fehlgeschlagen", "Entfernt".
+ */
+declare const KNOWLEDGE_SOURCE_ITEM_SHOWN_STATES: readonly ["discovered", "fetched", "indexed", "failed", "withdrawn"];
+type KnowledgeSourceItemShownState = (typeof KNOWLEDGE_SOURCE_ITEM_SHOWN_STATES)[number];
+/**
+ * A first pass that stopped at 10,000 items and waits for one confirmation (KB-ISO-1b): what the
+ * whole pass holds and what it would cost, estimated from the listed sizes with a factor per
+ * format. Counts and sizes only, never a name.
+ */
+declare const knowledgeFirstPassConfirmationSchema: z.ZodObject<{
+    syncRunId: z.ZodString;
+    items: z.ZodNumber;
+    bytes: z.ZodNumber;
+    stop: z.ZodNumber;
+    tokens: z.ZodOptional<z.ZodObject<{
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+    }, z.core.$strict>>;
+    passages: z.ZodOptional<z.ZodObject<{
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+    }, z.core.$strict>>;
+    model: z.ZodOptional<z.ZodString>;
+    cost: z.ZodOptional<z.ZodObject<{
+        min: z.ZodNumber;
+        max: z.ZodNumber;
+        currency: z.ZodString;
+    }, z.core.$strict>>;
+    room: z.ZodOptional<z.ZodBoolean>;
+    storeBytes: z.ZodNumber;
+    addedBytes: z.ZodOptional<z.ZodNumber>;
+    limitBytes: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+type KnowledgeFirstPassConfirmation = z.infer<typeof knowledgeFirstPassConfirmationSchema>;
+declare const knowledgeSourcesOutputSchema: z.ZodObject<{
+    sources: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        id: z.ZodString;
+        connection: z.ZodString;
+        kind: z.ZodOptional<z.ZodLiteral<"connector">>;
+        items: z.ZodObject<{
+            discovered: z.ZodNumber;
+            fetched: z.ZodNumber;
+            indexed: z.ZodNumber;
+            failed: z.ZodNumber;
+            withdrawn: z.ZodNumber;
+        }, z.core.$strict>;
+        failures: z.ZodArray<z.ZodObject<{
+            code: z.ZodUnion<readonly [z.ZodEnum<{
+                knowledge_file_format_unsupported: "knowledge_file_format_unsupported";
+                knowledge_file_over_limit: "knowledge_file_over_limit";
+                knowledge_source_unreachable: "knowledge_source_unreachable";
+                knowledge_source_refused: "knowledge_source_refused";
+                knowledge_fetch_failed: "knowledge_fetch_failed";
+                knowledge_source_limit_reached: "knowledge_source_limit_reached";
+                knowledge_item_invalid: "knowledge_item_invalid";
+                knowledge_fetch_not_allowed: "knowledge_fetch_not_allowed";
+                knowledge_ingest_cancelled: "knowledge_ingest_cancelled";
+                knowledge_item_removed: "knowledge_item_removed";
+            }>, z.ZodEnum<{
+                knowledge_file_format_unsupported: "knowledge_file_format_unsupported";
+                knowledge_file_over_limit: "knowledge_file_over_limit";
+                knowledge_file_unreadable: "knowledge_file_unreadable";
+                knowledge_file_missing: "knowledge_file_missing";
+                knowledge_extraction_failed: "knowledge_extraction_failed";
+                knowledge_file_format_unavailable: "knowledge_file_format_unavailable";
+                knowledge_text_unreadable: "knowledge_text_unreadable";
+                knowledge_text_empty: "knowledge_text_empty";
+                knowledge_index_failed: "knowledge_index_failed";
+                knowledge_file_too_many_pages: "knowledge_file_too_many_pages";
+                knowledge_processor_output_invalid: "knowledge_processor_output_invalid";
+                knowledge_conversion_timeout: "knowledge_conversion_timeout";
+            }>]>;
+            count: z.ZodNumber;
+        }, z.core.$strict>>;
+        running: z.ZodOptional<z.ZodObject<{
+            syncRunId: z.ZodString;
+            mode: z.ZodEnum<{
+                full: "full";
+                initial: "initial";
+                changes: "changes";
+                ingest: "ingest";
+            }>;
+            startedAt: z.ZodString;
+            itemsPerMinute: z.ZodOptional<z.ZodNumber>;
+            estimatedEndAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        last: z.ZodOptional<z.ZodObject<{
+            syncRunId: z.ZodString;
+            source: z.ZodString;
+            mode: z.ZodEnum<{
+                full: "full";
+                initial: "initial";
+                changes: "changes";
+                ingest: "ingest";
+            }>;
+            reason: z.ZodOptional<z.ZodEnum<{
+                cursor_expired: "cursor_expired";
+            }>>;
+            state: z.ZodEnum<{
+                failed: "failed";
+                running: "running";
+                done: "done";
+                superseded: "superseded";
+            }>;
+            counts: z.ZodObject<{
+                discovered: z.ZodNumber;
+                added: z.ZodNumber;
+                changed: z.ZodNumber;
+                moved: z.ZodNumber;
+                withdrawn: z.ZodNumber;
+                failed: z.ZodNumber;
+                skipped: z.ZodNumber;
+            }, z.core.$strict>;
+            bytesFetched: z.ZodNumber;
+            failureCode: z.ZodOptional<z.ZodEnum<{
+                knowledge_source_unreachable: "knowledge_source_unreachable";
+                knowledge_source_refused: "knowledge_source_refused";
+                knowledge_fetch_failed: "knowledge_fetch_failed";
+                knowledge_source_limit_reached: "knowledge_source_limit_reached";
+                knowledge_item_invalid: "knowledge_item_invalid";
+                knowledge_fetch_not_allowed: "knowledge_fetch_not_allowed";
+                knowledge_ingest_cancelled: "knowledge_ingest_cancelled";
+                knowledge_item_removed: "knowledge_item_removed";
+            }>>;
+            startedAt: z.ZodString;
+            endedAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        confirmation: z.ZodOptional<z.ZodObject<{
+            syncRunId: z.ZodString;
+            items: z.ZodNumber;
+            bytes: z.ZodNumber;
+            stop: z.ZodNumber;
+            tokens: z.ZodOptional<z.ZodObject<{
+                min: z.ZodNumber;
+                max: z.ZodNumber;
+            }, z.core.$strict>>;
+            passages: z.ZodOptional<z.ZodObject<{
+                min: z.ZodNumber;
+                max: z.ZodNumber;
+            }, z.core.$strict>>;
+            model: z.ZodOptional<z.ZodString>;
+            cost: z.ZodOptional<z.ZodObject<{
+                min: z.ZodNumber;
+                max: z.ZodNumber;
+                currency: z.ZodString;
+            }, z.core.$strict>>;
+            room: z.ZodOptional<z.ZodBoolean>;
+            storeBytes: z.ZodNumber;
+            addedBytes: z.ZodOptional<z.ZodNumber>;
+            limitBytes: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        lastChangeAt: z.ZodOptional<z.ZodString>;
+        oldestOpenChangeAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>, z.ZodObject<{
+        id: z.ZodString;
+        kind: z.ZodLiteral<"workflow">;
+        workflowId: z.ZodString;
+        running: z.ZodOptional<z.ZodObject<{
+            syncRunId: z.ZodString;
+            mode: z.ZodEnum<{
+                full: "full";
+                initial: "initial";
+                changes: "changes";
+                ingest: "ingest";
+            }>;
+            startedAt: z.ZodString;
+            itemsPerMinute: z.ZodOptional<z.ZodNumber>;
+            estimatedEndAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        failures: z.ZodArray<z.ZodObject<{
+            code: z.ZodUnion<readonly [z.ZodEnum<{
+                knowledge_file_format_unsupported: "knowledge_file_format_unsupported";
+                knowledge_file_over_limit: "knowledge_file_over_limit";
+                knowledge_source_unreachable: "knowledge_source_unreachable";
+                knowledge_source_refused: "knowledge_source_refused";
+                knowledge_fetch_failed: "knowledge_fetch_failed";
+                knowledge_source_limit_reached: "knowledge_source_limit_reached";
+                knowledge_item_invalid: "knowledge_item_invalid";
+                knowledge_fetch_not_allowed: "knowledge_fetch_not_allowed";
+                knowledge_ingest_cancelled: "knowledge_ingest_cancelled";
+                knowledge_item_removed: "knowledge_item_removed";
+            }>, z.ZodEnum<{
+                knowledge_file_format_unsupported: "knowledge_file_format_unsupported";
+                knowledge_file_over_limit: "knowledge_file_over_limit";
+                knowledge_file_unreadable: "knowledge_file_unreadable";
+                knowledge_file_missing: "knowledge_file_missing";
+                knowledge_extraction_failed: "knowledge_extraction_failed";
+                knowledge_file_format_unavailable: "knowledge_file_format_unavailable";
+                knowledge_text_unreadable: "knowledge_text_unreadable";
+                knowledge_text_empty: "knowledge_text_empty";
+                knowledge_index_failed: "knowledge_index_failed";
+                knowledge_file_too_many_pages: "knowledge_file_too_many_pages";
+                knowledge_processor_output_invalid: "knowledge_processor_output_invalid";
+                knowledge_conversion_timeout: "knowledge_conversion_timeout";
+            }>]>;
+            count: z.ZodNumber;
+        }, z.core.$strict>>;
+        items: z.ZodObject<{
+            discovered: z.ZodNumber;
+            fetched: z.ZodNumber;
+            indexed: z.ZodNumber;
+            failed: z.ZodNumber;
+            withdrawn: z.ZodNumber;
+        }, z.core.$strict>;
+        last: z.ZodOptional<z.ZodObject<{
+            syncRunId: z.ZodString;
+            source: z.ZodString;
+            mode: z.ZodEnum<{
+                full: "full";
+                initial: "initial";
+                changes: "changes";
+                ingest: "ingest";
+            }>;
+            reason: z.ZodOptional<z.ZodEnum<{
+                cursor_expired: "cursor_expired";
+            }>>;
+            state: z.ZodEnum<{
+                failed: "failed";
+                running: "running";
+                done: "done";
+                superseded: "superseded";
+            }>;
+            counts: z.ZodObject<{
+                discovered: z.ZodNumber;
+                added: z.ZodNumber;
+                changed: z.ZodNumber;
+                moved: z.ZodNumber;
+                withdrawn: z.ZodNumber;
+                failed: z.ZodNumber;
+                skipped: z.ZodNumber;
+            }, z.core.$strict>;
+            bytesFetched: z.ZodNumber;
+            failureCode: z.ZodOptional<z.ZodEnum<{
+                knowledge_source_unreachable: "knowledge_source_unreachable";
+                knowledge_source_refused: "knowledge_source_refused";
+                knowledge_fetch_failed: "knowledge_fetch_failed";
+                knowledge_source_limit_reached: "knowledge_source_limit_reached";
+                knowledge_item_invalid: "knowledge_item_invalid";
+                knowledge_fetch_not_allowed: "knowledge_fetch_not_allowed";
+                knowledge_ingest_cancelled: "knowledge_ingest_cancelled";
+                knowledge_item_removed: "knowledge_item_removed";
+            }>>;
+            startedAt: z.ZodString;
+            endedAt: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        confirmation: z.ZodOptional<z.ZodObject<{
+            syncRunId: z.ZodString;
+            items: z.ZodNumber;
+            bytes: z.ZodNumber;
+            stop: z.ZodNumber;
+            tokens: z.ZodOptional<z.ZodObject<{
+                min: z.ZodNumber;
+                max: z.ZodNumber;
+            }, z.core.$strict>>;
+            passages: z.ZodOptional<z.ZodObject<{
+                min: z.ZodNumber;
+                max: z.ZodNumber;
+            }, z.core.$strict>>;
+            model: z.ZodOptional<z.ZodString>;
+            cost: z.ZodOptional<z.ZodObject<{
+                min: z.ZodNumber;
+                max: z.ZodNumber;
+                currency: z.ZodString;
+            }, z.core.$strict>>;
+            room: z.ZodOptional<z.ZodBoolean>;
+            storeBytes: z.ZodNumber;
+            addedBytes: z.ZodOptional<z.ZodNumber>;
+            limitBytes: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        lastChangeAt: z.ZodOptional<z.ZodString>;
+        oldestOpenChangeAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>]>>;
+}, z.core.$strict>;
+type KnowledgeSourcesOutput = z.infer<typeof knowledgeSourcesOutputSchema>;
+declare const knowledgeSourceItemsInputSchema: z.ZodObject<{
+    source: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    state: z.ZodOptional<z.ZodEnum<{
+        failed: "failed";
+        withdrawn: "withdrawn";
+        indexed: "indexed";
+        discovered: "discovered";
+        fetched: "fetched";
+    }>>;
+    failureCode: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+        knowledge_file_format_unsupported: "knowledge_file_format_unsupported";
+        knowledge_file_over_limit: "knowledge_file_over_limit";
+        knowledge_source_unreachable: "knowledge_source_unreachable";
+        knowledge_source_refused: "knowledge_source_refused";
+        knowledge_fetch_failed: "knowledge_fetch_failed";
+        knowledge_source_limit_reached: "knowledge_source_limit_reached";
+        knowledge_item_invalid: "knowledge_item_invalid";
+        knowledge_fetch_not_allowed: "knowledge_fetch_not_allowed";
+        knowledge_ingest_cancelled: "knowledge_ingest_cancelled";
+        knowledge_item_removed: "knowledge_item_removed";
+    }>, z.ZodEnum<{
+        knowledge_file_format_unsupported: "knowledge_file_format_unsupported";
+        knowledge_file_over_limit: "knowledge_file_over_limit";
+        knowledge_file_unreadable: "knowledge_file_unreadable";
+        knowledge_file_missing: "knowledge_file_missing";
+        knowledge_extraction_failed: "knowledge_extraction_failed";
+        knowledge_file_format_unavailable: "knowledge_file_format_unavailable";
+        knowledge_text_unreadable: "knowledge_text_unreadable";
+        knowledge_text_empty: "knowledge_text_empty";
+        knowledge_index_failed: "knowledge_index_failed";
+        knowledge_file_too_many_pages: "knowledge_file_too_many_pages";
+        knowledge_processor_output_invalid: "knowledge_processor_output_invalid";
+        knowledge_conversion_timeout: "knowledge_conversion_timeout";
+    }>]>>;
+    limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type KnowledgeSourceItemsInput = z.infer<typeof knowledgeSourceItemsInputSchema>;
+declare const knowledgeSourceItemsOutputSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        itemId: z.ZodString;
+        name: z.ZodString;
+        path: z.ZodString;
+        state: z.ZodEnum<{
+            failed: "failed";
+            withdrawn: "withdrawn";
+            indexed: "indexed";
+            discovered: "discovered";
+            fetched: "fetched";
+        }>;
+        failureCode: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+            knowledge_file_format_unsupported: "knowledge_file_format_unsupported";
+            knowledge_file_over_limit: "knowledge_file_over_limit";
+            knowledge_source_unreachable: "knowledge_source_unreachable";
+            knowledge_source_refused: "knowledge_source_refused";
+            knowledge_fetch_failed: "knowledge_fetch_failed";
+            knowledge_source_limit_reached: "knowledge_source_limit_reached";
+            knowledge_item_invalid: "knowledge_item_invalid";
+            knowledge_fetch_not_allowed: "knowledge_fetch_not_allowed";
+            knowledge_ingest_cancelled: "knowledge_ingest_cancelled";
+            knowledge_item_removed: "knowledge_item_removed";
+        }>, z.ZodEnum<{
+            knowledge_file_format_unsupported: "knowledge_file_format_unsupported";
+            knowledge_file_over_limit: "knowledge_file_over_limit";
+            knowledge_file_unreadable: "knowledge_file_unreadable";
+            knowledge_file_missing: "knowledge_file_missing";
+            knowledge_extraction_failed: "knowledge_extraction_failed";
+            knowledge_file_format_unavailable: "knowledge_file_format_unavailable";
+            knowledge_text_unreadable: "knowledge_text_unreadable";
+            knowledge_text_empty: "knowledge_text_empty";
+            knowledge_index_failed: "knowledge_index_failed";
+            knowledge_file_too_many_pages: "knowledge_file_too_many_pages";
+            knowledge_processor_output_invalid: "knowledge_processor_output_invalid";
+            knowledge_conversion_timeout: "knowledge_conversion_timeout";
+        }>]>>;
+        documentId: z.ZodOptional<z.ZodString>;
+        originLink: z.ZodOptional<z.ZodString>;
+        changedAt: z.ZodString;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type KnowledgeSourceItemsOutput = z.infer<typeof knowledgeSourceItemsOutputSchema>;
+/**
+ * KB-5c's retry, widened: documents by id, or items of a source by id, by failure code or all
+ * failed ones. A failed fetch is fetched again; a failed document of a synced source is
+ * fetched and indexed again, because its original is not kept.
+ */
+declare const knowledgeRetryInputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    documentIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    source: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    sourceItemIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    source: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    failureCode: z.ZodUnion<readonly [z.ZodEnum<{
+        knowledge_file_format_unsupported: "knowledge_file_format_unsupported";
+        knowledge_file_over_limit: "knowledge_file_over_limit";
+        knowledge_source_unreachable: "knowledge_source_unreachable";
+        knowledge_source_refused: "knowledge_source_refused";
+        knowledge_fetch_failed: "knowledge_fetch_failed";
+        knowledge_source_limit_reached: "knowledge_source_limit_reached";
+        knowledge_item_invalid: "knowledge_item_invalid";
+        knowledge_fetch_not_allowed: "knowledge_fetch_not_allowed";
+        knowledge_ingest_cancelled: "knowledge_ingest_cancelled";
+        knowledge_item_removed: "knowledge_item_removed";
+    }>, z.ZodEnum<{
+        knowledge_file_format_unsupported: "knowledge_file_format_unsupported";
+        knowledge_file_over_limit: "knowledge_file_over_limit";
+        knowledge_file_unreadable: "knowledge_file_unreadable";
+        knowledge_file_missing: "knowledge_file_missing";
+        knowledge_extraction_failed: "knowledge_extraction_failed";
+        knowledge_file_format_unavailable: "knowledge_file_format_unavailable";
+        knowledge_text_unreadable: "knowledge_text_unreadable";
+        knowledge_text_empty: "knowledge_text_empty";
+        knowledge_index_failed: "knowledge_index_failed";
+        knowledge_file_too_many_pages: "knowledge_file_too_many_pages";
+        knowledge_processor_output_invalid: "knowledge_processor_output_invalid";
+        knowledge_conversion_timeout: "knowledge_conversion_timeout";
+    }>]>;
+}, z.core.$strict>, z.ZodObject<{
+    source: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    all: z.ZodLiteral<true>;
+}, z.core.$strict>]>;
+type KnowledgeRetryInput = z.infer<typeof knowledgeRetryInputSchema>;
+declare const knowledgeRetryOutputSchema: z.ZodObject<{
+    documents: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        state: z.ZodEnum<{
+            failed: "failed";
+            pending: "pending";
+            indexed: "indexed";
+        }>;
+    }, z.core.$strict>>>;
+    queued: z.ZodNumber;
+    released: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+type KnowledgeRetryOutput = z.infer<typeof knowledgeRetryOutputSchema>;
+declare const knowledgeLocateInputSchema: z.ZodObject<{
+    sourceItemId: z.ZodString;
+}, z.core.$strict>;
+type KnowledgeLocateInput = z.infer<typeof knowledgeLocateInputSchema>;
+/** An item's state and times, and no content, name or path. */
+declare const knowledgeLocateOutputSchema: z.ZodObject<{
+    sourceItemId: z.ZodString;
+    source: z.ZodString;
+    itemId: z.ZodString;
+    state: z.ZodEnum<{
+        failed: "failed";
+        withdrawn: "withdrawn";
+        indexed: "indexed";
+        discovered: "discovered";
+        fetched: "fetched";
+    }>;
+    discoveredAt: z.ZodString;
+    fetchedAt: z.ZodOptional<z.ZodString>;
+    withdrawnAt: z.ZodOptional<z.ZodString>;
+    purgedAt: z.ZodOptional<z.ZodString>;
+    removedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type KnowledgeLocateOutput = z.infer<typeof knowledgeLocateOutputSchema>;
+/**
+ * The delete question of a Workflow (KBW-2c): the Knowledge Bases its source feeds, each with
+ * how many documents it holds there, which a delete withdraws. Those the reader may not open are
+ * counted only, by number of Knowledge Bases and documents, and never named.
+ */
+declare const knowledgeWorkflowSourcesOutputSchema: z.ZodObject<{
+    knowledgeBases: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        title: z.ZodString;
+        documents: z.ZodNumber;
+    }, z.core.$strict>>;
+    hidden: z.ZodObject<{
+        knowledgeBases: z.ZodNumber;
+        documents: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+type KnowledgeWorkflowSourcesOutput = z.infer<typeof knowledgeWorkflowSourcesOutputSchema>;
+
+/** Dataset checkpoints exposed in Workflow metadata; rows remain in object storage. */
+declare const WORKFLOW_DATASET_STATES: readonly ["writing", "complete", "deleted"];
+type WorkflowDatasetState = (typeof WORKFLOW_DATASET_STATES)[number];
+
+/** The reference kept in step data; rows live in the owning run's dataset. */
+declare const workflowDatasetReferenceSchema: z.ZodObject<{
+    $dataset: z.ZodString;
+    rowCount: z.ZodNumber;
+    bytes: z.ZodNumber;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+/** One row of a batch's failures dataset, preserving the input item for a retry. */
+declare const operationBatchFailureSchema: z.ZodObject<{
+    item: z.ZodJSONSchema;
+    code: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strict>;
+/** One failed item never fails the call or its neighbours. */
+declare const operationBatchResultSchema: z.ZodObject<{
+    done: z.ZodNumber;
+    failed: z.ZodNumber;
+    failures: z.ZodObject<{
+        $dataset: z.ZodString;
+        rowCount: z.ZodNumber;
+        bytes: z.ZodNumber;
+        offset: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+type OperationBatchResult = z.infer<typeof operationBatchResultSchema>;
+type OperationBatchFailure = z.infer<typeof operationBatchFailureSchema>;
+
+/** Reserved until CONN-DL: the Workflow's account must be allowed to use this Connection. */
+declare const knowledgeIngestFetchSchema: z.ZodObject<{
+    connection: z.ZodString;
+    operation: z.ZodString;
+    input: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+}, z.core.$strict>;
+/** Exactly one content, in both the TypeScript type and the runtime schema. */
+declare const knowledgeIngestItemSchema: z.ZodUnion<readonly [z.ZodObject<{
+    itemId: z.ZodString;
+    version: z.ZodString;
+    name: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    originLink: z.ZodOptional<z.ZodURL>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    fileId: z.ZodOptional<z.ZodNever>;
+    fetch: z.ZodOptional<z.ZodNever>;
+    text: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    itemId: z.ZodString;
+    version: z.ZodString;
+    name: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    originLink: z.ZodOptional<z.ZodURL>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    text: z.ZodOptional<z.ZodNever>;
+    fetch: z.ZodOptional<z.ZodNever>;
+    fileId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    itemId: z.ZodString;
+    version: z.ZodString;
+    name: z.ZodString;
+    path: z.ZodOptional<z.ZodString>;
+    originLink: z.ZodOptional<z.ZodURL>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    text: z.ZodOptional<z.ZodNever>;
+    fileId: z.ZodOptional<z.ZodNever>;
+    fetch: z.ZodObject<{
+        connection: z.ZodString;
+        operation: z.ZodString;
+        input: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    }, z.core.$strict>;
+}, z.core.$strict>]>;
+type KnowledgeIngestItem = z.infer<typeof knowledgeIngestItemSchema>;
+declare const knowledgeIngestInputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    items: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+        itemId: z.ZodString;
+        version: z.ZodString;
+        name: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        originLink: z.ZodOptional<z.ZodURL>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        fileId: z.ZodOptional<z.ZodNever>;
+        fetch: z.ZodOptional<z.ZodNever>;
+        text: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        itemId: z.ZodString;
+        version: z.ZodString;
+        name: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        originLink: z.ZodOptional<z.ZodURL>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        text: z.ZodOptional<z.ZodNever>;
+        fetch: z.ZodOptional<z.ZodNever>;
+        fileId: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        itemId: z.ZodString;
+        version: z.ZodString;
+        name: z.ZodString;
+        path: z.ZodOptional<z.ZodString>;
+        originLink: z.ZodOptional<z.ZodURL>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+        text: z.ZodOptional<z.ZodNever>;
+        fileId: z.ZodOptional<z.ZodNever>;
+        fetch: z.ZodObject<{
+            connection: z.ZodString;
+            operation: z.ZodString;
+            input: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        }, z.core.$strict>;
+    }, z.core.$strict>]>>;
+    complete: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>, z.ZodObject<{
+    dataset: z.ZodObject<{
+        $dataset: z.ZodString;
+        rowCount: z.ZodNumber;
+        bytes: z.ZodNumber;
+        offset: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    complete: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>]>;
+declare const knowledgeIngestOutputSchema: z.ZodObject<{
+    done: z.ZodNumber;
+    failed: z.ZodNumber;
+    failures: z.ZodObject<{
+        $dataset: z.ZodString;
+        rowCount: z.ZodNumber;
+        bytes: z.ZodNumber;
+        offset: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+    accepted: z.ZodNumber;
+    withdrawn: z.ZodNumber;
+}, z.core.$strict>;
+declare const knowledgeWithdrawInputSchema: z.ZodObject<{
+    itemIds: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+declare const knowledgeWithdrawOutputSchema: z.ZodObject<{
+    withdrawn: z.ZodNumber;
+}, z.core.$strict>;
+declare const knowledgePendingInputSchema: z.ZodObject<{
+    type: z.ZodOptional<z.ZodString>;
+    since: z.ZodOptional<z.ZodISODateTime>;
+    limit: z.ZodNumber;
+}, z.core.$strict>;
+declare const knowledgePendingRowSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+    contentHash: z.ZodString;
+    pages: z.ZodObject<{
+        $dataset: z.ZodString;
+        rowCount: z.ZodNumber;
+        bytes: z.ZodNumber;
+        offset: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+declare const knowledgePendingOutputSchema: z.ZodObject<{
+    documents: z.ZodObject<{
+        $dataset: z.ZodString;
+        rowCount: z.ZodNumber;
+        bytes: z.ZodNumber;
+        offset: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+/**
+ * A processor returns logical documents and page text (tables as Markdown), optional
+ * section boundaries and fields. Chunking and vectors remain the platform's. This is the
+ * single validator for built-ins and Workflow write-back; every refusal has the code
+ * knowledge_processor_output_invalid. Fields' declared JSON Schema is checked by PROC-1.
+ */
+declare const knowledgeProcessorOutputSchema: z.ZodObject<{
+    documents: z.ZodArray<z.ZodObject<{
+        pageFrom: z.ZodNumber;
+        pageTo: z.ZodNumber;
+    }, z.core.$strict>>;
+    sections: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        pageFrom: z.ZodNumber;
+        pageTo: z.ZodNumber;
+        title: z.ZodString;
+    }, z.core.$strict>>>;
+    fields: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+    pages: z.ZodArray<z.ZodObject<{
+        page: z.ZodNumber;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type KnowledgeProcessorOutput = z.infer<typeof knowledgeProcessorOutputSchema>;
+declare const knowledgePutProcessedInputSchema: z.ZodObject<{
+    items: z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+        documentId: z.ZodString;
+        contentHash: z.ZodString;
+        workflowRevision: z.ZodString;
+        output: z.ZodObject<{
+            documents: z.ZodArray<z.ZodObject<{
+                pageFrom: z.ZodNumber;
+                pageTo: z.ZodNumber;
+            }, z.core.$strict>>;
+            sections: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                pageFrom: z.ZodNumber;
+                pageTo: z.ZodNumber;
+                title: z.ZodString;
+            }, z.core.$strict>>>;
+            fields: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            pages: z.ZodObject<{
+                $dataset: z.ZodString;
+                rowCount: z.ZodNumber;
+                bytes: z.ZodNumber;
+                offset: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>, z.ZodObject<{
+        $dataset: z.ZodString;
+        rowCount: z.ZodNumber;
+        bytes: z.ZodNumber;
+        offset: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>]>;
+}, z.core.$strict>;
+declare const knowledgeFieldValueSchema: z.ZodJSONSchema;
+declare const knowledgeExtractFieldsInputSchema: z.ZodObject<{
+    documentId: z.ZodString;
+    schema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+}, z.core.$strict>;
+declare const knowledgeExtractFieldsOutputSchema: z.ZodObject<{
+    droppedFields: z.ZodOptional<z.ZodNumber>;
+    failedFields: z.ZodOptional<z.ZodNumber>;
+    path: z.ZodString;
+    date: z.ZodNullable<z.ZodISODate>;
+    type: z.ZodString;
+    fields: z.ZodRecord<z.ZodString, z.ZodObject<{
+        value: z.ZodJSONSchema;
+        page: z.ZodNumber;
+        quote: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Created by the first ingest, never authored in kb.yaml; the id cannot collide with a connector source. */
+declare const knowledgeWorkflowSourceSchema: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodLiteral<"workflow">;
+    workflowId: z.ZodString;
+}, z.core.$strict>;
+type KnowledgeWorkflowSource = z.infer<typeof knowledgeWorkflowSourceSchema>;
+/** Contract inventory; completion, batch and dataset are present only where the table declares them. */
+declare const knowledgeWriteContracts: {
+    readonly ingest: {
+        readonly description: "Ingest items or a dataset into the calling data Workflow's source; complete promises a full pass, withdrawn only after the run succeeds.";
+        readonly inputSchema: z.ZodUnion<readonly [z.ZodObject<{
+            items: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                itemId: z.ZodString;
+                version: z.ZodString;
+                name: z.ZodString;
+                path: z.ZodOptional<z.ZodString>;
+                originLink: z.ZodOptional<z.ZodURL>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+                fileId: z.ZodOptional<z.ZodNever>;
+                fetch: z.ZodOptional<z.ZodNever>;
+                text: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                itemId: z.ZodString;
+                version: z.ZodString;
+                name: z.ZodString;
+                path: z.ZodOptional<z.ZodString>;
+                originLink: z.ZodOptional<z.ZodURL>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+                text: z.ZodOptional<z.ZodNever>;
+                fetch: z.ZodOptional<z.ZodNever>;
+                fileId: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                itemId: z.ZodString;
+                version: z.ZodString;
+                name: z.ZodString;
+                path: z.ZodOptional<z.ZodString>;
+                originLink: z.ZodOptional<z.ZodURL>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+                text: z.ZodOptional<z.ZodNever>;
+                fileId: z.ZodOptional<z.ZodNever>;
+                fetch: z.ZodObject<{
+                    connection: z.ZodString;
+                    operation: z.ZodString;
+                    input: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+                }, z.core.$strict>;
+            }, z.core.$strict>]>>;
+            complete: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>, z.ZodObject<{
+            dataset: z.ZodObject<{
+                $dataset: z.ZodString;
+                rowCount: z.ZodNumber;
+                bytes: z.ZodNumber;
+                offset: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>;
+            complete: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>]>;
+        readonly outputSchema: z.ZodObject<{
+            done: z.ZodNumber;
+            failed: z.ZodNumber;
+            failures: z.ZodObject<{
+                $dataset: z.ZodString;
+                rowCount: z.ZodNumber;
+                bytes: z.ZodNumber;
+                offset: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>;
+            accepted: z.ZodNumber;
+            withdrawn: z.ZodNumber;
+        }, z.core.$strict>;
+        readonly effect: "changing";
+        readonly right: "knowledge_base.ingest";
+        readonly keyLevel: "write";
+        readonly completion: "async";
+        readonly batch: true;
+    };
+    readonly withdraw: {
+        readonly description: "Withdraw item ids from the calling Workflow's source; removed from search immediately.";
+        readonly inputSchema: z.ZodObject<{
+            itemIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        readonly outputSchema: z.ZodObject<{
+            withdrawn: z.ZodNumber;
+        }, z.core.$strict>;
+        readonly effect: "changing";
+        readonly right: "knowledge_base.ingest";
+        readonly keyLevel: "write";
+    };
+    readonly pending: {
+        readonly description: "Pull pending documents by type and time as a dataset; page text is another dataset reference.";
+        readonly inputSchema: z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            since: z.ZodOptional<z.ZodISODateTime>;
+            limit: z.ZodNumber;
+        }, z.core.$strict>;
+        readonly outputSchema: z.ZodObject<{
+            documents: z.ZodObject<{
+                $dataset: z.ZodString;
+                rowCount: z.ZodNumber;
+                bytes: z.ZodNumber;
+                offset: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        readonly rowSchema: z.ZodObject<{
+            id: z.ZodString;
+            type: z.ZodString;
+            contentHash: z.ZodString;
+            pages: z.ZodObject<{
+                $dataset: z.ZodString;
+                rowCount: z.ZodNumber;
+                bytes: z.ZodNumber;
+                offset: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        readonly effect: "reading";
+        readonly right: "knowledge_base.read";
+        readonly keyLevel: "read";
+        readonly dataset: true;
+    };
+    readonly put_processed: {
+        readonly description: "Write processor output by document, content hash and Workflow revision, with pages as a dataset reference like pending; the platform validates, chunks and indexes it, with per-item outcomes.";
+        readonly inputSchema: z.ZodObject<{
+            items: z.ZodUnion<readonly [z.ZodArray<z.ZodObject<{
+                documentId: z.ZodString;
+                contentHash: z.ZodString;
+                workflowRevision: z.ZodString;
+                output: z.ZodObject<{
+                    documents: z.ZodArray<z.ZodObject<{
+                        pageFrom: z.ZodNumber;
+                        pageTo: z.ZodNumber;
+                    }, z.core.$strict>>;
+                    sections: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        pageFrom: z.ZodNumber;
+                        pageTo: z.ZodNumber;
+                        title: z.ZodString;
+                    }, z.core.$strict>>>;
+                    fields: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+                    pages: z.ZodObject<{
+                        $dataset: z.ZodString;
+                        rowCount: z.ZodNumber;
+                        bytes: z.ZodNumber;
+                        offset: z.ZodOptional<z.ZodNumber>;
+                    }, z.core.$strict>;
+                }, z.core.$strict>;
+            }, z.core.$strict>>, z.ZodObject<{
+                $dataset: z.ZodString;
+                rowCount: z.ZodNumber;
+                bytes: z.ZodNumber;
+                offset: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>;
+        readonly outputSchema: z.ZodObject<{
+            done: z.ZodNumber;
+            failed: z.ZodNumber;
+            failures: z.ZodObject<{
+                $dataset: z.ZodString;
+                rowCount: z.ZodNumber;
+                bytes: z.ZodNumber;
+                offset: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        readonly effect: "changing";
+        readonly right: "knowledge_base.ingest";
+        readonly keyLevel: "write";
+        readonly batch: true;
+    };
+    readonly extract_fields: {
+        readonly description: "Extract fields by schema through the approved model binding within the Knowledge Base budget; each value carries page and quote evidence.";
+        readonly inputSchema: z.ZodObject<{
+            documentId: z.ZodString;
+            schema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+        }, z.core.$strict>;
+        readonly outputSchema: z.ZodObject<{
+            droppedFields: z.ZodOptional<z.ZodNumber>;
+            failedFields: z.ZodOptional<z.ZodNumber>;
+            path: z.ZodString;
+            date: z.ZodNullable<z.ZodISODate>;
+            type: z.ZodString;
+            fields: z.ZodRecord<z.ZodString, z.ZodObject<{
+                value: z.ZodJSONSchema;
+                page: z.ZodNumber;
+                quote: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        readonly effect: "reading";
+        readonly right: "knowledge_base.read";
+        readonly keyLevel: "read";
+    };
+};
+/** Records rules belong to the Data Store; kb.yaml must never hold them. */
+declare const knowledgeRecordsRefusalSchema: z.ZodOptional<z.ZodNever>;
+type KnowledgeIngestInput = z.infer<typeof knowledgeIngestInputSchema>;
+type KnowledgeIngestOutput = z.infer<typeof knowledgeIngestOutputSchema>;
+type KnowledgeIngestFetch = z.infer<typeof knowledgeIngestFetchSchema>;
+type KnowledgeWithdrawInput = z.infer<typeof knowledgeWithdrawInputSchema>;
+type KnowledgeWithdrawOutput = z.infer<typeof knowledgeWithdrawOutputSchema>;
+type KnowledgePendingInput = z.infer<typeof knowledgePendingInputSchema>;
+type KnowledgePendingRow = z.infer<typeof knowledgePendingRowSchema>;
+type KnowledgePendingOutput = z.infer<typeof knowledgePendingOutputSchema>;
+type KnowledgePutProcessedInput = z.infer<typeof knowledgePutProcessedInputSchema>;
+type KnowledgeExtractFieldsInput = z.infer<typeof knowledgeExtractFieldsInputSchema>;
+type KnowledgeExtractFieldsOutput = z.infer<typeof knowledgeExtractFieldsOutputSchema>;
+
+/** Paging settings shared by accepted Connections and their API view. */
+declare const operationPagingSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    by: z.ZodEnum<{
+        page: "page";
+        offset: "offset";
+    }>;
+    param: z.ZodString;
+    sizeParam: z.ZodString;
+    size: z.ZodNumber;
+    start: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    by: z.ZodEnum<{
+        cursor: "cursor";
+        next_link: "next_link";
+    }>;
+    param: z.ZodString;
+    cursor: z.ZodString;
+}, z.core.$strict>], "by">;
+type OperationPaging = z.infer<typeof operationPagingSchema>;
+
+/** Published data Workflows that fill or process an asset, with unreadable names withheld. */
+declare const workflowDataFlowsSchema: z.ZodObject<{
+    fills: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        title: z.ZodString;
+    }, z.core.$strip>>;
+    processes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        title: z.ZodString;
+    }, z.core.$strip>>;
+    hidden: z.ZodObject<{
+        fills: z.ZodNumber;
+        processes: z.ZodNumber;
+    }, z.core.$strip>;
+    truncated: z.ZodBoolean;
+}, z.core.$strip>;
+
+declare const RECORDS_PROPOSE_MAX_ITEMS_PER_CALL = 1000;
+declare const RECORDS_PROPOSE_MAX_FIELDS_PER_ITEM = 1000;
+declare const RECORDS_FLAGGED_MAX_ITEMS_PER_PAGE = 10000;
+declare const dataStoreRecordsRuleSchema: z.ZodObject<{
+    table: z.ZodString;
+    key: z.ZodUnion<readonly [z.ZodObject<{
+        column: z.ZodString;
+        fromPath: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        column: z.ZodString;
+        fromField: z.ZodString;
+    }, z.core.$strict>]>;
+    precedence: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    review: z.ZodPrefault<z.ZodObject<{
+        always: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>>;
+    retainWithoutSource: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+type DataStoreRecordsRule = z.infer<typeof dataStoreRecordsRuleSchema>;
+/** A necessary condition, never a model confidence score or proof of correctness. */
+declare const recordEvidenceResultSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    status: z.ZodLiteral<"passed">;
+}, z.core.$strict>, z.ZodObject<{
+    status: z.ZodLiteral<"failed">;
+    reason: z.ZodEnum<{
+        page_not_found: "page_not_found";
+        quote_not_found: "quote_not_found";
+        value_not_parsed: "value_not_parsed";
+    }>;
+}, z.core.$strict>], "status">;
+type RecordEvidenceResult = z.infer<typeof recordEvidenceResultSchema>;
+declare const RECORD_FIELD_STATES: readonly ["extracted", "confirmed", "corrected", "conflict"];
+/** Why a field waits for a person in "Prüfen". */
+declare const RECORD_FLAG_REASONS: readonly ["conflict", "not_evidenced", "confirmation_required", "key_unresolved"];
+declare const RECORD_FIELD_FAILURE_CODES: readonly ["record_field_unknown"];
+declare const dataStoreRecordProposalItemSchema: z.ZodObject<{
+    knowledgeBaseId: z.ZodString;
+    documentId: z.ZodString;
+    kind: z.ZodString;
+    documentDate: z.ZodNullable<z.ZodISODate>;
+    path: z.ZodOptional<z.ZodString>;
+    fields: z.ZodArray<z.ZodObject<{
+        value: z.ZodJSONSchema;
+        page: z.ZodNumber;
+        quote: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type DataStoreRecordProposalItem = z.infer<typeof dataStoreRecordProposalItemSchema>;
+declare const dataStoreRecordsProposeInputSchema: z.ZodObject<{
+    table: z.ZodString;
+    items: z.ZodArray<z.ZodObject<{
+        knowledgeBaseId: z.ZodString;
+        documentId: z.ZodString;
+        kind: z.ZodString;
+        documentDate: z.ZodNullable<z.ZodISODate>;
+        path: z.ZodOptional<z.ZodString>;
+        fields: z.ZodArray<z.ZodObject<{
+            value: z.ZodJSONSchema;
+            page: z.ZodNumber;
+            quote: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type DataStoreRecordsProposeInput = z.infer<typeof dataStoreRecordsProposeInputSchema>;
+declare const dataStoreRecordsDecideInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    table: z.ZodString;
+    key: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    field: z.ZodString;
+    documentId: z.ZodOptional<z.ZodString>;
+    knowledgeBaseId: z.ZodOptional<z.ZodString>;
+    action: z.ZodLiteral<"confirm">;
+}, z.core.$strict>, z.ZodObject<{
+    table: z.ZodString;
+    key: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    field: z.ZodString;
+    documentId: z.ZodOptional<z.ZodString>;
+    knowledgeBaseId: z.ZodOptional<z.ZodString>;
+    action: z.ZodLiteral<"correct">;
+    value: z.ZodJSONSchema;
+}, z.core.$strict>, z.ZodObject<{
+    table: z.ZodString;
+    key: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+    field: z.ZodString;
+    action: z.ZodLiteral<"assign">;
+    documentId: z.ZodString;
+    knowledgeBaseId: z.ZodString;
+}, z.core.$strict>], "action">;
+type DataStoreRecordsDecideInput = z.infer<typeof dataStoreRecordsDecideInputSchema>;
+declare const dataStoreRecordsDecideOutputSchema: z.ZodObject<{
+    decided: z.ZodLiteral<true>;
+}, z.core.$strict>;
+declare const dataStoreRecordsFlaggedInputSchema: z.ZodObject<{
+    table: z.ZodOptional<z.ZodString>;
+    cursor: z.ZodOptional<z.ZodString>;
+    limit: z.ZodNumber;
+}, z.core.$strict>;
+declare const dataStoreRecordFieldSchema: z.ZodObject<{
+    value: z.ZodJSONSchema;
+    page: z.ZodNumber;
+    quote: z.ZodString;
+    name: z.ZodString;
+    correctedValue: z.ZodNullable<z.ZodJSONSchema>;
+    table: z.ZodString;
+    key: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+    knowledgeBaseId: z.ZodString;
+    documentId: z.ZodString;
+    kind: z.ZodString;
+    documentDate: z.ZodNullable<z.ZodISODate>;
+    extractedAt: z.ZodISODateTime;
+    evidence: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        status: z.ZodLiteral<"passed">;
+    }, z.core.$strict>, z.ZodObject<{
+        status: z.ZodLiteral<"failed">;
+        reason: z.ZodEnum<{
+            page_not_found: "page_not_found";
+            quote_not_found: "quote_not_found";
+            value_not_parsed: "value_not_parsed";
+        }>;
+    }, z.core.$strict>], "status">;
+    state: z.ZodEnum<{
+        confirmed: "confirmed";
+        extracted: "extracted";
+        corrected: "corrected";
+        conflict: "conflict";
+    }>;
+    decidedBy: z.ZodNullable<z.ZodString>;
+    decidedAt: z.ZodNullable<z.ZodISODateTime>;
+}, z.core.$strict>;
+type DataStoreRecordField = z.infer<typeof dataStoreRecordFieldSchema>;
+declare const dataStoreRecordsFlaggedOutputSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        value: z.ZodJSONSchema;
+        page: z.ZodNumber;
+        quote: z.ZodString;
+        name: z.ZodString;
+        correctedValue: z.ZodNullable<z.ZodJSONSchema>;
+        table: z.ZodString;
+        key: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+        knowledgeBaseId: z.ZodString;
+        documentId: z.ZodString;
+        kind: z.ZodString;
+        documentDate: z.ZodNullable<z.ZodISODate>;
+        extractedAt: z.ZodISODateTime;
+        evidence: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            status: z.ZodLiteral<"passed">;
+        }, z.core.$strict>, z.ZodObject<{
+            status: z.ZodLiteral<"failed">;
+            reason: z.ZodEnum<{
+                page_not_found: "page_not_found";
+                quote_not_found: "quote_not_found";
+                value_not_parsed: "value_not_parsed";
+            }>;
+        }, z.core.$strict>], "status">;
+        state: z.ZodEnum<{
+            confirmed: "confirmed";
+            extracted: "extracted";
+            corrected: "corrected";
+            conflict: "conflict";
+        }>;
+        decidedBy: z.ZodNullable<z.ZodString>;
+        decidedAt: z.ZodNullable<z.ZodISODateTime>;
+        reason: z.ZodEnum<{
+            conflict: "conflict";
+            not_evidenced: "not_evidenced";
+            confirmation_required: "confirmation_required";
+            key_unresolved: "key_unresolved";
+        }>;
+        document: z.ZodOptional<z.ZodObject<{
+            knowledgeBase: z.ZodString;
+            fileName: z.ZodString;
+        }, z.core.$strict>>;
+        decidedByName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    nextCursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type ColumnType = (typeof DATA_STORE_SCALAR_TYPES)[number];
+interface RecordColumn {
+    name: string;
+    type: ColumnType | `${ColumnType}[]` | "other";
+    nullable: boolean;
+    generated?: boolean;
+}
+/** Whether a column takes the value, as a proposal and a person's correction are checked. */
+declare function recordColumnTakes(column: RecordColumn, value: unknown): boolean;
+/**
+ * Validate a whole item before any candidate or customer row is written. The batch writer
+ * maps this refusal to record_field_unknown for that item and continues with other items.
+ * Types come from the store catalog, never from the caller's extraction schema.
+ */
+declare function proposalItemSchemaFor(columns: readonly RecordColumn[]): z.ZodObject<{
+    knowledgeBaseId: z.ZodString;
+    documentId: z.ZodString;
+    kind: z.ZodString;
+    documentDate: z.ZodNullable<z.ZodISODate>;
+    path: z.ZodOptional<z.ZodString>;
+    fields: z.ZodArray<z.ZodObject<{
+        value: z.ZodJSONSchema;
+        page: z.ZodNumber;
+        quote: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+/** Contracts only: REC-1a/1b/2 register the implementations, not REC-0. */
+declare const dataStoreRecordsContracts: {
+    readonly propose: {
+        readonly description: "Propose extracted fields with Knowledge Base/document/page/quote evidence. Validate each whole item against the published table before writing; failures are per item. Send at most 1000 items per call and 1000 fields per item; split larger work into batches. Merge by evidence precedence, then document date; unresolved keys and evidence go to review.";
+        readonly inputSchema: z.ZodObject<{
+            table: z.ZodString;
+            items: z.ZodArray<z.ZodObject<{
+                knowledgeBaseId: z.ZodString;
+                documentId: z.ZodString;
+                kind: z.ZodString;
+                documentDate: z.ZodNullable<z.ZodISODate>;
+                path: z.ZodOptional<z.ZodString>;
+                fields: z.ZodArray<z.ZodObject<{
+                    value: z.ZodJSONSchema;
+                    page: z.ZodNumber;
+                    quote: z.ZodString;
+                    name: z.ZodString;
+                }, z.core.$strict>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        readonly outputSchema: z.ZodObject<{
+            done: z.ZodNumber;
+            failed: z.ZodNumber;
+            failures: z.ZodObject<{
+                $dataset: z.ZodString;
+                rowCount: z.ZodNumber;
+                bytes: z.ZodNumber;
+                offset: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>;
+        }, z.core.$strict>;
+        readonly itemSchemaFor: typeof proposalItemSchemaFor;
+        readonly effect: "changing";
+        readonly right: "data_store.records";
+        readonly keyLevel: "write";
+        readonly batch: true;
+    };
+    readonly decide: {
+        readonly description: "Confirm or correct a field against its evidence, or assign a document to an object key. Decisions are pinned; audit table/field/action/actor only, never the value.";
+        readonly inputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            table: z.ZodString;
+            key: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            field: z.ZodString;
+            documentId: z.ZodOptional<z.ZodString>;
+            knowledgeBaseId: z.ZodOptional<z.ZodString>;
+            action: z.ZodLiteral<"confirm">;
+        }, z.core.$strict>, z.ZodObject<{
+            table: z.ZodString;
+            key: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            field: z.ZodString;
+            documentId: z.ZodOptional<z.ZodString>;
+            knowledgeBaseId: z.ZodOptional<z.ZodString>;
+            action: z.ZodLiteral<"correct">;
+            value: z.ZodJSONSchema;
+        }, z.core.$strict>, z.ZodObject<{
+            table: z.ZodString;
+            key: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>;
+            field: z.ZodString;
+            action: z.ZodLiteral<"assign">;
+            documentId: z.ZodString;
+            knowledgeBaseId: z.ZodString;
+        }, z.core.$strict>], "action">;
+        readonly outputSchema: z.ZodObject<{
+            decided: z.ZodLiteral<true>;
+        }, z.core.$strict>;
+        readonly effect: "changing";
+        readonly right: "data_store.records";
+        readonly keyLevel: "write";
+    };
+    readonly flagged: {
+        readonly description: "Page through fields needing review, up to 10000 per call; pass nextCursor as cursor for the next page. Check Knowledge Base access before showing any document citation; the store right alone does not grant access to source documents.";
+        readonly inputSchema: z.ZodObject<{
+            table: z.ZodOptional<z.ZodString>;
+            cursor: z.ZodOptional<z.ZodString>;
+            limit: z.ZodNumber;
+        }, z.core.$strict>;
+        readonly outputSchema: z.ZodObject<{
+            items: z.ZodArray<z.ZodObject<{
+                value: z.ZodJSONSchema;
+                page: z.ZodNumber;
+                quote: z.ZodString;
+                name: z.ZodString;
+                correctedValue: z.ZodNullable<z.ZodJSONSchema>;
+                table: z.ZodString;
+                key: z.ZodNullable<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+                knowledgeBaseId: z.ZodString;
+                documentId: z.ZodString;
+                kind: z.ZodString;
+                documentDate: z.ZodNullable<z.ZodISODate>;
+                extractedAt: z.ZodISODateTime;
+                evidence: z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    status: z.ZodLiteral<"passed">;
+                }, z.core.$strict>, z.ZodObject<{
+                    status: z.ZodLiteral<"failed">;
+                    reason: z.ZodEnum<{
+                        page_not_found: "page_not_found";
+                        quote_not_found: "quote_not_found";
+                        value_not_parsed: "value_not_parsed";
+                    }>;
+                }, z.core.$strict>], "status">;
+                state: z.ZodEnum<{
+                    confirmed: "confirmed";
+                    extracted: "extracted";
+                    corrected: "corrected";
+                    conflict: "conflict";
+                }>;
+                decidedBy: z.ZodNullable<z.ZodString>;
+                decidedAt: z.ZodNullable<z.ZodISODateTime>;
+                reason: z.ZodEnum<{
+                    conflict: "conflict";
+                    not_evidenced: "not_evidenced";
+                    confirmation_required: "confirmation_required";
+                    key_unresolved: "key_unresolved";
+                }>;
+                document: z.ZodOptional<z.ZodObject<{
+                    knowledgeBase: z.ZodString;
+                    fileName: z.ZodString;
+                }, z.core.$strict>>;
+                decidedByName: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            nextCursor: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        readonly effect: "reading";
+        readonly right: "data_store.records";
+        readonly keyLevel: "read";
+    };
+};
+type DataStoreRecordsDecideOutput = z.infer<typeof dataStoreRecordsDecideOutputSchema>;
+type DataStoreRecordsFlaggedInput = z.infer<typeof dataStoreRecordsFlaggedInputSchema>;
+type DataStoreRecordsFlaggedOutput = z.infer<typeof dataStoreRecordsFlaggedOutputSchema>;
+
+/** The UTC counter windows, metrics and scopes a model usage refusal may name. */
+declare const MODEL_USAGE_LIMIT_PERIODS: readonly ["day", "month"];
+declare const MODEL_USAGE_LIMIT_METRICS: readonly ["modelCallCount", "tokens", "costMicros"];
+declare const MODEL_USAGE_LIMIT_SCOPES: readonly ["instance", "user", "system", "workspace"];
+/**
+ * Where an admin sets a spend limit (LU-2): the instance, one default for every shared
+ * workspace and one for every user, and a value for one workspace or one user that replaces
+ * that default.
+ */
+declare const USAGE_SPEND_LIMIT_LEVELS: readonly ["instance", "workspace_default", "workspace", "user_default", "user"];
+/** The limit that refused a call: its period, what it counts, and whose counter it is. */
+interface ModelUsageRefusal {
+    period: (typeof MODEL_USAGE_LIMIT_PERIODS)[number];
+    metric: (typeof MODEL_USAGE_LIMIT_METRICS)[number];
+    /**
+     * `user`: the person's own calls. `system`: the calls the product makes for a person, or
+     * those no person made. `workspace`: the calls inside one shared workspace. `instance`: the
+     * spend budget everyone shares.
+     */
+    scope: (typeof MODEL_USAGE_LIMIT_SCOPES)[number];
+}
+/** The workspace key every Personal Workspace shares in the usage sums (LU-3): one row. */
+declare const PERSONAL_WORKSPACES_KEY = "personal";
+/** What the Breakdown of the Usage page groups by (LU-3, limits spec 3.3, view 2). */
+declare const USAGE_BREAKDOWN_DIMENSIONS: readonly ["workspace", "agent", "app", "workflow", "model", "origin"];
+/**
+ * Where usage came from (limits spec 3.2): a conversation, an App, a Workflow, Knowledge Base
+ * ingestion, or a call the product made for itself, such as a title or a guardrail check.
+ */
+declare const USAGE_ORIGINS: readonly ["conversation", "app", "workflow", "knowledge_base", "system"];
+
+/**
+ * The JSON Schema `format` of a string field that takes Markdown, such as the body of
+ * `mail.send`. In such a field a referenced list of strings joins as a bulleted list and a
+ * list of flat records as a table, and every referenced value is escaped as Markdown text.
+ */
+declare const WORKFLOW_TEXT_FORMAT_MARKDOWN = "markdown";
+/** The most parts one joined text has. */
+declare const WORKFLOW_TEXT_MAX_PARTS = 100;
+/** A referenced list in a Markdown field joins as at most this many rows; more is refused. */
+declare const WORKFLOW_MARKDOWN_MAX_ROWS = 100;
+/** A referenced list of records joins as a table of at most this many columns. */
+declare const WORKFLOW_MARKDOWN_MAX_COLUMNS = 8;
+
+/** The platform operation. It exists on an instance only while `outbound.enabled` is true. */
+declare const MAIL_SEND_OPERATION = "mail.send";
+/** The resource kind of a sender. Its right is `mail_sender.use`, on one sender. */
+declare const MAIL_SENDER_RESOURCE_KIND = "mail_sender";
+declare const MAIL_SENDER_USE_ACTION = "mail_sender.use";
+/** The instance's own mailer (`infrastructure.mail`), the only sender until MAIL-M365S. */
+declare const MAIL_SENDER_SYSTEM = "system";
+/** The prefix of a Connection sender (MAIL-M365S, MAIL-M365P): `connection.<name>`. */
+declare const MAIL_SENDER_CONNECTION_PREFIX = "connection.";
+/**
+ * The icon key the step shows for the system sender. An assembly may register the instance's
+ * mark under it; without one the generic mail icon stands. A Connection sender shows its
+ * Connection's `service` icon. The transport (Mailjet, capture, SMTP) never has an icon.
+ */
+declare const MAIL_SENDER_SYSTEM_ICON = "system-mail";
+/** The template `packages/mail` renders a mail of `mail.send` in. */
+declare const MAIL_WORKFLOW_MESSAGE_TEMPLATE = "workflow-message";
+/** Addresses of one mail once `{ workspace }` recipients are expanded, over to, cc and bcc. */
+declare const MAIL_SEND_MAX_ADDRESSES = 50;
+declare const MAIL_SUBJECT_MAX_LENGTH = 200;
+declare const MAIL_BODY_MAX_BYTES: number;
+declare const MAIL_SENDER_NAME_MAX_LENGTH = 80;
+/** The longest address RFC 5321 lets through a path. */
+declare const MAIL_ADDRESS_MAX_LENGTH = 254;
+/** `infrastructure.mail.outbound.limits` unless release config sets them; only it raises them. */
+declare const MAIL_OUTBOUND_DEFAULT_LIMITS: {
+    readonly perWorkflowPerHour: 200;
+    readonly perInstancePerDay: 1000;
+};
+/** One language's legal footer (§ 37a HGB company details), as plain text. */
+declare const MAIL_OUTBOUND_FOOTER_MAX_LENGTH = 2000;
+/** `mail.sent` names at most this many distinct recipient domains, then counts the rest. */
+declare const MAIL_AUDIT_MAX_DOMAINS = 10;
+/** Reserved for MAIL-4: Managed Files and datasets of the run, together. */
+declare const MAIL_ATTACHMENTS_MAX_FILES = 10;
+declare const MAIL_ATTACHMENTS_MAX_BYTES: number;
+/**
+ * Why `mail.send` refused or failed a mail, as `details.reason` of a VALIDATION_FAILED and as
+ * the code of a failed step. None is retried.
+ * - `recipient_not_allowed`: an address outside `recipientDomains` that is not a person of the
+ *   instance, or such a `replyTo`. `details.domain` names its domain. Nothing is sent to any
+ *   recipient of the mail.
+ * - `no_recipient`: `to` named people or workspaces, and none of them has an address.
+ * - `workspace_not_allowed`: a `{ workspace }` recipient is not a Shared Workspace the author
+ *   of the mail can see: they are no member of it and no instance admin (MAIL-2). The author
+ *   is the person who saves, publishes or tests the Workflow, or for whom an agent calls; in a
+ *   published run, its publisher. Nothing is sent and no member of it is named.
+ * - `mail_rejected`: the provider refused the mail before accepting it. `details.providerCode`
+ *   holds the provider's own code; its text is never kept.
+ * A transient failure is not one of these: a refused connection is retried by the step's
+ * attempts, and an answer lost after the request left is `operation_interrupted`.
+ */
+declare const MAIL_SEND_ERROR_CODES: {
+    readonly recipientNotAllowed: "recipient_not_allowed";
+    readonly noRecipient: "no_recipient";
+    readonly mailRejected: "mail_rejected";
+    readonly workspaceNotAllowed: "workspace_not_allowed";
+};
+type MailSendErrorCode = (typeof MAIL_SEND_ERROR_CODES)[keyof typeof MAIL_SEND_ERROR_CODES];
+declare const MAIL_SEND_REFUSAL_REASONS: readonly ["recipient_not_allowed", "no_recipient", "mail_rejected", "workspace_not_allowed"];
+/** `details` of a refused `mail.send`: the one refused domain, or the provider's code. */
+declare const mailSendRefusalDetailsSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    reason: z.ZodLiteral<"recipient_not_allowed">;
+    domain: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    reason: z.ZodLiteral<"no_recipient">;
+}, z.core.$strict>, z.ZodObject<{
+    reason: z.ZodLiteral<"workspace_not_allowed">;
+}, z.core.$strict>, z.ZodObject<{
+    reason: z.ZodLiteral<"mail_rejected">;
+    providerCode: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>], "reason">;
+type MailSendRefusalDetails = z.infer<typeof mailSendRefusalDetailsSchema>;
+/** A user or workspace id, as `NOTICE_ID_PATTERN` of core reads it. */
+declare const MAIL_RECIPIENT_ID_PATTERN: RegExp;
+/** One address as written. Its domain is compared without regard to case. */
+declare const mailAddressSchema: z.ZodEmail;
+/**
+ * A domain of `recipientDomains`, lowercase: `kanzlei.de` matches that domain only,
+ * `*.kanzlei.de` its subdomains and not the domain itself. `*` alone admits every address.
+ */
+declare const MAIL_RECIPIENT_DOMAIN_PATTERN: RegExp;
+declare const MAIL_RECIPIENT_DOMAINS_ANY = "*";
+declare const mailRecipientDomainSchema: z.ZodString;
+/**
+ * Which sender the mail goes out as. `system` until MAIL-M365S; `connection.<name>` is
+ * reserved and refused with `not_supported_yet`.
+ */
+declare const mailSenderIdSchema: z.ZodUnion<readonly [z.ZodLiteral<"system">, z.ZodTemplateLiteral<`connection.${string}`>]>;
+type MailSenderId = typeof MAIL_SENDER_SYSTEM | `connection.${string}`;
+/**
+ * One recipient of a literal list: an address, a person of the instance by id, or a workspace,
+ * which stands for its members. A person or member without an address is skipped and counted.
+ */
+declare const mailRecipientSchema: z.ZodUnion<readonly [z.ZodObject<{
+    address: z.ZodEmail;
+}, z.core.$strict>, z.ZodObject<{
+    user: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    workspace: z.ZodString;
+}, z.core.$strict>]>;
+type MailSendRecipient = z.infer<typeof mailRecipientSchema>;
+declare const mailRecipientListSchema: z.ZodUnion<readonly [z.ZodEmail, z.ZodArray<z.ZodUnion<readonly [z.ZodEmail, z.ZodUnion<readonly [z.ZodObject<{
+    address: z.ZodEmail;
+}, z.core.$strict>, z.ZodObject<{
+    user: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    workspace: z.ZodString;
+}, z.core.$strict>]>, z.ZodObject<{
+    email: z.ZodEmail;
+}, z.core.$loose>]>>]>;
+type MailSendRecipientList = z.infer<typeof mailRecipientListSchema>;
+/**
+ * What `cc` and `bcc` take: as `to`, and an empty list too, since a referenced list of copy
+ * recipients may hold nobody and the mail still goes to `to`.
+ */
+declare const mailCopyRecipientListSchema: z.ZodUnion<readonly [z.ZodEmail, z.ZodArray<z.ZodUnion<readonly [z.ZodEmail, z.ZodUnion<readonly [z.ZodObject<{
+    address: z.ZodEmail;
+}, z.core.$strict>, z.ZodObject<{
+    user: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    workspace: z.ZodString;
+}, z.core.$strict>]>, z.ZodObject<{
+    email: z.ZodEmail;
+}, z.core.$loose>]>>]>;
+/** One address, or a person of the instance. The recipient rule applies to it as to `to`. */
+declare const mailReplyToSchema: z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+    address: z.ZodEmail;
+}, z.core.$strict>, z.ZodObject<{
+    user: z.ZodString;
+}, z.core.$strict>]>;
+/** One line of 1 to 200 characters with something besides spaces. */
+declare const mailSubjectSchema: z.ZodString;
+/**
+ * The author's Markdown, rendered on the server: no raw HTML, no image, links over `https`,
+ * `http` and `mailto` only. `format: markdown` is what makes a mapped field join lists and
+ * tables (EW-TEXT) and escape every referenced value, and a field mapped as one reference show
+ * each link's address after its label (MAIL-2).
+ */
+declare const mailBodySchema: z.ZodString;
+/** The display name on the From line. The address stays the sender's. */
+declare const mailSenderNameSchema: z.ZodString;
+/**
+ * The input of `mail.send`, as the operation reads it after a step's mapping is resolved. Each
+ * field of a step's mapping takes a literal, a reference or, for the strings, text joined
+ * from parts (EW-TEXT). `attachments` arrives with MAIL-4 and is refused until then.
+ */
+declare const mailSendInputSchema: z.ZodObject<{
+    sender: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"system">, z.ZodTemplateLiteral<`connection.${string}`>]>>;
+    to: z.ZodUnion<readonly [z.ZodEmail, z.ZodArray<z.ZodUnion<readonly [z.ZodEmail, z.ZodUnion<readonly [z.ZodObject<{
+        address: z.ZodEmail;
+    }, z.core.$strict>, z.ZodObject<{
+        user: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        workspace: z.ZodString;
+    }, z.core.$strict>]>, z.ZodObject<{
+        email: z.ZodEmail;
+    }, z.core.$loose>]>>]>;
+    cc: z.ZodOptional<z.ZodUnion<readonly [z.ZodEmail, z.ZodArray<z.ZodUnion<readonly [z.ZodEmail, z.ZodUnion<readonly [z.ZodObject<{
+        address: z.ZodEmail;
+    }, z.core.$strict>, z.ZodObject<{
+        user: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        workspace: z.ZodString;
+    }, z.core.$strict>]>, z.ZodObject<{
+        email: z.ZodEmail;
+    }, z.core.$loose>]>>]>>;
+    bcc: z.ZodOptional<z.ZodUnion<readonly [z.ZodEmail, z.ZodArray<z.ZodUnion<readonly [z.ZodEmail, z.ZodUnion<readonly [z.ZodObject<{
+        address: z.ZodEmail;
+    }, z.core.$strict>, z.ZodObject<{
+        user: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        workspace: z.ZodString;
+    }, z.core.$strict>]>, z.ZodObject<{
+        email: z.ZodEmail;
+    }, z.core.$loose>]>>]>>;
+    subject: z.ZodString;
+    body: z.ZodString;
+    senderName: z.ZodOptional<z.ZodString>;
+    replyTo: z.ZodOptional<z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+        address: z.ZodEmail;
+    }, z.core.$strict>, z.ZodObject<{
+        user: z.ZodString;
+    }, z.core.$strict>]>>;
+    locale: z.ZodOptional<z.ZodEnum<{
+        en: "en";
+        de: "de";
+    }>>;
+}, z.core.$strict>;
+type MailSendInput = z.infer<typeof mailSendInputSchema>;
+type MailSendInputFields = z.input<typeof mailSendInputSchema>;
+/**
+ * What a live or test send answers: counts and the provider's message id, never an address.
+ * `skipped` counts people and members without an address. `test` marks "Run live once",
+ * which sent to the tester alone.
+ */
+declare const mailSendOutputSchema: z.ZodObject<{
+    sentAt: z.ZodISODateTime;
+    messageId: z.ZodOptional<z.ZodString>;
+    recipients: z.ZodObject<{
+        to: z.ZodNumber;
+        cc: z.ZodNumber;
+        bcc: z.ZodNumber;
+    }, z.core.$strict>;
+    skipped: z.ZodNumber;
+    test: z.ZodOptional<z.ZodLiteral<true>>;
+}, z.core.$strict>;
+type MailSendOutput = z.infer<typeof mailSendOutputSchema>;
+/** A recipient as a preview names it: a person by name, an address as written. */
+declare const mailPreviewRecipientSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        address: "address";
+        person: "person";
+    }>;
+    label: z.ZodString;
+}, z.core.$strict>;
+type MailPreviewRecipient = z.infer<typeof mailPreviewRecipientSchema>;
+/**
+ * The mail as it would go out, checked against the recipient rule. It is step data of a test
+ * run and the confirmation card's content; it is never audit data.
+ */
+declare const mailSendPreviewSchema: z.ZodObject<{
+    from: z.ZodObject<{
+        name: z.ZodString;
+        address: z.ZodEmail;
+    }, z.core.$strict>;
+    replyTo: z.ZodOptional<z.ZodEmail>;
+    to: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            address: "address";
+            person: "person";
+        }>;
+        label: z.ZodString;
+    }, z.core.$strict>>;
+    cc: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            address: "address";
+            person: "person";
+        }>;
+        label: z.ZodString;
+    }, z.core.$strict>>;
+    bcc: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            address: "address";
+            person: "person";
+        }>;
+        label: z.ZodString;
+    }, z.core.$strict>>;
+    skipped: z.ZodNumber;
+    subject: z.ZodString;
+    html: z.ZodString;
+    text: z.ZodString;
+}, z.core.$strict>;
+type MailSendPreview = z.infer<typeof mailSendPreviewSchema>;
+/** What a simulated call (a test run's `dry_run`, an agent preview turn) answers. */
+declare const mailSendSimulatedOutputSchema: z.ZodObject<{
+    simulated: z.ZodLiteral<true>;
+    preview: z.ZodObject<{
+        from: z.ZodObject<{
+            name: z.ZodString;
+            address: z.ZodEmail;
+        }, z.core.$strict>;
+        replyTo: z.ZodOptional<z.ZodEmail>;
+        to: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                address: "address";
+                person: "person";
+            }>;
+            label: z.ZodString;
+        }, z.core.$strict>>;
+        cc: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                address: "address";
+                person: "person";
+            }>;
+            label: z.ZodString;
+        }, z.core.$strict>>;
+        bcc: z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                address: "address";
+                person: "person";
+            }>;
+            label: z.ZodString;
+        }, z.core.$strict>>;
+        skipped: z.ZodNumber;
+        subject: z.ZodString;
+        html: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+type MailSendSimulatedOutput = z.infer<typeof mailSendSimulatedOutputSchema>;
+/**
+ * The params of the template `workflow-message`, per mail. The frame (the instance's name,
+ * embedded logo, accent colour and `outbound.footer`) is the instance's and not a param; the
+ * envelope (From name, to, cc, bcc, Reply-To) is the message's and not a param either.
+ * `markdown` arrives with every joined referenced value already escaped, and a body mapped as
+ * one reference with each link's address shown. `test` puts "[Test]" before
+ * the subject and lists whom the mail would have reached.
+ */
+declare const workflowMessageMailParamsSchema: z.ZodObject<{
+    subject: z.ZodString;
+    markdown: z.ZodString;
+    sentBy: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"workflow">;
+        workflowName: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        kind: z.ZodLiteral<"agent">;
+        onBehalfOf: z.ZodString;
+    }, z.core.$strict>], "kind">;
+    test: z.ZodOptional<z.ZodObject<{
+        intendedRecipients: z.ZodObject<{
+            to: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    address: "address";
+                    person: "person";
+                }>;
+                label: z.ZodString;
+            }, z.core.$strict>>;
+            cc: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    address: "address";
+                    person: "person";
+                }>;
+                label: z.ZodString;
+            }, z.core.$strict>>;
+            bcc: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    address: "address";
+                    person: "person";
+                }>;
+                label: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+type WorkflowMessageMailParams = z.infer<typeof workflowMessageMailParamsSchema>;
+/**
+ * What the step facts of a `mail.send` step carry beside `source { kind: "mail_sender", title,
+ * service }`, where `service` is the icon key: the sender's address and the instance's
+ * `recipientDomains`, so the panel marks an address a run would refuse.
+ */
+declare const workflowMailSenderFactSchema: z.ZodObject<{
+    sender: z.ZodString;
+    title: z.ZodString;
+    icon: z.ZodString;
+    address: z.ZodEmail;
+    recipientDomains: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+type WorkflowMailSenderFact = z.infer<typeof workflowMailSenderFactSchema>;
+/** Contract only: MAIL-1 registers the operation while `outbound.enabled` is true. */
+declare const mailSendContract: {
+    readonly name: "mail.send";
+    readonly description: "Send one e-mail as a sender of the instance (system unless set). Recipients are addresses, people of the instance and workspaces; an address outside the instance's recipient domains is refused. The body is Markdown in the instance's frame. A test run previews the mail and sends nothing.";
+    readonly inputSchema: z.ZodObject<{
+        sender: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"system">, z.ZodTemplateLiteral<`connection.${string}`>]>>;
+        to: z.ZodUnion<readonly [z.ZodEmail, z.ZodArray<z.ZodUnion<readonly [z.ZodEmail, z.ZodUnion<readonly [z.ZodObject<{
+            address: z.ZodEmail;
+        }, z.core.$strict>, z.ZodObject<{
+            user: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            workspace: z.ZodString;
+        }, z.core.$strict>]>, z.ZodObject<{
+            email: z.ZodEmail;
+        }, z.core.$loose>]>>]>;
+        cc: z.ZodOptional<z.ZodUnion<readonly [z.ZodEmail, z.ZodArray<z.ZodUnion<readonly [z.ZodEmail, z.ZodUnion<readonly [z.ZodObject<{
+            address: z.ZodEmail;
+        }, z.core.$strict>, z.ZodObject<{
+            user: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            workspace: z.ZodString;
+        }, z.core.$strict>]>, z.ZodObject<{
+            email: z.ZodEmail;
+        }, z.core.$loose>]>>]>>;
+        bcc: z.ZodOptional<z.ZodUnion<readonly [z.ZodEmail, z.ZodArray<z.ZodUnion<readonly [z.ZodEmail, z.ZodUnion<readonly [z.ZodObject<{
+            address: z.ZodEmail;
+        }, z.core.$strict>, z.ZodObject<{
+            user: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            workspace: z.ZodString;
+        }, z.core.$strict>]>, z.ZodObject<{
+            email: z.ZodEmail;
+        }, z.core.$loose>]>>]>>;
+        subject: z.ZodString;
+        body: z.ZodString;
+        senderName: z.ZodOptional<z.ZodString>;
+        replyTo: z.ZodOptional<z.ZodUnion<readonly [z.ZodEmail, z.ZodObject<{
+            address: z.ZodEmail;
+        }, z.core.$strict>, z.ZodObject<{
+            user: z.ZodString;
+        }, z.core.$strict>]>>;
+        locale: z.ZodOptional<z.ZodEnum<{
+            en: "en";
+            de: "de";
+        }>>;
+    }, z.core.$strict>;
+    readonly outputSchema: z.ZodObject<{
+        sentAt: z.ZodISODateTime;
+        messageId: z.ZodOptional<z.ZodString>;
+        recipients: z.ZodObject<{
+            to: z.ZodNumber;
+            cc: z.ZodNumber;
+            bcc: z.ZodNumber;
+        }, z.core.$strict>;
+        skipped: z.ZodNumber;
+        test: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strict>;
+    readonly simulatedOutputSchema: z.ZodObject<{
+        simulated: z.ZodLiteral<true>;
+        preview: z.ZodObject<{
+            from: z.ZodObject<{
+                name: z.ZodString;
+                address: z.ZodEmail;
+            }, z.core.$strict>;
+            replyTo: z.ZodOptional<z.ZodEmail>;
+            to: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    address: "address";
+                    person: "person";
+                }>;
+                label: z.ZodString;
+            }, z.core.$strict>>;
+            cc: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    address: "address";
+                    person: "person";
+                }>;
+                label: z.ZodString;
+            }, z.core.$strict>>;
+            bcc: z.ZodArray<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    address: "address";
+                    person: "person";
+                }>;
+                label: z.ZodString;
+            }, z.core.$strict>>;
+            skipped: z.ZodNumber;
+            subject: z.ZodString;
+            html: z.ZodString;
+            text: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    readonly effect: "changing";
+    readonly changeClass: "outward";
+    readonly right: "mail_sender.use";
+    readonly resourceKind: "mail_sender";
+    readonly events: {
+        readonly after: "mail.sent";
+        readonly refused: "mail.refused";
+    };
+    readonly errorCodes: {
+        readonly recipientNotAllowed: "recipient_not_allowed";
+        readonly noRecipient: "no_recipient";
+        readonly mailRejected: "mail_rejected";
+        readonly workspaceNotAllowed: "workspace_not_allowed";
+    };
+};
+
+/** One instance's data separation dimension. SCOPE-1 serves one dimension. */
+declare const dataScopeNameSchema: z.ZodString;
+declare const dataScopesSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    label: z.ZodString;
+    valueType: z.ZodLiteral<"text">;
+}, z.core.$strict>>;
+type DataScopes = z.infer<typeof dataScopesSchema>;
+declare const scopeAssignmentInputSchema: z.ZodObject<{
+    dimension: z.ZodString;
+    holderKind: z.ZodEnum<{
+        user: "user";
+        service_principal: "service_principal";
+        group: "group";
+    }>;
+    holderId: z.ZodString;
+    effect: z.ZodEnum<{
+        allow: "allow";
+        deny: "deny";
+    }>;
+    values: z.ZodUnion<readonly [z.ZodLiteral<"all">, z.ZodArray<z.ZodString>]>;
+}, z.core.$strict>;
+type ScopeAssignmentInput = z.infer<typeof scopeAssignmentInputSchema>;
+declare const scopedTablesSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    scope: z.ZodRecord<z.ZodString, z.ZodString>;
+}, z.core.$strict>>;
+type ScopedTables = z.infer<typeof scopedTablesSchema>;
+
+/** The longest comment. */
+declare const FEEDBACK_TEXT_MAX_LENGTH = 4000;
+/** The longest machine-written summary and category a workflow stores on a comment. */
+declare const FEEDBACK_SUMMARY_MAX_LENGTH = 1000;
+declare const FEEDBACK_CATEGORY_MAX_LENGTH = 60;
+/** The longest note a reviewer leaves when marking a comment handled. */
+declare const FEEDBACK_NOTE_MAX_LENGTH = 2000;
+/**
+ * What a comment is about. `message` in the first version; an App and a Workflow run follow
+ * (LU-6), each with a reference of its own.
+ */
+declare const FEEDBACK_SUBJECT_KINDS: readonly ["message"];
+type FeedbackSubjectKind = (typeof FEEDBACK_SUBJECT_KINDS)[number];
+declare const FEEDBACK_STATES: readonly ["new", "handled"];
+type FeedbackState = (typeof FEEDBACK_STATES)[number];
+
+/** The source of an operation. A source the caller may not read is told by its kind alone. */
+declare const operationSourceSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        workflow: "workflow";
+        other: "other";
+        connection: "connection";
+        data_store: "data_store";
+        knowledge_base: "knowledge_base";
+    }>;
+    title: z.ZodOptional<z.ZodString>;
+    service: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type OperationSourceView = z.infer<typeof operationSourceSchema>;
+declare const callableOperationSchema: z.ZodObject<{
+    name: z.ZodString;
+    effect: z.ZodEnum<{
+        reading: "reading";
+        changing: "changing";
+    }>;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    source: z.ZodObject<{
+        kind: z.ZodEnum<{
+            workflow: "workflow";
+            other: "other";
+            connection: "connection";
+            data_store: "data_store";
+            knowledge_base: "knowledge_base";
+        }>;
+        title: z.ZodOptional<z.ZodString>;
+        service: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    available: z.ZodBoolean;
+    inputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+type CallableOperationView = z.infer<typeof callableOperationSchema>;
+/** One page of callable operations. */
+declare const callableOperationsPageSchema: z.ZodObject<{
+    operations: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        effect: z.ZodEnum<{
+            reading: "reading";
+            changing: "changing";
+        }>;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        source: z.ZodObject<{
+            kind: z.ZodEnum<{
+                workflow: "workflow";
+                other: "other";
+                connection: "connection";
+                data_store: "data_store";
+                knowledge_base: "knowledge_base";
+            }>;
+            title: z.ZodOptional<z.ZodString>;
+            service: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        available: z.ZodBoolean;
+        inputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        outputSchema: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodOptional<z.ZodString>;
+    truncated: z.ZodBoolean;
+}, z.core.$strip>;
+type CallableOperationsPage = z.infer<typeof callableOperationsPageSchema>;
+
+export { ACCESS_SOURCES, ACTIONS, ACTIVE_AGENT_RUN_STATUSES, ADMINISTERED_USER_STATUSES, AGENT_AVAILABILITY_MODES, AGENT_EDITABLE_FIELDS, AGENT_PREVIEW_SOURCES, AGENT_RUN_FAILURE_CATEGORIES, AGENT_RUN_STATUSES, AGENT_STARTERS_MAX, AGENT_USE_SETTINGS, API_CREDENTIAL_SCOPES, APPROVAL_CHECK_FAILURE_OUTCOMES, APPROVAL_CHECK_STATUSES, APPROVAL_EXECUTIONS, APPROVAL_REQUEST_STATUSES, APP_ACTION_CALL_STATUSES, APP_AUDIENCES, APP_ERROR_CODES, APP_ERROR_STATUS_CODES, APP_MODES, ARTIFACT_PREVIEW_IMAGE_FORMATS, ARTIFACT_PREVIEW_IMAGE_MIME_TYPES, ARTIFACT_PREVIEW_STATUSES, ASSET_ACCESS_VERBS, ASSET_LIFECYCLES, ASSET_NAME_REFUSAL_REASONS, ASSET_OWNER_KINDS, ASSET_REPO_BUNDLE_KINDS, ASSET_REPRESENTATIONS, ASSET_SYNC_CHANGE_TYPES, ATTACHMENT_CREATE_OUTCOMES, AUDIT_ACTOR_KINDS, AUDIT_EVENT_STATUSES, AUDIT_OUTCOMES, AUDIT_TIERS, AUTH_PRINCIPAL_KINDS, AUTH_SCOPE_WILDCARD, type AccessSource, type ActiveAgentRunStatus, type AdministeredUserStatus, type AgentAvailabilityMode, type AgentConfig, type AgentEditableField, type AgentInitialPromptConfig, type AgentRunFailureCategory, type AgentRunStatus, type AgentUse, type ApiCredentialScope, type AppActionCallStatus, type AppErrorCode, type AppMode, type ApprovalCheckFailureOutcome, type ApprovalCheckStatus, type ApprovalExecution, type ApprovalRequestStatus, type ArtifactPreviewImageFormat, type ArtifactPreviewImageMimeType, type ArtifactPreviewStatus, type AssetLifecycle, type AssetNameRefusalReason, type AssetOwnerKind, type AssetRepoBundleKind, type AssetRepresentation, type AssetSyncChangeType, type AttachmentCreateOutcome, type AuditActorKind, type AuditEventStatus, type AuditOutcome, type AuditTier, type AuthPrincipalKind, CATALOGUE_CATEGORIES, CATALOGUE_PARTS, CHAT_MESSAGE_ROLES, CHAT_SESSION_AUTH_SCOPES, COLLABORATION_WORKSPACE_KINDS, CONFIG_ASSET_CHANGE_OPERATIONS, CONFIG_ASSET_KINDS, CONNECTION_BINDING_STATES, CONNECTION_CREDENTIAL_MODES, CONNECTION_EXPOSURES, CONNECTION_HEALTH_STATES, CONNECTION_NAME_MAX_LENGTH, CONNECTION_NAME_PATTERN, CONNECTION_NETWORKS, CONNECTION_OAUTH_REGISTRATIONS, CONNECTION_OPERATION_POLICIES, CONNECTION_OPERATION_STATUSES, CONNECTION_ORIGINS, CONNECTION_PROPOSAL_BINDING_STATES, CONNECTION_PROPOSAL_STATES, CONNECTION_PROVIDER_REVOCATIONS, CONNECTION_SECRET_STATES, CONNECTION_SIGN_IN_NEEDS, CONNECTOR_TEST_STATUSES, CONVERSATION_ATTACHMENT_STATUSES, CONVERSATION_KINDS, CONVERSATION_VISIBILITIES, type CallableOperationView, type CallableOperationsPage, type CatalogueCategory, type CataloguePart, type ChatMessageRole, type ChatSessionAuthScope, type CollaborationWorkspaceKind, type ConfigAssetChangeOperation, type ConfigAssetKind, type ConnectionBindingState, type ConnectionCredentialMode, type ConnectionExposure, type ConnectionHealth, type ConnectionNetwork, type ConnectionOAuthRegistration, type ConnectionOperationPolicy, type ConnectionOperationStatus, type ConnectionOrigin, type ConnectionProposalBindingState, type ConnectionProposalState, type ConnectionProviderRevocation, type ConnectionSecretState, type ConnectionSignInNeed, type ConnectorTestStatus, type ConversationAttachmentStatus, type ConversationKind, type ConversationVisibility, DATABASE_RELATION_TYPES, DATA_STORE_CONDITIONS, DATA_STORE_INSERT_CONFLICT_MODES, DATA_STORE_LOAD_CONFLICT_MODES, DATA_STORE_MIGRATION_OUTCOMES, DATA_STORE_SCALAR_TYPES, DATA_STORE_STATUSES, DECIDED_APPROVAL_REQUEST_STATUSES, DELETION_STATES, type DataScopes, type DataStoreCondition, type DataStoreInsertConflictMode, type DataStoreLoadConflictMode, type DataStoreMigrationOutcome, type DataStoreRecordField, type DataStoreRecordProposalItem, type DataStoreRecordsDecideInput, type DataStoreRecordsDecideOutput, type DataStoreRecordsFlaggedInput, type DataStoreRecordsFlaggedOutput, type DataStoreRecordsProposeInput, type DataStoreRecordsRule, type DataStoreScalarType, type DataStoreStatus, type DatabaseRelationType, type DecidedApprovalRequestStatus, type DeletionState, ENDED_AGENT_RUN_STATUSES, ENDED_APPROVAL_EXECUTIONS, type EndedAgentRunStatus, type EndedApprovalExecution, FAILED_JOB_STATUSES, FEEDBACK_CATEGORY_MAX_LENGTH, FEEDBACK_NOTE_MAX_LENGTH, FEEDBACK_STATES, FEEDBACK_SUBJECT_KINDS, FEEDBACK_SUMMARY_MAX_LENGTH, FEEDBACK_TEXT_MAX_LENGTH, FIRST_PARTY_AUTH_SCOPES, FOLLOW_UP_MODES, FOLLOW_UP_STATUSES, type FailedJobStatus, type FeedbackState, type FeedbackSubjectKind, type FirstPartyAuthScope, GRANT_EFFECTS, GRANT_HOLDER_KINDS, GRANT_SCOPE_KINDS, GUARDRAIL_HIT_OUTCOMES, GUARDRAIL_NAME_MAX_LENGTH, GUARDRAIL_NAME_PATTERN, GUARDRAIL_OUTCOMES, type GrantEffect, type GrantHolderKind, type GrantScopeKind, type GuardrailHitOutcome, type GuardrailOutcome, IDEMPOTENCY_KEY_MAX_LENGTH, INFRASTRUCTURE_SECRET_STATES, INFRASTRUCTURE_WITHHELD_FIELDS, type InfrastructureSecretState, type InfrastructureWithheldField, JOB_STATUSES, type JobStatus, KNOWLEDGE_BASE_STATUSES, KNOWLEDGE_CHECK_STATUSES, KNOWLEDGE_DOCUMENT_FAILURE_CODES, KNOWLEDGE_DOCUMENT_STATES, KNOWLEDGE_DOCUMENT_WAIT_CODES, KNOWLEDGE_EMBEDDING_STATES, KNOWLEDGE_FILE_MAX_BYTES, KNOWLEDGE_SEARCH_SIGNALS, KNOWLEDGE_SOURCE_FAILURE_CODES, KNOWLEDGE_SOURCE_ITEM_FAILURE_CODES, KNOWLEDGE_SOURCE_ITEM_SHOWN_STATES, KNOWLEDGE_SOURCE_ITEM_STATES, KNOWLEDGE_SYNC_COUNTS, KNOWLEDGE_SYNC_MODES, KNOWLEDGE_SYNC_RUN_STATES, type KnowledgeBaseStatus, type KnowledgeCheckStatus, type KnowledgeDocumentFailureCode, type KnowledgeDocumentState, type KnowledgeDocumentWaitCode, type KnowledgeExtractFieldsInput, type KnowledgeExtractFieldsOutput, type KnowledgeFirstPassConfirmation, type KnowledgeIngestFetch, type KnowledgeIngestInput, type KnowledgeIngestItem, type KnowledgeIngestOutput, type KnowledgeLocateInput, type KnowledgeLocateOutput, type KnowledgePendingInput, type KnowledgePendingOutput, type KnowledgePendingRow, type KnowledgeProcessorOutput, type KnowledgePutProcessedInput, type KnowledgeRetryInput, type KnowledgeRetryOutput, type KnowledgeSearchSignal, type KnowledgeSourceFailureCode, type KnowledgeSourceItemFailureCode, type KnowledgeSourceItemShownState, type KnowledgeSourceItemState, type KnowledgeSourceItemsInput, type KnowledgeSourceItemsOutput, type KnowledgeSourcesOutput, type KnowledgeSyncCount, type KnowledgeSyncInput, type KnowledgeSyncMode, type KnowledgeSyncResult, type KnowledgeSyncRunState, type KnowledgeWithdrawInput, type KnowledgeWithdrawOutput, type KnowledgeWorkflowSource, type KnowledgeWorkflowSourcesOutput, LISTED_DATA_STORE_STATUSES, LIVE_JOB_STATUSES, type ListedDataStoreStatus, type LiveJobStatus, type LocaleCode, type LocalizedStringConfig, MAIL_ADDRESS_MAX_LENGTH, MAIL_ATTACHMENTS_MAX_BYTES, MAIL_ATTACHMENTS_MAX_FILES, MAIL_AUDIT_MAX_DOMAINS, MAIL_BODY_MAX_BYTES, MAIL_OUTBOUND_DEFAULT_LIMITS, MAIL_OUTBOUND_FOOTER_MAX_LENGTH, MAIL_RECIPIENT_DOMAINS_ANY, MAIL_RECIPIENT_DOMAIN_PATTERN, MAIL_RECIPIENT_ID_PATTERN, MAIL_SENDER_CONNECTION_PREFIX, MAIL_SENDER_NAME_MAX_LENGTH, MAIL_SENDER_RESOURCE_KIND, MAIL_SENDER_SYSTEM, MAIL_SENDER_SYSTEM_ICON, MAIL_SENDER_USE_ACTION, MAIL_SEND_ERROR_CODES, MAIL_SEND_MAX_ADDRESSES, MAIL_SEND_OPERATION, MAIL_SEND_REFUSAL_REASONS, MAIL_SUBJECT_MAX_LENGTH, MAIL_WORKFLOW_MESSAGE_TEMPLATE, MANAGED_FILE_STATUSES, MESSAGE_FINISH_STATUSES, MODEL_PROVIDER_AUTH_MODES, MODEL_USAGE_EVENT_STATUSES, MODEL_USAGE_LIMIT_METRICS, MODEL_USAGE_LIMIT_PERIODS, MODEL_USAGE_LIMIT_SCOPES, MODEL_USAGE_SOURCES, MODEL_USAGE_TIERS, type MailPreviewRecipient, type MailSendErrorCode, type MailSendInput, type MailSendInputFields, type MailSendOutput, type MailSendPreview, type MailSendRecipient, type MailSendRecipientList, type MailSendRefusalDetails, type MailSendSimulatedOutput, type MailSenderId, type MessageFinishStatus, type ModelProviderAuthMode, type ModelUsageEventStatus, type ModelUsageRefusal, type ModelUsageSource, type ModelUsageTier, NOTIFY_CHANNELS, type NotifyChannel, OPENAI_COMPATIBLE_APIS, OPERATIONS_AUDIENCES, OPERATION_CHANGE_CLASSES, OPERATION_CONFIRMATION_DECISIONS, OPERATION_DENIAL_REASONS, OPERATION_EFFECTS, OPERATION_ORIGIN_KINDS, OPERATION_RUN_DECISION_MODES, OPERATION_RUN_DECISION_REASONS, OPERATION_RUN_STATUSES, OPERATION_SOURCE_KINDS, OPERATION_TARGETS, type OpenaiCompatibleApi, type OperationBatchFailure, type OperationBatchResult, type OperationDenialReason, type OperationEffect, type OperationOriginKind, type OperationPaging, type OperationRunDecisionMode, type OperationRunDecisionReason, type OperationRunStatus, type OperationScope, type OperationSourceKind, type OperationSourceView, type OperationTarget, type OperationsAudience, PERSONAL_WORKSPACES_KEY, PERSON_POLICY_SETTINGS, POLICY_VALUES, PRINCIPAL_HOLDER_KINDS, PROVIDER_CHECK_ERROR_CLASSES, PROVIDER_PORTS, PROVIDER_REGIONS, PUBLISHED_DATA_CONSUMER_KINDS, type PlatformAction, type PolicyValue, type PrincipalHolderKind, type ProviderCheckErrorClass, type ProviderPort, type ProviderRegion, type PublishedDataConsumerKind, READING_POLICY_VALUES, REASONING_EFFORTS, RECORDS_FLAGGED_MAX_ITEMS_PER_PAGE, RECORDS_PROPOSE_MAX_FIELDS_PER_ITEM, RECORDS_PROPOSE_MAX_ITEMS_PER_CALL, RECORD_FIELD_FAILURE_CODES, RECORD_FIELD_STATES, RECORD_FLAG_REASONS, ROLE_GRANT_SCOPE_KINDS, ROLE_PENDING_CHANGES, ROLE_PENDING_DECISIONS, type ReadingPolicyValue, type ReasoningEffortConfig, type RecordColumn, type RecordEvidenceResult, type RoleGrantScopeKind, type RolePendingDecision, SCHEDULED_START_STATES, SERVICE_PRINCIPAL_PERMISSIONS, SERVICE_PRINCIPAL_STATUSES, SKILL_CHANGE_TYPES, SKILL_FRONTMATTER_FIELDS, SKILL_FRONTMATTER_MAX_BYTES, SKILL_FRONTMATTER_MAX_DEPTH, SKILL_NAME_PATTERN, SKILL_NAME_RULE, SKILL_ORIGINS, SKILL_PORTABLE_DESCRIPTION_MAX_CHARS, SKILL_PORTABLE_NAME_MAX_CHARS, SKILL_RESOURCE_MEDIA_TYPES, SKILL_STARTERS_MAX, SKILL_STARTER_LINE_MAX_LENGTH, SKILL_SUMMARY_MAX_LENGTH, STRUCTURED_DATA_REVIEW_REASONS, SUPPORTED_IMAGE_MIME_TYPES, type ScopeAssignmentInput, type ScopedTables, type ServicePrincipalPermission, type ServicePrincipalStatus, type SkillChangeType, type SkillConfig, type SkillFileEntry, type SkillFrontmatterRefusal, SkillMarkdownError, type SkillOrigin, type SkillResourceConfig, type SkillResourceMediaType, type SkillStarterConfig, type StructuredDataReviewReason, type SupportedImageMimeType, THEME_MODES, THEME_MODE_PREFERENCES, TOOL_CALL_STATES, TOOL_DECISION_MODES, TOOL_DECISION_OUTCOMES, TOOL_DISPLAY_MODES, TOOL_GROUPS, TOOL_INPUT_PARSE_ERROR_CODES, type ThemeMode, type ThemeModePreference, type ToolCallState, type ToolDisplayMode, type ToolGroup, type ToolInputParseErrorCode, USAGE_BREAKDOWN_DIMENSIONS, USAGE_COST_STATUSES, USAGE_ORIGINS, USAGE_SPEND_LIMIT_LEVELS, USER_STATUSES, type UsageCostStatus, type UserStatus, WAITING_OPERATION_RUN_STATUSES, WEB_SOURCE_PROVIDERS, WORKFLOW_DATASET_DOWNLOAD_FORMATS, WORKFLOW_DATASET_STATES, WORKFLOW_ENDED_STATUSES, WORKFLOW_EXECUTED_STEP_TYPES, WORKFLOW_KINDS, WORKFLOW_MARKDOWN_MAX_COLUMNS, WORKFLOW_MARKDOWN_MAX_ROWS, WORKFLOW_NAME_PATTERN, WORKFLOW_NAME_RULE, WORKFLOW_RESERVED_STEP_TYPES, WORKFLOW_RIGHTS_REVISIONS, WORKFLOW_RIGHT_NEEDED_FOR, WORKFLOW_RIGHT_REFUSALS, WORKFLOW_RUN_ACCOUNT_STATUSES, WORKFLOW_RUN_MODES, WORKFLOW_RUN_STATUSES, WORKFLOW_STEP_RUN_STATUSES, WORKFLOW_STEP_SOURCE_KINDS, WORKFLOW_STEP_TYPES, WORKFLOW_TEST_REVISIONS, WORKFLOW_TEXT_FORMAT_MARKDOWN, WORKFLOW_TEXT_MAX_PARTS, WORKFLOW_TRIGGER_KINDS, WORKSPACE_ACCENT_COLORS, WORKSPACE_ACCESS_STATES, WORKSPACE_COMMAND_STATUSES, WORKSPACE_FILE_KINDS, WORKSPACE_MEMBERSHIP_ROLES, WORKSPACE_SECTIONS, WORKSPACE_USE_ASSET_KINDS, WORKSPACE_VISIBILITIES, type WebSourceProvider, type WorkflowAssetConfig, type WorkflowDatasetDownloadFormat, type WorkflowDatasetState, type WorkflowEndedStatus, type WorkflowKind, type WorkflowMailSenderFact, type WorkflowMessageMailParams, type WorkflowReservedStepType, type WorkflowRunMode, type WorkflowRunStatus, type WorkflowStepRunStatus, type WorkflowStepSourceKind, type WorkflowStepType, type WorkflowTestRevision, type WorkflowTriggerKind, type WorkspaceAccentColor, type WorkspaceAccessState, type WorkspaceCommandStatus, type WorkspaceFileKind, type WorkspaceMembershipRole, type WorkspaceSection, type WorkspaceVisibility, YAML_DATA_MAX_VALUES, YamlDataError, type YamlDataIssue, type YamlDataIssueCode, type YamlDataOptions, type YamlDataResult, agentConfigSchema, callableOperationSchema, callableOperationsPageSchema, checkStorableTexts, dataScopeNameSchema, dataScopesSchema, dataStoreRecordFieldSchema, dataStoreRecordProposalItemSchema, dataStoreRecordsContracts, dataStoreRecordsDecideInputSchema, dataStoreRecordsDecideOutputSchema, dataStoreRecordsFlaggedInputSchema, dataStoreRecordsFlaggedOutputSchema, dataStoreRecordsProposeInputSchema, dataStoreRecordsRuleSchema, deriveSkillTitle, formatSkillMarkdown, isStorableText, knowledgeExtractFieldsInputSchema, knowledgeExtractFieldsOutputSchema, knowledgeFieldValueSchema, knowledgeFirstPassConfirmationSchema, knowledgeIngestFetchSchema, knowledgeIngestInputSchema, knowledgeIngestItemSchema, knowledgeIngestOutputSchema, knowledgeLocateInputSchema, knowledgeLocateOutputSchema, knowledgePendingInputSchema, knowledgePendingOutputSchema, knowledgePendingRowSchema, knowledgeProcessorOutputSchema, knowledgePutProcessedInputSchema, knowledgeRecordsRefusalSchema, knowledgeRetryInputSchema, knowledgeRetryOutputSchema, knowledgeSourceItemsInputSchema, knowledgeSourceItemsOutputSchema, knowledgeSourcesOutputSchema, knowledgeSyncInputSchema, knowledgeSyncResultSchema, knowledgeWithdrawInputSchema, knowledgeWithdrawOutputSchema, knowledgeWorkflowSourceSchema, knowledgeWorkflowSourcesOutputSchema, knowledgeWriteContracts, loadYamlData, localeCodes, localizedStringSchema, mailAddressSchema, mailBodySchema, mailCopyRecipientListSchema, mailPreviewRecipientSchema, mailRecipientDomainSchema, mailRecipientListSchema, mailRecipientSchema, mailReplyToSchema, mailSendContract, mailSendInputSchema, mailSendOutputSchema, mailSendPreviewSchema, mailSendRefusalDetailsSchema, mailSendSimulatedOutputSchema, mailSenderIdSchema, mailSenderNameSchema, mailSubjectSchema, operationBatchFailureSchema, operationBatchResultSchema, operationPagingSchema, operationSourceSchema, parseSkillMarkdown, providerRegionSchema, readYamlData, recordColumnTakes, recordEvidenceResultSchema, scopeAssignmentInputSchema, scopedTablesSchema, skillConfigSchema, skillFileEntrySchema, skillFileFrontmatterSchema, skillNameSchema, skillPortabilityIssues, skillResourceConfigSchema, skillResourceMediaTypeForPath, skillResourcePathSchema, skillStarterSchema, workflowConfigSchema, workflowDataFlowsSchema, workflowDatasetReferenceSchema, workflowMailSenderFactSchema, workflowMessageMailParamsSchema, yamlValueIssue, yamlValueIssueSentence };