apps 0.0.1-beta.8 → 0.0.1-beta.81

package/types/apps/src/contracts/protocols/current.d.ts

@@ -0,0 +1,3843 @@
+/**
+ * The host protocol this framework speaks: every message that crosses between a host and an app
+ * bundle built with it. Its number is `frameworkProtocol` in `../protocol-version.ts`.
+ *
+ * This module is live. The framework and the SDK read the current boundary from here, through
+ * `../host.ts`. `bun run check` records it in `packages/apps/protocols/<frameworkProtocol>.json` and
+ * checks that it stays compatible with every released protocol in `released.ts`: a host that speaks
+ * this module must keep running every bundle a released protocol retained. A change that no longer
+ * does so is a break: freeze this module's previous content as `<frameworkProtocol>.ts`, raise the
+ * number, and give the host an adapter for the frozen one. See notes/apps-publishing.md.
+ *
+ * The frozen protocol modules beside this one are records of released boundaries. Nothing here
+ * imports them, so a change here never edits a released protocol.
+ */
+import { Schema } from "effect";
+import { DatabaseFieldReserved, DatabaseLimitExceeded } from "../../../../app-data/src/contracts/database.js";
+import { OpenapiResponseError } from "../api-response-error.js";
+import { ElicitationFailed } from "../elicitation.js";
+import { ProviderError } from "../provider-error.js";
+import { WorkflowFailure } from "../workflows.js";
+declare const McpError_base: Schema.Class<McpError, Schema.TaggedStruct<"McpError", {
+    readonly phase: Schema.Literals<readonly ["connect", "discover", "call", "schema", "transport"]>;
+    readonly reason: Schema.Literals<readonly ["request", "unauthorized", "invalid_response", "timeout", "invalid_input"]>;
+    readonly status: Schema.optional<Schema.Number>;
+    /** The JSON-RPC error the server stated. */
+    readonly upstream: Schema.optional<Schema.Struct<{
+        readonly code: Schema.Union<readonly [Schema.Int, Schema.String]>;
+        readonly message: Schema.optionalKey<Schema.String>;
+    }>>;
+    /**
+     * The refused request carried the session ID the server issued at initialization, so a 404 reads
+     * as a session the server may have lost. Chooses the explanation only; the host never decides from
+     * it whose side a failure is on.
+     */
+    readonly session: Schema.optional<Schema.Literal<true>>;
+}>, import("effect/Cause").YieldableError>;
+/** An MCP failure as it crosses the host boundary. Apps throw the author-facing class from `apps/mcp`. */
+export declare class McpError extends McpError_base {
+}
+declare const SkillLoadFailed_base: Schema.Class<SkillLoadFailed, Schema.TaggedStruct<"SkillLoadFailed", {
+    readonly reason: Schema.Literals<readonly ["source", "request", "rate_limited", "document", "limit", "changed", "encoding"]>;
+    readonly message: Schema.optional<Schema.String>;
+    readonly status: Schema.optional<Schema.Int>;
+    /** What the service's answer points to as missing: the repository, or the branch or tag. */
+    readonly missing: Schema.optional<Schema.Literals<readonly ["repository", "ref"]>>;
+}>, import("effect/Cause").YieldableError>;
+/** A skill loader failure as it crosses the host boundary. Apps throw the author-facing class from `apps/skills`. */
+export declare class SkillLoadFailed extends SkillLoadFailed_base {
+}
+/**
+ * Where a provider's credentials may be sent: an exact host, `host:port`, or `*.` followed by a
+ * domain, matching exactly one more label. Lowercase, without a scheme or path.
+ */
+export declare const CredentialHost: Schema.String;
+/** Serializable authentication declarations interpreted by the trusted host. */
+export declare const DeclaredAuthMethod: Schema.Union<readonly [Schema.Struct<{
+    readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+    readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+    readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly in: Schema.Literal<"header">;
+        readonly name: Schema.String;
+        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly field: Schema.NonEmptyString;
+        }>, Schema.Struct<{
+            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly field: Schema.NonEmptyString;
+            }>]>>;
+        }>]>>;
+    }>, Schema.Struct<{
+        readonly in: Schema.Literal<"query">;
+        readonly name: Schema.NonEmptyString;
+        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly field: Schema.NonEmptyString;
+        }>, Schema.Struct<{
+            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly field: Schema.NonEmptyString;
+            }>]>>;
+        }>]>>;
+    }>]>>>;
+    readonly type: Schema.Literal<"secrets">;
+    readonly label: Schema.String;
+    readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>, Schema.Struct<{
+    readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+    readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+    readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly in: Schema.Literal<"header">;
+        readonly name: Schema.String;
+        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly field: Schema.NonEmptyString;
+        }>, Schema.Struct<{
+            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly field: Schema.NonEmptyString;
+            }>]>>;
+        }>]>>;
+    }>, Schema.Struct<{
+        readonly in: Schema.Literal<"query">;
+        readonly name: Schema.NonEmptyString;
+        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly field: Schema.NonEmptyString;
+        }>, Schema.Struct<{
+            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly field: Schema.NonEmptyString;
+            }>]>>;
+        }>]>>;
+    }>]>>>;
+    readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly discover: Schema.String;
+    readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.String>;
+    readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+    readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+    readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+    readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+        readonly path: Schema.String;
+    }>>;
+    readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+    readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+    readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+    readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+    readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+    readonly type: Schema.Literal<"oauth2">;
+}>, Schema.Struct<{
+    readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+    readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+    readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly in: Schema.Literal<"header">;
+        readonly name: Schema.String;
+        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly field: Schema.NonEmptyString;
+        }>, Schema.Struct<{
+            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly field: Schema.NonEmptyString;
+            }>]>>;
+        }>]>>;
+    }>, Schema.Struct<{
+        readonly in: Schema.Literal<"query">;
+        readonly name: Schema.NonEmptyString;
+        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly field: Schema.NonEmptyString;
+        }>, Schema.Struct<{
+            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly field: Schema.NonEmptyString;
+            }>]>>;
+        }>]>>;
+    }>]>>>;
+    readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly authorizationUrl: Schema.String;
+    readonly tokenUrl: Schema.String;
+    readonly revocationUrl: Schema.optionalKey<Schema.String>;
+    readonly scopes: Schema.$Array<Schema.String>;
+    readonly issuer: Schema.optionalKey<Schema.String>;
+    readonly discover: Schema.optionalKey<Schema.Never>;
+    readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.Never>;
+    readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+        readonly path: Schema.String;
+    }>>;
+    readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+    readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+    readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+    readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+    readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+    readonly type: Schema.Literal<"oauth2">;
+}>, Schema.Struct<{
+    readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+    readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+    readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly in: Schema.Literal<"header">;
+        readonly name: Schema.String;
+        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly field: Schema.NonEmptyString;
+        }>, Schema.Struct<{
+            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly field: Schema.NonEmptyString;
+            }>]>>;
+        }>]>>;
+    }>, Schema.Struct<{
+        readonly in: Schema.Literal<"query">;
+        readonly name: Schema.NonEmptyString;
+        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly field: Schema.NonEmptyString;
+        }>, Schema.Struct<{
+            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly field: Schema.NonEmptyString;
+            }>]>>;
+        }>]>>;
+    }>]>>>;
+    readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+    readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+    readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+    readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+    readonly grant: Schema.Literal<"client_credentials">;
+    readonly discover: Schema.String;
+    readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.String>;
+    readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+    readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+    readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+    readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    readonly type: Schema.Literal<"oauth2">;
+}>, Schema.Struct<{
+    readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+    readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+    readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly in: Schema.Literal<"header">;
+        readonly name: Schema.String;
+        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly field: Schema.NonEmptyString;
+        }>, Schema.Struct<{
+            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly field: Schema.NonEmptyString;
+            }>]>>;
+        }>]>>;
+    }>, Schema.Struct<{
+        readonly in: Schema.Literal<"query">;
+        readonly name: Schema.NonEmptyString;
+        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+            readonly field: Schema.NonEmptyString;
+        }>, Schema.Struct<{
+            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly field: Schema.NonEmptyString;
+            }>]>>;
+        }>]>>;
+    }>]>>>;
+    readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+    readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+    readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+    readonly discover: Schema.optionalKey<Schema.Never>;
+    readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.Never>;
+    readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+    readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+    readonly grant: Schema.Literal<"client_credentials">;
+    readonly tokenUrl: Schema.String;
+    readonly revocationUrl: Schema.optionalKey<Schema.String>;
+    readonly scopes: Schema.$Array<Schema.String>;
+    readonly type: Schema.Literal<"oauth2">;
+}>]>;
+/** A credential-free provider declaration with the hosts its credentials may be sent to. */
+export declare const DeclaredProvider: Schema.Struct<{
+    readonly name: Schema.NonEmptyString;
+    readonly auth: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+        readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+        readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+        readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly in: Schema.Literal<"header">;
+            readonly name: Schema.String;
+            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly field: Schema.NonEmptyString;
+            }>, Schema.Struct<{
+                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>]>>;
+            }>]>>;
+        }>, Schema.Struct<{
+            readonly in: Schema.Literal<"query">;
+            readonly name: Schema.NonEmptyString;
+            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly field: Schema.NonEmptyString;
+            }>, Schema.Struct<{
+                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>]>>;
+            }>]>>;
+        }>]>>>;
+        readonly type: Schema.Literal<"secrets">;
+        readonly label: Schema.String;
+        readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>, Schema.Struct<{
+        readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+        readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+        readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly in: Schema.Literal<"header">;
+            readonly name: Schema.String;
+            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly field: Schema.NonEmptyString;
+            }>, Schema.Struct<{
+                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>]>>;
+            }>]>>;
+        }>, Schema.Struct<{
+            readonly in: Schema.Literal<"query">;
+            readonly name: Schema.NonEmptyString;
+            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly field: Schema.NonEmptyString;
+            }>, Schema.Struct<{
+                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>]>>;
+            }>]>>;
+        }>]>>>;
+        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly discover: Schema.String;
+        readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.String>;
+        readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+        readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+        readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+        readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+            readonly path: Schema.String;
+        }>>;
+        readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+        readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+        readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+        readonly type: Schema.Literal<"oauth2">;
+    }>, Schema.Struct<{
+        readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+        readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+        readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly in: Schema.Literal<"header">;
+            readonly name: Schema.String;
+            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly field: Schema.NonEmptyString;
+            }>, Schema.Struct<{
+                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>]>>;
+            }>]>>;
+        }>, Schema.Struct<{
+            readonly in: Schema.Literal<"query">;
+            readonly name: Schema.NonEmptyString;
+            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly field: Schema.NonEmptyString;
+            }>, Schema.Struct<{
+                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>]>>;
+            }>]>>;
+        }>]>>>;
+        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly authorizationUrl: Schema.String;
+        readonly tokenUrl: Schema.String;
+        readonly revocationUrl: Schema.optionalKey<Schema.String>;
+        readonly scopes: Schema.$Array<Schema.String>;
+        readonly issuer: Schema.optionalKey<Schema.String>;
+        readonly discover: Schema.optionalKey<Schema.Never>;
+        readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.Never>;
+        readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+            readonly path: Schema.String;
+        }>>;
+        readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+        readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+        readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+        readonly type: Schema.Literal<"oauth2">;
+    }>, Schema.Struct<{
+        readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+        readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+        readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly in: Schema.Literal<"header">;
+            readonly name: Schema.String;
+            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly field: Schema.NonEmptyString;
+            }>, Schema.Struct<{
+                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>]>>;
+            }>]>>;
+        }>, Schema.Struct<{
+            readonly in: Schema.Literal<"query">;
+            readonly name: Schema.NonEmptyString;
+            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly field: Schema.NonEmptyString;
+            }>, Schema.Struct<{
+                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>]>>;
+            }>]>>;
+        }>]>>>;
+        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+        readonly grant: Schema.Literal<"client_credentials">;
+        readonly discover: Schema.String;
+        readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.String>;
+        readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+        readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+        readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+        readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly type: Schema.Literal<"oauth2">;
+    }>, Schema.Struct<{
+        readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+        readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+        readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly in: Schema.Literal<"header">;
+            readonly name: Schema.String;
+            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly field: Schema.NonEmptyString;
+            }>, Schema.Struct<{
+                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>]>>;
+            }>]>>;
+        }>, Schema.Struct<{
+            readonly in: Schema.Literal<"query">;
+            readonly name: Schema.NonEmptyString;
+            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                readonly field: Schema.NonEmptyString;
+            }>, Schema.Struct<{
+                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>]>>;
+            }>]>>;
+        }>]>>>;
+        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+        readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+        readonly discover: Schema.optionalKey<Schema.Never>;
+        readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.Never>;
+        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+        readonly grant: Schema.Literal<"client_credentials">;
+        readonly tokenUrl: Schema.String;
+        readonly revocationUrl: Schema.optionalKey<Schema.String>;
+        readonly scopes: Schema.$Array<Schema.String>;
+        readonly type: Schema.Literal<"oauth2">;
+    }>]>>;
+    readonly hosts: Schema.optionalKey<Schema.$Array<Schema.String>>;
+}>;
+/** Credential-free provider declaration; content matching remains host policy. */
+export type DeclaredProvider = typeof DeclaredProvider.Type;
+/** Account slots available without binding accounts or evaluating the app factory. */
+export declare const DeclaredRequirements: Schema.Struct<{
+    /** Protocol support of this retained framework build, not an author-declared requirement. */
+    readonly capabilities: Schema.optionalKey<Schema.Struct<{
+        readonly skills: Schema.Literal<true>;
+        /** Accepts inspect detail and tools. Earlier builds reject both as excess fields. */
+        readonly toolIndex: Schema.optionalKey<Schema.Literal<true>>;
+        /** Accepts skills sources and reports whether the catalog includes a live loader. */
+        readonly skillSources: Schema.optionalKey<Schema.Literal<true>>;
+        /** Accepts scheduled inspection. Earlier builds reject it as an excess field. */
+        readonly scheduledTools: Schema.optionalKey<Schema.Literal<true>>;
+    }>>;
+    /**
+     * The document database an app of protocol 9 or earlier declared. Apps of this protocol declare
+     * `sql` instead; the field remains so requirements read from older retained builds keep their meaning.
+     */
+    readonly database: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+        readonly fields: Schema.$Record<Schema.String, Schema.Struct<{
+            readonly kind: Schema.Literals<readonly ["string", "number", "boolean", "id", "userId"]>;
+            readonly optional: Schema.optional<Schema.Boolean>;
+            readonly default: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean]>>;
+            readonly references: Schema.optional<Schema.String>;
+        }>>;
+        readonly indexes: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly fields: Schema.NonEmptyArray<Schema.String>;
+        }>>;
+    }>>>;
+    readonly accounts: Schema.$Record<Schema.NonEmptyString, Schema.Struct<{
+        readonly definition: Schema.Struct<{
+            readonly name: Schema.NonEmptyString;
+            readonly auth: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+                readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly in: Schema.Literal<"header">;
+                    readonly name: Schema.String;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>, Schema.Struct<{
+                    readonly in: Schema.Literal<"query">;
+                    readonly name: Schema.NonEmptyString;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>]>>>;
+                readonly type: Schema.Literal<"secrets">;
+                readonly label: Schema.String;
+                readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            }>, Schema.Struct<{
+                readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly in: Schema.Literal<"header">;
+                    readonly name: Schema.String;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>, Schema.Struct<{
+                    readonly in: Schema.Literal<"query">;
+                    readonly name: Schema.NonEmptyString;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>]>>>;
+                readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly discover: Schema.String;
+                readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.String>;
+                readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+                readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+                readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                    readonly path: Schema.String;
+                }>>;
+                readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+                readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+                readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                readonly type: Schema.Literal<"oauth2">;
+            }>, Schema.Struct<{
+                readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly in: Schema.Literal<"header">;
+                    readonly name: Schema.String;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>, Schema.Struct<{
+                    readonly in: Schema.Literal<"query">;
+                    readonly name: Schema.NonEmptyString;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>]>>>;
+                readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly authorizationUrl: Schema.String;
+                readonly tokenUrl: Schema.String;
+                readonly revocationUrl: Schema.optionalKey<Schema.String>;
+                readonly scopes: Schema.$Array<Schema.String>;
+                readonly issuer: Schema.optionalKey<Schema.String>;
+                readonly discover: Schema.optionalKey<Schema.Never>;
+                readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.Never>;
+                readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                    readonly path: Schema.String;
+                }>>;
+                readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+                readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+                readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                readonly type: Schema.Literal<"oauth2">;
+            }>, Schema.Struct<{
+                readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly in: Schema.Literal<"header">;
+                    readonly name: Schema.String;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>, Schema.Struct<{
+                    readonly in: Schema.Literal<"query">;
+                    readonly name: Schema.NonEmptyString;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>]>>>;
+                readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+                readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                readonly grant: Schema.Literal<"client_credentials">;
+                readonly discover: Schema.String;
+                readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.String>;
+                readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+                readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+                readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly type: Schema.Literal<"oauth2">;
+            }>, Schema.Struct<{
+                readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly in: Schema.Literal<"header">;
+                    readonly name: Schema.String;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>, Schema.Struct<{
+                    readonly in: Schema.Literal<"query">;
+                    readonly name: Schema.NonEmptyString;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>]>>>;
+                readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+                readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                readonly discover: Schema.optionalKey<Schema.Never>;
+                readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.Never>;
+                readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                readonly grant: Schema.Literal<"client_credentials">;
+                readonly tokenUrl: Schema.String;
+                readonly revocationUrl: Schema.optionalKey<Schema.String>;
+                readonly scopes: Schema.$Array<Schema.String>;
+                readonly type: Schema.Literal<"oauth2">;
+            }>]>>;
+            readonly hosts: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        }>;
+        readonly cardinality: Schema.Literals<readonly ["one", "many"]>;
+        /**
+         * The slot's provider defines an account check. Kept beside the definition, not in it, so
+         * adding or editing a check never changes the provider's identity.
+         */
+        readonly health: Schema.optionalKey<Schema.Literal<true>>;
+    }>>;
+    /** The build has SQL files in `migrations/` and owns a raw SQLite database. */
+    readonly sql: Schema.optionalKey<Schema.Literal<true>>;
+    /** The events the app declares, so a host lists them without evaluating the app. */
+    readonly events: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+        readonly description: Schema.String;
+        readonly filters: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly payload: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>>>;
+}>;
+/** Parsed declared account requirements. */
+export type DeclaredRequirements = typeof DeclaredRequirements.Type;
+/**
+ * Host-resolved credentials for one stable saved account. Never a request DTO. When the provider
+ * declares hosts, its secret string fields are sealed handles, not values. The provider carries
+ * the hosts and placements granted to this account.
+ */
+export declare const ResolvedAccount: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "acc">;
+    readonly provider: Schema.Struct<{
+        readonly name: Schema.NonEmptyString;
+        readonly auth: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+            readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly in: Schema.Literal<"header">;
+                readonly name: Schema.String;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>, Schema.Struct<{
+                readonly in: Schema.Literal<"query">;
+                readonly name: Schema.NonEmptyString;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>]>>>;
+            readonly type: Schema.Literal<"secrets">;
+            readonly label: Schema.String;
+            readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>, Schema.Struct<{
+            readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly in: Schema.Literal<"header">;
+                readonly name: Schema.String;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>, Schema.Struct<{
+                readonly in: Schema.Literal<"query">;
+                readonly name: Schema.NonEmptyString;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>]>>>;
+            readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly discover: Schema.String;
+            readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.String>;
+            readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+            readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+            readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+            readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                readonly path: Schema.String;
+            }>>;
+            readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+            readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+            readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+            readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+            readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+            readonly type: Schema.Literal<"oauth2">;
+        }>, Schema.Struct<{
+            readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly in: Schema.Literal<"header">;
+                readonly name: Schema.String;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>, Schema.Struct<{
+                readonly in: Schema.Literal<"query">;
+                readonly name: Schema.NonEmptyString;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>]>>>;
+            readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly authorizationUrl: Schema.String;
+            readonly tokenUrl: Schema.String;
+            readonly revocationUrl: Schema.optionalKey<Schema.String>;
+            readonly scopes: Schema.$Array<Schema.String>;
+            readonly issuer: Schema.optionalKey<Schema.String>;
+            readonly discover: Schema.optionalKey<Schema.Never>;
+            readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.Never>;
+            readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                readonly path: Schema.String;
+            }>>;
+            readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+            readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+            readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+            readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+            readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+            readonly type: Schema.Literal<"oauth2">;
+        }>, Schema.Struct<{
+            readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly in: Schema.Literal<"header">;
+                readonly name: Schema.String;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>, Schema.Struct<{
+                readonly in: Schema.Literal<"query">;
+                readonly name: Schema.NonEmptyString;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>]>>>;
+            readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+            readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+            readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+            readonly grant: Schema.Literal<"client_credentials">;
+            readonly discover: Schema.String;
+            readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.String>;
+            readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+            readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+            readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+            readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly type: Schema.Literal<"oauth2">;
+        }>, Schema.Struct<{
+            readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly in: Schema.Literal<"header">;
+                readonly name: Schema.String;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>, Schema.Struct<{
+                readonly in: Schema.Literal<"query">;
+                readonly name: Schema.NonEmptyString;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>]>>>;
+            readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+            readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+            readonly discover: Schema.optionalKey<Schema.Never>;
+            readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.Never>;
+            readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+            readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+            readonly grant: Schema.Literal<"client_credentials">;
+            readonly tokenUrl: Schema.String;
+            readonly revocationUrl: Schema.optionalKey<Schema.String>;
+            readonly scopes: Schema.$Array<Schema.String>;
+            readonly type: Schema.Literal<"oauth2">;
+        }>]>>;
+        readonly hosts: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    }>;
+    readonly method: Schema.NonEmptyString;
+    /**
+     * Changes when the account is reconnected or its credentials replaced, not on renewal. Hosts
+     * send it since credential generations; `apps@0.0.1-beta.0` and `beta.1` ignore it.
+     */
+    readonly generation: Schema.optionalKey<Schema.Int>;
+    readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>;
+/** Parsed host account binding. */
+export type ResolvedAccount = typeof ResolvedAccount.Type;
+/** Full saved selection resolved by the trusted caller; [] differs from a missing slot. */
+export declare const ResolvedAccounts: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "acc">;
+    readonly provider: Schema.Struct<{
+        readonly name: Schema.NonEmptyString;
+        readonly auth: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+            readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly in: Schema.Literal<"header">;
+                readonly name: Schema.String;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>, Schema.Struct<{
+                readonly in: Schema.Literal<"query">;
+                readonly name: Schema.NonEmptyString;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>]>>>;
+            readonly type: Schema.Literal<"secrets">;
+            readonly label: Schema.String;
+            readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>, Schema.Struct<{
+            readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly in: Schema.Literal<"header">;
+                readonly name: Schema.String;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>, Schema.Struct<{
+                readonly in: Schema.Literal<"query">;
+                readonly name: Schema.NonEmptyString;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>]>>>;
+            readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly discover: Schema.String;
+            readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.String>;
+            readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+            readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+            readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+            readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                readonly path: Schema.String;
+            }>>;
+            readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+            readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+            readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+            readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+            readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+            readonly type: Schema.Literal<"oauth2">;
+        }>, Schema.Struct<{
+            readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly in: Schema.Literal<"header">;
+                readonly name: Schema.String;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>, Schema.Struct<{
+                readonly in: Schema.Literal<"query">;
+                readonly name: Schema.NonEmptyString;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>]>>>;
+            readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly authorizationUrl: Schema.String;
+            readonly tokenUrl: Schema.String;
+            readonly revocationUrl: Schema.optionalKey<Schema.String>;
+            readonly scopes: Schema.$Array<Schema.String>;
+            readonly issuer: Schema.optionalKey<Schema.String>;
+            readonly discover: Schema.optionalKey<Schema.Never>;
+            readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.Never>;
+            readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                readonly path: Schema.String;
+            }>>;
+            readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+            readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+            readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+            readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+            readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+            readonly type: Schema.Literal<"oauth2">;
+        }>, Schema.Struct<{
+            readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly in: Schema.Literal<"header">;
+                readonly name: Schema.String;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>, Schema.Struct<{
+                readonly in: Schema.Literal<"query">;
+                readonly name: Schema.NonEmptyString;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>]>>>;
+            readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+            readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+            readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+            readonly grant: Schema.Literal<"client_credentials">;
+            readonly discover: Schema.String;
+            readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.String>;
+            readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+            readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+            readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+            readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly type: Schema.Literal<"oauth2">;
+        }>, Schema.Struct<{
+            readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly in: Schema.Literal<"header">;
+                readonly name: Schema.String;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>, Schema.Struct<{
+                readonly in: Schema.Literal<"query">;
+                readonly name: Schema.NonEmptyString;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>]>>>;
+            readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+            readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+            readonly discover: Schema.optionalKey<Schema.Never>;
+            readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.Never>;
+            readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+            readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+            readonly grant: Schema.Literal<"client_credentials">;
+            readonly tokenUrl: Schema.String;
+            readonly revocationUrl: Schema.optionalKey<Schema.String>;
+            readonly scopes: Schema.$Array<Schema.String>;
+            readonly type: Schema.Literal<"oauth2">;
+        }>]>>;
+        readonly hosts: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    }>;
+    readonly method: Schema.NonEmptyString;
+    /**
+     * Changes when the account is reconnected or its credentials replaced, not on renewal. Hosts
+     * send it since credential generations; `apps@0.0.1-beta.0` and `beta.1` ignore it.
+     */
+    readonly generation: Schema.optionalKey<Schema.Int>;
+    readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>, Schema.$Array<Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "acc">;
+    readonly provider: Schema.Struct<{
+        readonly name: Schema.NonEmptyString;
+        readonly auth: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+            readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly in: Schema.Literal<"header">;
+                readonly name: Schema.String;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>, Schema.Struct<{
+                readonly in: Schema.Literal<"query">;
+                readonly name: Schema.NonEmptyString;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>]>>>;
+            readonly type: Schema.Literal<"secrets">;
+            readonly label: Schema.String;
+            readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>, Schema.Struct<{
+            readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly in: Schema.Literal<"header">;
+                readonly name: Schema.String;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>, Schema.Struct<{
+                readonly in: Schema.Literal<"query">;
+                readonly name: Schema.NonEmptyString;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>]>>>;
+            readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly discover: Schema.String;
+            readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.String>;
+            readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+            readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+            readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+            readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                readonly path: Schema.String;
+            }>>;
+            readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+            readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+            readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+            readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+            readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+            readonly type: Schema.Literal<"oauth2">;
+        }>, Schema.Struct<{
+            readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly in: Schema.Literal<"header">;
+                readonly name: Schema.String;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>, Schema.Struct<{
+                readonly in: Schema.Literal<"query">;
+                readonly name: Schema.NonEmptyString;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>]>>>;
+            readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly authorizationUrl: Schema.String;
+            readonly tokenUrl: Schema.String;
+            readonly revocationUrl: Schema.optionalKey<Schema.String>;
+            readonly scopes: Schema.$Array<Schema.String>;
+            readonly issuer: Schema.optionalKey<Schema.String>;
+            readonly discover: Schema.optionalKey<Schema.Never>;
+            readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.Never>;
+            readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                readonly path: Schema.String;
+            }>>;
+            readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+            readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+            readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+            readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+            readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+            readonly type: Schema.Literal<"oauth2">;
+        }>, Schema.Struct<{
+            readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly in: Schema.Literal<"header">;
+                readonly name: Schema.String;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>, Schema.Struct<{
+                readonly in: Schema.Literal<"query">;
+                readonly name: Schema.NonEmptyString;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>]>>>;
+            readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+            readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+            readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+            readonly grant: Schema.Literal<"client_credentials">;
+            readonly discover: Schema.String;
+            readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.String>;
+            readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+            readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+            readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+            readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly type: Schema.Literal<"oauth2">;
+        }>, Schema.Struct<{
+            readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly in: Schema.Literal<"header">;
+                readonly name: Schema.String;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>, Schema.Struct<{
+                readonly in: Schema.Literal<"query">;
+                readonly name: Schema.NonEmptyString;
+                readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                    readonly field: Schema.NonEmptyString;
+                }>, Schema.Struct<{
+                    readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>]>>;
+                }>]>>;
+            }>]>>>;
+            readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+            readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+            readonly discover: Schema.optionalKey<Schema.Never>;
+            readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.Never>;
+            readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+            readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+            readonly grant: Schema.Literal<"client_credentials">;
+            readonly tokenUrl: Schema.String;
+            readonly revocationUrl: Schema.optionalKey<Schema.String>;
+            readonly scopes: Schema.$Array<Schema.String>;
+            readonly type: Schema.Literal<"oauth2">;
+        }>]>>;
+        readonly hosts: Schema.optionalKey<Schema.$Array<Schema.String>>;
+    }>;
+    readonly method: Schema.NonEmptyString;
+    /**
+     * Changes when the account is reconnected or its credentials replaced, not on renewal. Hosts
+     * send it since credential generations; `apps@0.0.1-beta.0` and `beta.1` ignore it.
+     */
+    readonly generation: Schema.optionalKey<Schema.Int>;
+    readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+}>>]>>;
+/** Parsed host selections, kept redacted until native account binding. */
+export type ResolvedAccounts = typeof ResolvedAccounts.Type;
+/** Trusted approval for one decoded call. Never accepted in public command JSON. */
+export declare const TrustedToolApproval: Schema.Struct<{
+    readonly tool: Schema.NonEmptyString;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>;
+export type TrustedToolApproval = typeof TrustedToolApproval.Type;
+/** Absolute Unix time in milliseconds; remote hosts enforce it inside the operation transaction. */
+export declare const InvocationDeadline: Schema.Finite;
+/**
+ * Serializable live tool metadata; executable callbacks never cross this boundary. `name` is the
+ * tool's full dotted path. `router` is the path of the router that owns it, omitted at the root.
+ * `readOnly` marks a query; a tool without it is a mutation.
+ */
+export declare const HostedTool: Schema.Struct<{
+    readonly schedules: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly name: Schema.NonEmptyString;
+        readonly timing: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"interval">;
+            readonly milliseconds: Schema.Int;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"cron">;
+            readonly calendar: Schema.Struct<{
+                readonly expression: Schema.NonEmptyString;
+                readonly timezone: Schema.NonEmptyString;
+            }>;
+        }>]>;
+        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>>>;
+    readonly name: Schema.NonEmptyString;
+    readonly router: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly tags: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+    readonly description: Schema.String;
+    readonly inputSchema: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly readOnly: Schema.optionalKey<Schema.Boolean>;
+    readonly title: Schema.optionalKey<Schema.String>;
+    readonly outputSchema: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly annotations: Schema.optionalKey<Schema.Struct<{
+        readonly title: Schema.optionalKey<Schema.String>;
+        readonly readOnlyHint: Schema.optionalKey<Schema.Boolean>;
+        readonly destructiveHint: Schema.optionalKey<Schema.Boolean>;
+        readonly idempotentHint: Schema.optionalKey<Schema.Boolean>;
+        readonly openWorldHint: Schema.optionalKey<Schema.Boolean>;
+    }>>;
+    readonly _meta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>;
+/** Parsed live tool description. */
+export type HostedTool = typeof HostedTool.Type;
+/** Catalog entry without schemas. Browsing lists these and reads one full tool on selection. */
+export declare const HostedToolSummary: Schema.Struct<{
+    readonly schedules: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly name: Schema.NonEmptyString;
+        readonly timing: Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"interval">;
+            readonly milliseconds: Schema.Int;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"cron">;
+            readonly calendar: Schema.Struct<{
+                readonly expression: Schema.NonEmptyString;
+                readonly timezone: Schema.NonEmptyString;
+            }>;
+        }>]>;
+        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>>>;
+    readonly name: Schema.NonEmptyString;
+    readonly router: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly tags: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+    readonly description: Schema.String;
+    readonly readOnly: Schema.optionalKey<Schema.Boolean>;
+    readonly title: Schema.optionalKey<Schema.String>;
+    readonly annotations: Schema.optionalKey<Schema.Struct<{
+        readonly title: Schema.optionalKey<Schema.String>;
+        readonly readOnlyHint: Schema.optionalKey<Schema.Boolean>;
+        readonly destructiveHint: Schema.optionalKey<Schema.Boolean>;
+        readonly idempotentHint: Schema.optionalKey<Schema.Boolean>;
+        readonly openWorldHint: Schema.optionalKey<Schema.Boolean>;
+    }>>;
+}>;
+export type HostedToolSummary = typeof HostedToolSummary.Type;
+declare const HostDeclarationInvalid_base: Schema.Class<HostDeclarationInvalid, Schema.TaggedStruct<"HostDeclarationInvalid", {
+    source: Schema.optionalKey<Schema.Literals<readonly ["app", "storage", "service"]>>;
+    errorName: Schema.optionalKey<Schema.String>;
+    code: Schema.optionalKey<Schema.String>;
+    message: Schema.optionalKey<Schema.String>;
+    fields: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean]>>>;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The module or declared capability shape could not be hosted. The detail names what the app
+ * declared wrongly; declarations bind no accounts.
+ */
+export declare class HostDeclarationInvalid extends HostDeclarationInvalid_base {
+}
+declare const HostEvaluationFailed_base: Schema.Class<HostEvaluationFailed, Schema.TaggedStruct<"HostEvaluationFailed", {
+    source: Schema.optionalKey<Schema.Literals<readonly ["app", "storage", "service"]>>;
+    errorName: Schema.optionalKey<Schema.String>;
+    code: Schema.optionalKey<Schema.String>;
+    message: Schema.optionalKey<Schema.String>;
+    fields: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean]>>>;
+}>, import("effect/Cause").YieldableError>;
+/** Fresh app evaluation failed before calling a tool. */
+export declare class HostEvaluationFailed extends HostEvaluationFailed_base {
+}
+/** Why one router's tools could not be read. The rest of the app's catalog is unaffected. */
+export declare const HostRouterError: Schema.Union<readonly [typeof ProviderError, typeof McpError, typeof SkillLoadFailed, typeof HostDeclarationInvalid, typeof HostEvaluationFailed]>;
+export type HostRouterError = typeof HostRouterError.Type;
+/**
+ * One router in a live catalog. `path` is "" for the app's root router. `skill` names the skill
+ * that carries this router's instructions. A router with `error` lists none of its tools.
+ */
+export declare const HostedRouter: Schema.Struct<{
+    readonly path: Schema.String;
+    readonly title: Schema.optionalKey<Schema.String>;
+    readonly description: Schema.optionalKey<Schema.String>;
+    readonly icons: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly src: Schema.NonEmptyString;
+        readonly mimeType: Schema.optionalKey<Schema.String>;
+        readonly sizes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        readonly theme: Schema.optionalKey<Schema.Literals<readonly ["light", "dark"]>>;
+    }>>>;
+    readonly tags: Schema.optionalKey<Schema.$Record<Schema.NonEmptyString, Schema.String>>;
+    readonly skill: Schema.optionalKey<Schema.NonEmptyString>;
+    readonly error: Schema.optionalKey<Schema.Union<readonly [typeof ProviderError, typeof McpError, typeof SkillLoadFailed, typeof HostDeclarationInvalid, typeof HostEvaluationFailed]>>;
+}>;
+export type HostedRouter = typeof HostedRouter.Type;
+/** A live evaluation's tools and the routers that group them. */
+export declare const HostedCatalog: Schema.Struct<{
+    readonly tools: Schema.$Array<Schema.Struct<{
+        readonly schedules: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly name: Schema.NonEmptyString;
+            readonly timing: Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"interval">;
+                readonly milliseconds: Schema.Int;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"cron">;
+                readonly calendar: Schema.Struct<{
+                    readonly expression: Schema.NonEmptyString;
+                    readonly timezone: Schema.NonEmptyString;
+                }>;
+            }>]>;
+            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>;
+        readonly name: Schema.NonEmptyString;
+        readonly router: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly tags: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+        readonly description: Schema.String;
+        readonly inputSchema: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        readonly readOnly: Schema.optionalKey<Schema.Boolean>;
+        readonly title: Schema.optionalKey<Schema.String>;
+        readonly outputSchema: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly annotations: Schema.optionalKey<Schema.Struct<{
+            readonly title: Schema.optionalKey<Schema.String>;
+            readonly readOnlyHint: Schema.optionalKey<Schema.Boolean>;
+            readonly destructiveHint: Schema.optionalKey<Schema.Boolean>;
+            readonly idempotentHint: Schema.optionalKey<Schema.Boolean>;
+            readonly openWorldHint: Schema.optionalKey<Schema.Boolean>;
+        }>>;
+        readonly _meta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    }>>;
+    readonly routers: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.String;
+        readonly title: Schema.optionalKey<Schema.String>;
+        readonly description: Schema.optionalKey<Schema.String>;
+        readonly icons: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly src: Schema.NonEmptyString;
+            readonly mimeType: Schema.optionalKey<Schema.String>;
+            readonly sizes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly theme: Schema.optionalKey<Schema.Literals<readonly ["light", "dark"]>>;
+        }>>>;
+        readonly tags: Schema.optionalKey<Schema.$Record<Schema.NonEmptyString, Schema.String>>;
+        readonly skill: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly error: Schema.optionalKey<Schema.Union<readonly [typeof ProviderError, typeof McpError, typeof SkillLoadFailed, typeof HostDeclarationInvalid, typeof HostEvaluationFailed]>>;
+    }>>;
+}>;
+export type HostedCatalog = typeof HostedCatalog.Type;
+/** A catalog without tool schemas. Browsing lists these and reads one full tool on selection. */
+export declare const HostedCatalogSummary: Schema.Struct<{
+    readonly tools: Schema.$Array<Schema.Struct<{
+        readonly schedules: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly name: Schema.NonEmptyString;
+            readonly timing: Schema.Union<readonly [Schema.Struct<{
+                readonly kind: Schema.Literal<"interval">;
+                readonly milliseconds: Schema.Int;
+            }>, Schema.Struct<{
+                readonly kind: Schema.Literal<"cron">;
+                readonly calendar: Schema.Struct<{
+                    readonly expression: Schema.NonEmptyString;
+                    readonly timezone: Schema.NonEmptyString;
+                }>;
+            }>]>;
+            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>>>;
+        readonly name: Schema.NonEmptyString;
+        readonly router: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly tags: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+        readonly description: Schema.String;
+        readonly readOnly: Schema.optionalKey<Schema.Boolean>;
+        readonly title: Schema.optionalKey<Schema.String>;
+        readonly annotations: Schema.optionalKey<Schema.Struct<{
+            readonly title: Schema.optionalKey<Schema.String>;
+            readonly readOnlyHint: Schema.optionalKey<Schema.Boolean>;
+            readonly destructiveHint: Schema.optionalKey<Schema.Boolean>;
+            readonly idempotentHint: Schema.optionalKey<Schema.Boolean>;
+            readonly openWorldHint: Schema.optionalKey<Schema.Boolean>;
+        }>>;
+    }>>;
+    readonly routers: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.String;
+        readonly title: Schema.optionalKey<Schema.String>;
+        readonly description: Schema.optionalKey<Schema.String>;
+        readonly icons: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+            readonly src: Schema.NonEmptyString;
+            readonly mimeType: Schema.optionalKey<Schema.String>;
+            readonly sizes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            readonly theme: Schema.optionalKey<Schema.Literals<readonly ["light", "dark"]>>;
+        }>>>;
+        readonly tags: Schema.optionalKey<Schema.$Record<Schema.NonEmptyString, Schema.String>>;
+        readonly skill: Schema.optionalKey<Schema.NonEmptyString>;
+        readonly error: Schema.optionalKey<Schema.Union<readonly [typeof ProviderError, typeof McpError, typeof SkillLoadFailed, typeof HostDeclarationInvalid, typeof HostEvaluationFailed]>>;
+    }>>;
+}>;
+export type HostedCatalogSummary = typeof HostedCatalogSummary.Type;
+/**
+ * A skill catalog and whether any of it came from `dynamicSkills`. Without a live loader the
+ * catalog is determined by the build and its evaluation inputs; with one it reflects a publisher.
+ * `cached` says the loader read through the app cache, so the cache's freshness and invalidation
+ * govern its publisher reads.
+ */
+export declare const SkillSources: Schema.Struct<{
+    readonly skills: Schema.$Array<Schema.Struct<{
+        readonly files: Schema.$Array<Schema.Struct<{
+            readonly path: Schema.NonEmptyString;
+            readonly content: Schema.String;
+        }>>;
+        readonly name: Schema.NonEmptyString;
+        readonly description: Schema.String;
+        readonly license: Schema.optionalKey<Schema.String>;
+        readonly compatibility: Schema.optionalKey<Schema.String>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+        readonly "allowed-tools": Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly dynamic: Schema.Boolean;
+    readonly cached: Schema.optionalKey<Schema.Boolean>;
+}>;
+export type SkillSources = typeof SkillSources.Type;
+/** Either response shape; `dynamic` is unknown for builds that predate skillSources. */
+export declare const SkillCatalogResponse: Schema.Union<readonly [Schema.Struct<{
+    readonly skills: Schema.$Array<Schema.Struct<{
+        readonly files: Schema.$Array<Schema.Struct<{
+            readonly path: Schema.NonEmptyString;
+            readonly content: Schema.String;
+        }>>;
+        readonly name: Schema.NonEmptyString;
+        readonly description: Schema.String;
+        readonly license: Schema.optionalKey<Schema.String>;
+        readonly compatibility: Schema.optionalKey<Schema.String>;
+        readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+        readonly "allowed-tools": Schema.optionalKey<Schema.String>;
+    }>>;
+    readonly dynamic: Schema.Boolean;
+    readonly cached: Schema.optionalKey<Schema.Boolean>;
+}>, Schema.$Array<Schema.Struct<{
+    readonly files: Schema.$Array<Schema.Struct<{
+        readonly path: Schema.NonEmptyString;
+        readonly content: Schema.String;
+    }>>;
+    readonly name: Schema.NonEmptyString;
+    readonly description: Schema.String;
+    readonly license: Schema.optionalKey<Schema.String>;
+    readonly compatibility: Schema.optionalKey<Schema.String>;
+    readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+    readonly "allowed-tools": Schema.optionalKey<Schema.String>;
+}>>]>;
+/** Whether a tool reads or writes. */
+export declare const ToolKind: Schema.Literals<readonly ["query", "mutation"]>;
+/**
+ * Check one account for one declared slot. The invocation supplies only that slot, as a single
+ * account even when the slot takes many. The app factory is not evaluated.
+ */
+export declare const AccountCheckCommand: Schema.Struct<{
+    readonly operation: Schema.Literal<"account-check">;
+    readonly requirement: Schema.NonEmptyString;
+}>;
+export type AccountCheckCommand = typeof AccountCheckCommand.Type;
+/** Apply the build's pending SQL migrations. No accounts are bound and the app is not evaluated. */
+export declare const MigrateCommand: Schema.Struct<{
+    readonly operation: Schema.Literal<"migrate">;
+}>;
+export type MigrateCommand = typeof MigrateCommand.Type;
+/** The migrations this command applied, oldest first, by position and file path. Empty when the database was current. */
+export declare const MigrateResult: Schema.$Array<Schema.Struct<{
+    readonly id: Schema.Int;
+    readonly name: Schema.NonEmptyString;
+}>>;
+export type MigrateResult = typeof MigrateResult.Type;
+/** Framework-owned dispatch, independent of app-authored HTTP routing. */
+export declare const HostRequest: Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+    readonly operation: Schema.Literal<"workflows">;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"workflow-validate">;
+    readonly name: Schema.NonEmptyString;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"workflow-run">;
+    readonly name: Schema.NonEmptyString;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>]>, Schema.Union<readonly [Schema.Struct<{
+    readonly operation: Schema.Literal<"webhooks">;
+}>, Schema.Struct<{
+    readonly name: Schema.NonEmptyString;
+    readonly subscriptionId: Schema.NonEmptyString;
+    readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+    readonly callbackUrl: Schema.String;
+    readonly secret: Schema.String;
+    readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly operation: Schema.Literal<"webhook-validate">;
+}>, Schema.Struct<{
+    readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly name: Schema.NonEmptyString;
+    readonly subscriptionId: Schema.NonEmptyString;
+    readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+    readonly callbackUrl: Schema.String;
+    readonly secret: Schema.String;
+    readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly operation: Schema.Literal<"webhook-complete">;
+}>, Schema.Struct<{
+    readonly name: Schema.NonEmptyString;
+    readonly subscriptionId: Schema.NonEmptyString;
+    readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+    readonly callbackUrl: Schema.String;
+    readonly secret: Schema.String;
+    readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly operation: Schema.Literal<"webhook-register">;
+}>, Schema.Struct<{
+    readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly name: Schema.NonEmptyString;
+    readonly subscriptionId: Schema.NonEmptyString;
+    readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+    readonly callbackUrl: Schema.String;
+    readonly secret: Schema.String;
+    readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly operation: Schema.Literal<"webhook-unregister">;
+}>, Schema.Struct<{
+    readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly request: Schema.Struct<{
+        readonly url: Schema.String;
+        readonly method: Schema.Literals<readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]>;
+        readonly headers: Schema.$Record<Schema.String, Schema.String>;
+        readonly body: Schema.String;
+    }>;
+    readonly name: Schema.NonEmptyString;
+    readonly subscriptionId: Schema.NonEmptyString;
+    readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+    readonly callbackUrl: Schema.String;
+    readonly secret: Schema.String;
+    readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly operation: Schema.Literal<"webhook-handle">;
+}>]>, Schema.Struct<{
+    readonly operation: Schema.Literal<"requirements">;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"inspect">;
+    /** Omit schemas. Only builds that declare the toolIndex capability accept this. */
+    readonly detail: Schema.optionalKey<Schema.Literal<"summary">>;
+    /** Describe only these tools. Only builds that declare the toolIndex capability accept this. */
+    readonly tools: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+    /**
+     * Describe only declared operations that have schedules, without dynamic tool discovery.
+     * Only builds that declare the scheduledTools capability accept this.
+     */
+    readonly scheduled: Schema.optionalKey<Schema.Literal<true>>;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"skills">;
+    /** Answer with SkillSources. Only builds that declare the skillSources capability accept this. */
+    readonly sources: Schema.optionalKey<Schema.Literal<true>>;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"query">;
+    readonly name: Schema.NonEmptyString;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"mutate">;
+    readonly name: Schema.NonEmptyString;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"call">;
+    readonly tool: Schema.NonEmptyString;
+    /**
+     * The caller's claim; the bundle rejects a call whose tool has the other kind. The host omits
+     * it for a tool its catalog does not list, and then opens storage for writing.
+     */
+    readonly kind: Schema.optionalKey<Schema.Literals<readonly ["query", "mutation"]>>;
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"account-check">;
+    readonly requirement: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly operation: Schema.Literal<"migrate">;
+}>]>;
+/** Parsed portable dispatch request. */
+export type HostRequest = typeof HostRequest.Type;
+declare const HostRequestInvalid_base: Schema.Class<HostRequestInvalid, Schema.TaggedStruct<"HostRequestInvalid", {}>, import("effect/Cause").YieldableError>;
+/** The dispatch request did not match the protocol. */
+export declare class HostRequestInvalid extends HostRequestInvalid_base {
+}
+declare const HostAccountsInvalid_base: Schema.Class<HostAccountsInvalid, Schema.TaggedStruct<"HostAccountsInvalid", {}>, import("effect/Cause").YieldableError>;
+/** Host-supplied accounts did not satisfy the declared slots or native method schemas. */
+export declare class HostAccountsInvalid extends HostAccountsInvalid_base {
+}
+declare const HostOperationNotFound_base: Schema.Class<HostOperationNotFound, Schema.TaggedStruct<"HostOperationNotFound", {}>, import("effect/Cause").YieldableError>;
+/** No query or mutation matched the requested name. */
+export declare class HostOperationNotFound extends HostOperationNotFound_base {
+}
+declare const HostOperationFailed_base: Schema.Class<HostOperationFailed, Schema.TaggedStruct<"HostOperationFailed", {
+    source: Schema.optionalKey<Schema.Literals<readonly ["app", "storage", "service"]>>;
+    errorName: Schema.optionalKey<Schema.String>;
+    code: Schema.optionalKey<Schema.String>;
+    message: Schema.optionalKey<Schema.String>;
+    fields: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean]>>>;
+}>, import("effect/Cause").YieldableError>;
+/** An app operation failed. Carries the app's own error name, code, fields and bounded message. */
+export declare class HostOperationFailed extends HostOperationFailed_base {
+}
+declare const HostToolNotFound_base: Schema.Class<HostToolNotFound, Schema.TaggedStruct<"HostToolNotFound", {}>, import("effect/Cause").YieldableError>;
+/** The freshly evaluated catalog did not contain the requested tool. */
+export declare class HostToolNotFound extends HostToolNotFound_base {
+}
+declare const HostKindMismatch_base: Schema.Class<HostKindMismatch, Schema.TaggedStruct<"HostKindMismatch", {
+    readonly tool: Schema.NonEmptyString;
+    readonly requested: Schema.Literals<readonly ["query", "mutation"]>;
+    readonly actual: Schema.Literals<readonly ["query", "mutation"]>;
+}>, import("effect/Cause").YieldableError>;
+/** The tool exists but is a query called as a mutation, or the reverse. Nothing ran. */
+export declare class HostKindMismatch extends HostKindMismatch_base {
+}
+/** One failing input location and its expected shape; never the supplied value. */
+export declare const InputProblem: Schema.String;
+/** Input decoding reports at most this many problems. */
+export declare const maxInputProblems = 10;
+declare const HostInputInvalid_base: Schema.Class<HostInputInvalid, Schema.TaggedStruct<"HostInputInvalid", {
+    readonly problems: Schema.optionalKey<Schema.$Array<Schema.String>>;
+}>, import("effect/Cause").YieldableError>;
+/** Native input decoding failed; supplied values are omitted. Builds before problems were reported send none. */
+export declare class HostInputInvalid extends HostInputInvalid_base {
+}
+declare const HostToolBlocked_base: Schema.Class<HostToolBlocked, Schema.TaggedStruct<"HostToolBlocked", {}>, import("effect/Cause").YieldableError>;
+/** The tool's approval policy blocked this call before its tool body ran. */
+export declare class HostToolBlocked extends HostToolBlocked_base {
+}
+declare const HostToolApprovalRequired_base: Schema.Class<HostToolApprovalRequired, Schema.TaggedStruct<"HostToolApprovalRequired", {
+    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly elicitation: Schema.Struct<{
+        readonly requestedSchema: Schema.Struct<{
+            readonly type: Schema.Literal<"object">;
+            readonly properties: Schema.$Record<Schema.String, Schema.Never>;
+        }>;
+        readonly mode: Schema.Literal<"form">;
+        readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+        readonly message: Schema.String;
+    }>;
+}>, import("effect/Cause").YieldableError>;
+/** Policy elicitation plus decoded input. No tool body ran; the host owns delivery and resumption. */
+export declare class HostToolApprovalRequired extends HostToolApprovalRequired_base {
+}
+declare const HostToolPolicyFailed_base: Schema.Class<HostToolPolicyFailed, Schema.TaggedStruct<"HostToolPolicyFailed", {}>, import("effect/Cause").YieldableError>;
+/** The tool's approval policy failed or returned an invalid decision. Author failures remain private. */
+export declare class HostToolPolicyFailed extends HostToolPolicyFailed_base {
+}
+declare const HostOutputInvalid_base: Schema.Class<HostOutputInvalid, Schema.TaggedStruct<"HostOutputInvalid", {}>, import("effect/Cause").YieldableError>;
+/** A tool result was not JSON; the result is never included in the error. */
+export declare class HostOutputInvalid extends HostOutputInvalid_base {
+}
+/**
+ * Safe error envelope. Author failures carry only their name, code, scalar fields and bounded
+ * message with account secrets replaced; no stack or cause value is serialized.
+ */
+export declare const HostError: Schema.Union<readonly [typeof OpenapiResponseError, typeof ProviderError, typeof McpError, typeof SkillLoadFailed, typeof WorkflowFailure, typeof HostRequestInvalid, typeof HostAccountsInvalid, typeof HostDeclarationInvalid, typeof HostEvaluationFailed, typeof HostOperationNotFound, typeof HostOperationFailed, typeof DatabaseLimitExceeded, typeof DatabaseFieldReserved, typeof HostToolNotFound, typeof HostInputInvalid, typeof HostOutputInvalid, typeof HostToolBlocked, typeof HostToolApprovalRequired, typeof HostToolPolicyFailed, typeof ElicitationFailed, typeof HostKindMismatch]>;
+/** Expected host failures. */
+export type HostError = typeof HostError.Type;
+/** Portable response envelope; callers parse the success value for their operation. */
+export declare const HostResponse: Schema.Union<readonly [Schema.Struct<{
+    readonly ok: Schema.Literal<true>;
+    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    readonly toolError: Schema.optionalKey<Schema.Literal<true>>;
+    /** The occurrences this invocation emitted, kept only because it succeeded. */
+    readonly events: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly id: Schema.String;
+        readonly occurredAt: Schema.Int;
+        readonly data: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly filters: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean]>>;
+        readonly account: Schema.NullOr<Schema.brand<Schema.String, "acc">>;
+    }>>>;
+}>, Schema.Struct<{
+    readonly ok: Schema.Literal<false>;
+    readonly error: Schema.Union<readonly [typeof OpenapiResponseError, typeof ProviderError, typeof McpError, typeof SkillLoadFailed, typeof WorkflowFailure, typeof HostRequestInvalid, typeof HostAccountsInvalid, typeof HostDeclarationInvalid, typeof HostEvaluationFailed, typeof HostOperationNotFound, typeof HostOperationFailed, typeof DatabaseLimitExceeded, typeof DatabaseFieldReserved, typeof HostToolNotFound, typeof HostInputInvalid, typeof HostOutputInvalid, typeof HostToolBlocked, typeof HostToolApprovalRequired, typeof HostToolPolicyFailed, typeof ElicitationFailed, typeof HostKindMismatch]>;
+}>]>;
+/** Parsed response envelope. */
+export type HostResponse = typeof HostResponse.Type;
+/**
+ * The JSON body the host sends to a bundle's generated server entry. The entry is compiled into
+ * the retained build, so this shape is part of the protocol too.
+ */
+export declare const HostInvocation: Schema.Struct<{
+    readonly command: Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+        readonly operation: Schema.Literal<"workflows">;
+    }>, Schema.Struct<{
+        readonly operation: Schema.Literal<"workflow-validate">;
+        readonly name: Schema.NonEmptyString;
+        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>, Schema.Struct<{
+        readonly operation: Schema.Literal<"workflow-run">;
+        readonly name: Schema.NonEmptyString;
+        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>]>, Schema.Union<readonly [Schema.Struct<{
+        readonly operation: Schema.Literal<"webhooks">;
+    }>, Schema.Struct<{
+        readonly name: Schema.NonEmptyString;
+        readonly subscriptionId: Schema.NonEmptyString;
+        readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+        readonly callbackUrl: Schema.String;
+        readonly secret: Schema.String;
+        readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly operation: Schema.Literal<"webhook-validate">;
+    }>, Schema.Struct<{
+        readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly name: Schema.NonEmptyString;
+        readonly subscriptionId: Schema.NonEmptyString;
+        readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+        readonly callbackUrl: Schema.String;
+        readonly secret: Schema.String;
+        readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly operation: Schema.Literal<"webhook-complete">;
+    }>, Schema.Struct<{
+        readonly name: Schema.NonEmptyString;
+        readonly subscriptionId: Schema.NonEmptyString;
+        readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+        readonly callbackUrl: Schema.String;
+        readonly secret: Schema.String;
+        readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly operation: Schema.Literal<"webhook-register">;
+    }>, Schema.Struct<{
+        readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly name: Schema.NonEmptyString;
+        readonly subscriptionId: Schema.NonEmptyString;
+        readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+        readonly callbackUrl: Schema.String;
+        readonly secret: Schema.String;
+        readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly operation: Schema.Literal<"webhook-unregister">;
+    }>, Schema.Struct<{
+        readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly request: Schema.Struct<{
+            readonly url: Schema.String;
+            readonly method: Schema.Literals<readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]>;
+            readonly headers: Schema.$Record<Schema.String, Schema.String>;
+            readonly body: Schema.String;
+        }>;
+        readonly name: Schema.NonEmptyString;
+        readonly subscriptionId: Schema.NonEmptyString;
+        readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+        readonly callbackUrl: Schema.String;
+        readonly secret: Schema.String;
+        readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        readonly operation: Schema.Literal<"webhook-handle">;
+    }>]>, Schema.Struct<{
+        readonly operation: Schema.Literal<"requirements">;
+    }>, Schema.Struct<{
+        readonly operation: Schema.Literal<"inspect">;
+        /** Omit schemas. Only builds that declare the toolIndex capability accept this. */
+        readonly detail: Schema.optionalKey<Schema.Literal<"summary">>;
+        /** Describe only these tools. Only builds that declare the toolIndex capability accept this. */
+        readonly tools: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+        /**
+         * Describe only declared operations that have schedules, without dynamic tool discovery.
+         * Only builds that declare the scheduledTools capability accept this.
+         */
+        readonly scheduled: Schema.optionalKey<Schema.Literal<true>>;
+    }>, Schema.Struct<{
+        readonly operation: Schema.Literal<"skills">;
+        /** Answer with SkillSources. Only builds that declare the skillSources capability accept this. */
+        readonly sources: Schema.optionalKey<Schema.Literal<true>>;
+    }>, Schema.Struct<{
+        readonly operation: Schema.Literal<"query">;
+        readonly name: Schema.NonEmptyString;
+        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>, Schema.Struct<{
+        readonly operation: Schema.Literal<"mutate">;
+        readonly name: Schema.NonEmptyString;
+        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>, Schema.Struct<{
+        readonly operation: Schema.Literal<"call">;
+        readonly tool: Schema.NonEmptyString;
+        /**
+         * The caller's claim; the bundle rejects a call whose tool has the other kind. The host omits
+         * it for a tool its catalog does not list, and then opens storage for writing.
+         */
+        readonly kind: Schema.optionalKey<Schema.Literals<readonly ["query", "mutation"]>>;
+        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>, Schema.Struct<{
+        readonly operation: Schema.Literal<"account-check">;
+        readonly requirement: Schema.NonEmptyString;
+    }>, Schema.Struct<{
+        readonly operation: Schema.Literal<"migrate">;
+    }>]>;
+    readonly accounts: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "acc">;
+        readonly provider: Schema.Struct<{
+            readonly name: Schema.NonEmptyString;
+            readonly auth: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+                readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly in: Schema.Literal<"header">;
+                    readonly name: Schema.String;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>, Schema.Struct<{
+                    readonly in: Schema.Literal<"query">;
+                    readonly name: Schema.NonEmptyString;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>]>>>;
+                readonly type: Schema.Literal<"secrets">;
+                readonly label: Schema.String;
+                readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            }>, Schema.Struct<{
+                readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly in: Schema.Literal<"header">;
+                    readonly name: Schema.String;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>, Schema.Struct<{
+                    readonly in: Schema.Literal<"query">;
+                    readonly name: Schema.NonEmptyString;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>]>>>;
+                readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly discover: Schema.String;
+                readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.String>;
+                readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+                readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+                readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                    readonly path: Schema.String;
+                }>>;
+                readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+                readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+                readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                readonly type: Schema.Literal<"oauth2">;
+            }>, Schema.Struct<{
+                readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly in: Schema.Literal<"header">;
+                    readonly name: Schema.String;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>, Schema.Struct<{
+                    readonly in: Schema.Literal<"query">;
+                    readonly name: Schema.NonEmptyString;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>]>>>;
+                readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly authorizationUrl: Schema.String;
+                readonly tokenUrl: Schema.String;
+                readonly revocationUrl: Schema.optionalKey<Schema.String>;
+                readonly scopes: Schema.$Array<Schema.String>;
+                readonly issuer: Schema.optionalKey<Schema.String>;
+                readonly discover: Schema.optionalKey<Schema.Never>;
+                readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.Never>;
+                readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                    readonly path: Schema.String;
+                }>>;
+                readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+                readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+                readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                readonly type: Schema.Literal<"oauth2">;
+            }>, Schema.Struct<{
+                readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly in: Schema.Literal<"header">;
+                    readonly name: Schema.String;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>, Schema.Struct<{
+                    readonly in: Schema.Literal<"query">;
+                    readonly name: Schema.NonEmptyString;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>]>>>;
+                readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+                readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                readonly grant: Schema.Literal<"client_credentials">;
+                readonly discover: Schema.String;
+                readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.String>;
+                readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+                readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+                readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly type: Schema.Literal<"oauth2">;
+            }>, Schema.Struct<{
+                readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly in: Schema.Literal<"header">;
+                    readonly name: Schema.String;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>, Schema.Struct<{
+                    readonly in: Schema.Literal<"query">;
+                    readonly name: Schema.NonEmptyString;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>]>>>;
+                readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+                readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                readonly discover: Schema.optionalKey<Schema.Never>;
+                readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.Never>;
+                readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                readonly grant: Schema.Literal<"client_credentials">;
+                readonly tokenUrl: Schema.String;
+                readonly revocationUrl: Schema.optionalKey<Schema.String>;
+                readonly scopes: Schema.$Array<Schema.String>;
+                readonly type: Schema.Literal<"oauth2">;
+            }>]>>;
+            readonly hosts: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        }>;
+        readonly method: Schema.NonEmptyString;
+        /**
+         * Changes when the account is reconnected or its credentials replaced, not on renewal. Hosts
+         * send it since credential generations; `apps@0.0.1-beta.0` and `beta.1` ignore it.
+         */
+        readonly generation: Schema.optionalKey<Schema.Int>;
+        readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>, Schema.$Array<Schema.Struct<{
+        readonly id: Schema.brand<Schema.String, "acc">;
+        readonly provider: Schema.Struct<{
+            readonly name: Schema.NonEmptyString;
+            readonly auth: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+                readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly in: Schema.Literal<"header">;
+                    readonly name: Schema.String;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>, Schema.Struct<{
+                    readonly in: Schema.Literal<"query">;
+                    readonly name: Schema.NonEmptyString;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>]>>>;
+                readonly type: Schema.Literal<"secrets">;
+                readonly label: Schema.String;
+                readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            }>, Schema.Struct<{
+                readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly in: Schema.Literal<"header">;
+                    readonly name: Schema.String;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>, Schema.Struct<{
+                    readonly in: Schema.Literal<"query">;
+                    readonly name: Schema.NonEmptyString;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>]>>>;
+                readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly discover: Schema.String;
+                readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.String>;
+                readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+                readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+                readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                    readonly path: Schema.String;
+                }>>;
+                readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+                readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+                readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                readonly type: Schema.Literal<"oauth2">;
+            }>, Schema.Struct<{
+                readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly in: Schema.Literal<"header">;
+                    readonly name: Schema.String;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>, Schema.Struct<{
+                    readonly in: Schema.Literal<"query">;
+                    readonly name: Schema.NonEmptyString;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>]>>>;
+                readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly authorizationUrl: Schema.String;
+                readonly tokenUrl: Schema.String;
+                readonly revocationUrl: Schema.optionalKey<Schema.String>;
+                readonly scopes: Schema.$Array<Schema.String>;
+                readonly issuer: Schema.optionalKey<Schema.String>;
+                readonly discover: Schema.optionalKey<Schema.Never>;
+                readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.Never>;
+                readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                    readonly path: Schema.String;
+                }>>;
+                readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+                readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+                readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                readonly type: Schema.Literal<"oauth2">;
+            }>, Schema.Struct<{
+                readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly in: Schema.Literal<"header">;
+                    readonly name: Schema.String;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>, Schema.Struct<{
+                    readonly in: Schema.Literal<"query">;
+                    readonly name: Schema.NonEmptyString;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>]>>>;
+                readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+                readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                readonly grant: Schema.Literal<"client_credentials">;
+                readonly discover: Schema.String;
+                readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.String>;
+                readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+                readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+                readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                readonly type: Schema.Literal<"oauth2">;
+            }>, Schema.Struct<{
+                readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly in: Schema.Literal<"header">;
+                    readonly name: Schema.String;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>, Schema.Struct<{
+                    readonly in: Schema.Literal<"query">;
+                    readonly name: Schema.NonEmptyString;
+                    readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                        readonly field: Schema.NonEmptyString;
+                    }>, Schema.Struct<{
+                        readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>]>>;
+                    }>]>>;
+                }>]>>>;
+                readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+                readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                readonly discover: Schema.optionalKey<Schema.Never>;
+                readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.Never>;
+                readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                readonly grant: Schema.Literal<"client_credentials">;
+                readonly tokenUrl: Schema.String;
+                readonly revocationUrl: Schema.optionalKey<Schema.String>;
+                readonly scopes: Schema.$Array<Schema.String>;
+                readonly type: Schema.Literal<"oauth2">;
+            }>]>>;
+            readonly hosts: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        }>;
+        readonly method: Schema.NonEmptyString;
+        /**
+         * Changes when the account is reconnected or its credentials replaced, not on renewal. Hosts
+         * send it since credential generations; `apps@0.0.1-beta.0` and `beta.1` ignore it.
+         */
+        readonly generation: Schema.optionalKey<Schema.Int>;
+        readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    }>>]>>;
+    readonly approval: Schema.optionalKey<Schema.Struct<{
+        readonly tool: Schema.NonEmptyString;
+        readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+    }>>;
+    readonly replay: Schema.optionalKey<Schema.Struct<{
+        readonly key: Schema.NonEmptyString;
+        readonly fingerprint: Schema.NonEmptyString;
+    }>>;
+    readonly deadline: Schema.optionalKey<Schema.Finite>;
+    readonly workflowRun: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "wfr">>;
+}>;
+export type HostInvocation = typeof HostInvocation.Type;
+/**
+ * Who sends each message. The host must keep accepting everything a released protocol's bundles
+ * send (`bundle`), and must send a released protocol's bundles only what they accept, or gate the
+ * addition on something the bundle declared (`host`). Names a released protocol used and this one
+ * dropped, such as `tools`, keep their direction here.
+ */
+export declare const messageDirections: {
+    readonly invocation: "host";
+    readonly request: "host";
+    readonly accounts: "host";
+    readonly elicitationReply: "host";
+    readonly workflowStepReply: "host";
+    readonly cacheReply: "host";
+    readonly response: "bundle";
+    readonly requirements: "bundle";
+    readonly catalog: "bundle";
+    readonly catalogSummary: "bundle";
+    readonly tools: "bundle";
+    readonly toolSummaries: "bundle";
+    readonly skills: "bundle";
+    readonly elicitationRequest: "bundle";
+    readonly workflowStep: "bundle";
+    readonly workflowControl: "bundle";
+    readonly cacheCommand: "bundle";
+    readonly accountCheck: "bundle";
+    readonly migrate: "bundle";
+};
+/** A message name every protocol so far has used. */
+export type MessageName = keyof typeof messageDirections;
+/** Every message of the current protocol. The snapshot records them by name. */
+export declare const current: {
+    readonly version: 12;
+    readonly schemas: {
+        readonly invocation: Schema.Struct<{
+            readonly command: Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+                readonly operation: Schema.Literal<"workflows">;
+            }>, Schema.Struct<{
+                readonly operation: Schema.Literal<"workflow-validate">;
+                readonly name: Schema.NonEmptyString;
+                readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            }>, Schema.Struct<{
+                readonly operation: Schema.Literal<"workflow-run">;
+                readonly name: Schema.NonEmptyString;
+                readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            }>]>, Schema.Union<readonly [Schema.Struct<{
+                readonly operation: Schema.Literal<"webhooks">;
+            }>, Schema.Struct<{
+                readonly name: Schema.NonEmptyString;
+                readonly subscriptionId: Schema.NonEmptyString;
+                readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+                readonly callbackUrl: Schema.String;
+                readonly secret: Schema.String;
+                readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly operation: Schema.Literal<"webhook-validate">;
+            }>, Schema.Struct<{
+                readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly name: Schema.NonEmptyString;
+                readonly subscriptionId: Schema.NonEmptyString;
+                readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+                readonly callbackUrl: Schema.String;
+                readonly secret: Schema.String;
+                readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly operation: Schema.Literal<"webhook-complete">;
+            }>, Schema.Struct<{
+                readonly name: Schema.NonEmptyString;
+                readonly subscriptionId: Schema.NonEmptyString;
+                readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+                readonly callbackUrl: Schema.String;
+                readonly secret: Schema.String;
+                readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly operation: Schema.Literal<"webhook-register">;
+            }>, Schema.Struct<{
+                readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly name: Schema.NonEmptyString;
+                readonly subscriptionId: Schema.NonEmptyString;
+                readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+                readonly callbackUrl: Schema.String;
+                readonly secret: Schema.String;
+                readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly operation: Schema.Literal<"webhook-unregister">;
+            }>, Schema.Struct<{
+                readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly request: Schema.Struct<{
+                    readonly url: Schema.String;
+                    readonly method: Schema.Literals<readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]>;
+                    readonly headers: Schema.$Record<Schema.String, Schema.String>;
+                    readonly body: Schema.String;
+                }>;
+                readonly name: Schema.NonEmptyString;
+                readonly subscriptionId: Schema.NonEmptyString;
+                readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+                readonly callbackUrl: Schema.String;
+                readonly secret: Schema.String;
+                readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly operation: Schema.Literal<"webhook-handle">;
+            }>]>, Schema.Struct<{
+                readonly operation: Schema.Literal<"requirements">;
+            }>, Schema.Struct<{
+                readonly operation: Schema.Literal<"inspect">;
+                /** Omit schemas. Only builds that declare the toolIndex capability accept this. */
+                readonly detail: Schema.optionalKey<Schema.Literal<"summary">>;
+                /** Describe only these tools. Only builds that declare the toolIndex capability accept this. */
+                readonly tools: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                /**
+                 * Describe only declared operations that have schedules, without dynamic tool discovery.
+                 * Only builds that declare the scheduledTools capability accept this.
+                 */
+                readonly scheduled: Schema.optionalKey<Schema.Literal<true>>;
+            }>, Schema.Struct<{
+                readonly operation: Schema.Literal<"skills">;
+                /** Answer with SkillSources. Only builds that declare the skillSources capability accept this. */
+                readonly sources: Schema.optionalKey<Schema.Literal<true>>;
+            }>, Schema.Struct<{
+                readonly operation: Schema.Literal<"query">;
+                readonly name: Schema.NonEmptyString;
+                readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            }>, Schema.Struct<{
+                readonly operation: Schema.Literal<"mutate">;
+                readonly name: Schema.NonEmptyString;
+                readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            }>, Schema.Struct<{
+                readonly operation: Schema.Literal<"call">;
+                readonly tool: Schema.NonEmptyString;
+                /**
+                 * The caller's claim; the bundle rejects a call whose tool has the other kind. The host omits
+                 * it for a tool its catalog does not list, and then opens storage for writing.
+                 */
+                readonly kind: Schema.optionalKey<Schema.Literals<readonly ["query", "mutation"]>>;
+                readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            }>, Schema.Struct<{
+                readonly operation: Schema.Literal<"account-check">;
+                readonly requirement: Schema.NonEmptyString;
+            }>, Schema.Struct<{
+                readonly operation: Schema.Literal<"migrate">;
+            }>]>;
+            readonly accounts: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+                readonly id: Schema.brand<Schema.String, "acc">;
+                readonly provider: Schema.Struct<{
+                    readonly name: Schema.NonEmptyString;
+                    readonly auth: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+                        readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                            readonly in: Schema.Literal<"header">;
+                            readonly name: Schema.String;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>, Schema.Struct<{
+                            readonly in: Schema.Literal<"query">;
+                            readonly name: Schema.NonEmptyString;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>]>>>;
+                        readonly type: Schema.Literal<"secrets">;
+                        readonly label: Schema.String;
+                        readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                    }>, Schema.Struct<{
+                        readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                            readonly in: Schema.Literal<"header">;
+                            readonly name: Schema.String;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>, Schema.Struct<{
+                            readonly in: Schema.Literal<"query">;
+                            readonly name: Schema.NonEmptyString;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>]>>>;
+                        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                        readonly discover: Schema.String;
+                        readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.String>;
+                        readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+                        readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                        readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                            readonly path: Schema.String;
+                        }>>;
+                        readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+                        readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                        readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+                        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                        readonly type: Schema.Literal<"oauth2">;
+                    }>, Schema.Struct<{
+                        readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                            readonly in: Schema.Literal<"header">;
+                            readonly name: Schema.String;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>, Schema.Struct<{
+                            readonly in: Schema.Literal<"query">;
+                            readonly name: Schema.NonEmptyString;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>]>>>;
+                        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                        readonly authorizationUrl: Schema.String;
+                        readonly tokenUrl: Schema.String;
+                        readonly revocationUrl: Schema.optionalKey<Schema.String>;
+                        readonly scopes: Schema.$Array<Schema.String>;
+                        readonly issuer: Schema.optionalKey<Schema.String>;
+                        readonly discover: Schema.optionalKey<Schema.Never>;
+                        readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.Never>;
+                        readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                            readonly path: Schema.String;
+                        }>>;
+                        readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+                        readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                        readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+                        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                        readonly type: Schema.Literal<"oauth2">;
+                    }>, Schema.Struct<{
+                        readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                            readonly in: Schema.Literal<"header">;
+                            readonly name: Schema.String;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>, Schema.Struct<{
+                            readonly in: Schema.Literal<"query">;
+                            readonly name: Schema.NonEmptyString;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>]>>>;
+                        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                        readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+                        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                        readonly grant: Schema.Literal<"client_credentials">;
+                        readonly discover: Schema.String;
+                        readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.String>;
+                        readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+                        readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                        readonly type: Schema.Literal<"oauth2">;
+                    }>, Schema.Struct<{
+                        readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                            readonly in: Schema.Literal<"header">;
+                            readonly name: Schema.String;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>, Schema.Struct<{
+                            readonly in: Schema.Literal<"query">;
+                            readonly name: Schema.NonEmptyString;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>]>>>;
+                        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                        readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+                        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly discover: Schema.optionalKey<Schema.Never>;
+                        readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.Never>;
+                        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                        readonly grant: Schema.Literal<"client_credentials">;
+                        readonly tokenUrl: Schema.String;
+                        readonly revocationUrl: Schema.optionalKey<Schema.String>;
+                        readonly scopes: Schema.$Array<Schema.String>;
+                        readonly type: Schema.Literal<"oauth2">;
+                    }>]>>;
+                    readonly hosts: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                }>;
+                readonly method: Schema.NonEmptyString;
+                /**
+                 * Changes when the account is reconnected or its credentials replaced, not on renewal. Hosts
+                 * send it since credential generations; `apps@0.0.1-beta.0` and `beta.1` ignore it.
+                 */
+                readonly generation: Schema.optionalKey<Schema.Int>;
+                readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            }>, Schema.$Array<Schema.Struct<{
+                readonly id: Schema.brand<Schema.String, "acc">;
+                readonly provider: Schema.Struct<{
+                    readonly name: Schema.NonEmptyString;
+                    readonly auth: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+                        readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                            readonly in: Schema.Literal<"header">;
+                            readonly name: Schema.String;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>, Schema.Struct<{
+                            readonly in: Schema.Literal<"query">;
+                            readonly name: Schema.NonEmptyString;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>]>>>;
+                        readonly type: Schema.Literal<"secrets">;
+                        readonly label: Schema.String;
+                        readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                    }>, Schema.Struct<{
+                        readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                            readonly in: Schema.Literal<"header">;
+                            readonly name: Schema.String;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>, Schema.Struct<{
+                            readonly in: Schema.Literal<"query">;
+                            readonly name: Schema.NonEmptyString;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>]>>>;
+                        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                        readonly discover: Schema.String;
+                        readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.String>;
+                        readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+                        readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                        readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                            readonly path: Schema.String;
+                        }>>;
+                        readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+                        readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                        readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+                        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                        readonly type: Schema.Literal<"oauth2">;
+                    }>, Schema.Struct<{
+                        readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                            readonly in: Schema.Literal<"header">;
+                            readonly name: Schema.String;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>, Schema.Struct<{
+                            readonly in: Schema.Literal<"query">;
+                            readonly name: Schema.NonEmptyString;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>]>>>;
+                        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                        readonly authorizationUrl: Schema.String;
+                        readonly tokenUrl: Schema.String;
+                        readonly revocationUrl: Schema.optionalKey<Schema.String>;
+                        readonly scopes: Schema.$Array<Schema.String>;
+                        readonly issuer: Schema.optionalKey<Schema.String>;
+                        readonly discover: Schema.optionalKey<Schema.Never>;
+                        readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.Never>;
+                        readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                            readonly path: Schema.String;
+                        }>>;
+                        readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+                        readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                        readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+                        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                        readonly type: Schema.Literal<"oauth2">;
+                    }>, Schema.Struct<{
+                        readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                            readonly in: Schema.Literal<"header">;
+                            readonly name: Schema.String;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>, Schema.Struct<{
+                            readonly in: Schema.Literal<"query">;
+                            readonly name: Schema.NonEmptyString;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>]>>>;
+                        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                        readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+                        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                        readonly grant: Schema.Literal<"client_credentials">;
+                        readonly discover: Schema.String;
+                        readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.String>;
+                        readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+                        readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                        readonly type: Schema.Literal<"oauth2">;
+                    }>, Schema.Struct<{
+                        readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                            readonly in: Schema.Literal<"header">;
+                            readonly name: Schema.String;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>, Schema.Struct<{
+                            readonly in: Schema.Literal<"query">;
+                            readonly name: Schema.NonEmptyString;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>]>>>;
+                        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                        readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+                        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly discover: Schema.optionalKey<Schema.Never>;
+                        readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.Never>;
+                        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                        readonly grant: Schema.Literal<"client_credentials">;
+                        readonly tokenUrl: Schema.String;
+                        readonly revocationUrl: Schema.optionalKey<Schema.String>;
+                        readonly scopes: Schema.$Array<Schema.String>;
+                        readonly type: Schema.Literal<"oauth2">;
+                    }>]>>;
+                    readonly hosts: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                }>;
+                readonly method: Schema.NonEmptyString;
+                /**
+                 * Changes when the account is reconnected or its credentials replaced, not on renewal. Hosts
+                 * send it since credential generations; `apps@0.0.1-beta.0` and `beta.1` ignore it.
+                 */
+                readonly generation: Schema.optionalKey<Schema.Int>;
+                readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            }>>]>>;
+            readonly approval: Schema.optionalKey<Schema.Struct<{
+                readonly tool: Schema.NonEmptyString;
+                readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            }>>;
+            readonly replay: Schema.optionalKey<Schema.Struct<{
+                readonly key: Schema.NonEmptyString;
+                readonly fingerprint: Schema.NonEmptyString;
+            }>>;
+            readonly deadline: Schema.optionalKey<Schema.Finite>;
+            readonly workflowRun: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "wfr">>;
+        }>;
+        readonly request: Schema.Union<readonly [Schema.Union<readonly [Schema.Struct<{
+            readonly operation: Schema.Literal<"workflows">;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"workflow-validate">;
+            readonly name: Schema.NonEmptyString;
+            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"workflow-run">;
+            readonly name: Schema.NonEmptyString;
+            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>]>, Schema.Union<readonly [Schema.Struct<{
+            readonly operation: Schema.Literal<"webhooks">;
+        }>, Schema.Struct<{
+            readonly name: Schema.NonEmptyString;
+            readonly subscriptionId: Schema.NonEmptyString;
+            readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+            readonly callbackUrl: Schema.String;
+            readonly secret: Schema.String;
+            readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly operation: Schema.Literal<"webhook-validate">;
+        }>, Schema.Struct<{
+            readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly name: Schema.NonEmptyString;
+            readonly subscriptionId: Schema.NonEmptyString;
+            readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+            readonly callbackUrl: Schema.String;
+            readonly secret: Schema.String;
+            readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly operation: Schema.Literal<"webhook-complete">;
+        }>, Schema.Struct<{
+            readonly name: Schema.NonEmptyString;
+            readonly subscriptionId: Schema.NonEmptyString;
+            readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+            readonly callbackUrl: Schema.String;
+            readonly secret: Schema.String;
+            readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly operation: Schema.Literal<"webhook-register">;
+        }>, Schema.Struct<{
+            readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly name: Schema.NonEmptyString;
+            readonly subscriptionId: Schema.NonEmptyString;
+            readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+            readonly callbackUrl: Schema.String;
+            readonly secret: Schema.String;
+            readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly operation: Schema.Literal<"webhook-unregister">;
+        }>, Schema.Struct<{
+            readonly state: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly request: Schema.Struct<{
+                readonly url: Schema.String;
+                readonly method: Schema.Literals<readonly ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"]>;
+                readonly headers: Schema.$Record<Schema.String, Schema.String>;
+                readonly body: Schema.String;
+            }>;
+            readonly name: Schema.NonEmptyString;
+            readonly subscriptionId: Schema.NonEmptyString;
+            readonly sourceAccount: Schema.brand<Schema.String, "acc">;
+            readonly callbackUrl: Schema.String;
+            readonly secret: Schema.String;
+            readonly config: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly operation: Schema.Literal<"webhook-handle">;
+        }>]>, Schema.Struct<{
+            readonly operation: Schema.Literal<"requirements">;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"inspect">;
+            /** Omit schemas. Only builds that declare the toolIndex capability accept this. */
+            readonly detail: Schema.optionalKey<Schema.Literal<"summary">>;
+            /** Describe only these tools. Only builds that declare the toolIndex capability accept this. */
+            readonly tools: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+            /**
+             * Describe only declared operations that have schedules, without dynamic tool discovery.
+             * Only builds that declare the scheduledTools capability accept this.
+             */
+            readonly scheduled: Schema.optionalKey<Schema.Literal<true>>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"skills">;
+            /** Answer with SkillSources. Only builds that declare the skillSources capability accept this. */
+            readonly sources: Schema.optionalKey<Schema.Literal<true>>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"query">;
+            readonly name: Schema.NonEmptyString;
+            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"mutate">;
+            readonly name: Schema.NonEmptyString;
+            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"call">;
+            readonly tool: Schema.NonEmptyString;
+            /**
+             * The caller's claim; the bundle rejects a call whose tool has the other kind. The host omits
+             * it for a tool its catalog does not list, and then opens storage for writing.
+             */
+            readonly kind: Schema.optionalKey<Schema.Literals<readonly ["query", "mutation"]>>;
+            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"account-check">;
+            readonly requirement: Schema.NonEmptyString;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"migrate">;
+        }>]>;
+        readonly response: Schema.Union<readonly [Schema.Struct<{
+            readonly ok: Schema.Literal<true>;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly toolError: Schema.optionalKey<Schema.Literal<true>>;
+            /** The occurrences this invocation emitted, kept only because it succeeded. */
+            readonly events: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly id: Schema.String;
+                readonly occurredAt: Schema.Int;
+                readonly data: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly filters: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean]>>;
+                readonly account: Schema.NullOr<Schema.brand<Schema.String, "acc">>;
+            }>>>;
+        }>, Schema.Struct<{
+            readonly ok: Schema.Literal<false>;
+            readonly error: Schema.Union<readonly [typeof OpenapiResponseError, typeof ProviderError, typeof McpError, typeof SkillLoadFailed, typeof WorkflowFailure, typeof HostRequestInvalid, typeof HostAccountsInvalid, typeof HostDeclarationInvalid, typeof HostEvaluationFailed, typeof HostOperationNotFound, typeof HostOperationFailed, typeof DatabaseLimitExceeded, typeof DatabaseFieldReserved, typeof HostToolNotFound, typeof HostInputInvalid, typeof HostOutputInvalid, typeof HostToolBlocked, typeof HostToolApprovalRequired, typeof HostToolPolicyFailed, typeof ElicitationFailed, typeof HostKindMismatch]>;
+        }>]>;
+        readonly requirements: Schema.Struct<{
+            /** Protocol support of this retained framework build, not an author-declared requirement. */
+            readonly capabilities: Schema.optionalKey<Schema.Struct<{
+                readonly skills: Schema.Literal<true>;
+                /** Accepts inspect detail and tools. Earlier builds reject both as excess fields. */
+                readonly toolIndex: Schema.optionalKey<Schema.Literal<true>>;
+                /** Accepts skills sources and reports whether the catalog includes a live loader. */
+                readonly skillSources: Schema.optionalKey<Schema.Literal<true>>;
+                /** Accepts scheduled inspection. Earlier builds reject it as an excess field. */
+                readonly scheduledTools: Schema.optionalKey<Schema.Literal<true>>;
+            }>>;
+            /**
+             * The document database an app of protocol 9 or earlier declared. Apps of this protocol declare
+             * `sql` instead; the field remains so requirements read from older retained builds keep their meaning.
+             */
+            readonly database: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+                readonly fields: Schema.$Record<Schema.String, Schema.Struct<{
+                    readonly kind: Schema.Literals<readonly ["string", "number", "boolean", "id", "userId"]>;
+                    readonly optional: Schema.optional<Schema.Boolean>;
+                    readonly default: Schema.optional<Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean]>>;
+                    readonly references: Schema.optional<Schema.String>;
+                }>>;
+                readonly indexes: Schema.$Array<Schema.Struct<{
+                    readonly name: Schema.String;
+                    readonly fields: Schema.NonEmptyArray<Schema.String>;
+                }>>;
+            }>>>;
+            readonly accounts: Schema.$Record<Schema.NonEmptyString, Schema.Struct<{
+                readonly definition: Schema.Struct<{
+                    readonly name: Schema.NonEmptyString;
+                    readonly auth: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+                        readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                            readonly in: Schema.Literal<"header">;
+                            readonly name: Schema.String;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>, Schema.Struct<{
+                            readonly in: Schema.Literal<"query">;
+                            readonly name: Schema.NonEmptyString;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>]>>>;
+                        readonly type: Schema.Literal<"secrets">;
+                        readonly label: Schema.String;
+                        readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                    }>, Schema.Struct<{
+                        readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                            readonly in: Schema.Literal<"header">;
+                            readonly name: Schema.String;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>, Schema.Struct<{
+                            readonly in: Schema.Literal<"query">;
+                            readonly name: Schema.NonEmptyString;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>]>>>;
+                        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                        readonly discover: Schema.String;
+                        readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.String>;
+                        readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+                        readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                        readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                            readonly path: Schema.String;
+                        }>>;
+                        readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+                        readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                        readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+                        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                        readonly type: Schema.Literal<"oauth2">;
+                    }>, Schema.Struct<{
+                        readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                            readonly in: Schema.Literal<"header">;
+                            readonly name: Schema.String;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>, Schema.Struct<{
+                            readonly in: Schema.Literal<"query">;
+                            readonly name: Schema.NonEmptyString;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>]>>>;
+                        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                        readonly authorizationUrl: Schema.String;
+                        readonly tokenUrl: Schema.String;
+                        readonly revocationUrl: Schema.optionalKey<Schema.String>;
+                        readonly scopes: Schema.$Array<Schema.String>;
+                        readonly issuer: Schema.optionalKey<Schema.String>;
+                        readonly discover: Schema.optionalKey<Schema.Never>;
+                        readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.Never>;
+                        readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                            readonly path: Schema.String;
+                        }>>;
+                        readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+                        readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                        readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+                        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                        readonly type: Schema.Literal<"oauth2">;
+                    }>, Schema.Struct<{
+                        readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                            readonly in: Schema.Literal<"header">;
+                            readonly name: Schema.String;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>, Schema.Struct<{
+                            readonly in: Schema.Literal<"query">;
+                            readonly name: Schema.NonEmptyString;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>]>>>;
+                        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                        readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+                        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                        readonly grant: Schema.Literal<"client_credentials">;
+                        readonly discover: Schema.String;
+                        readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.String>;
+                        readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+                        readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                        readonly type: Schema.Literal<"oauth2">;
+                    }>, Schema.Struct<{
+                        readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                        readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                            readonly in: Schema.Literal<"header">;
+                            readonly name: Schema.String;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>, Schema.Struct<{
+                            readonly in: Schema.Literal<"query">;
+                            readonly name: Schema.NonEmptyString;
+                            readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>, Schema.Struct<{
+                                readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                    readonly field: Schema.NonEmptyString;
+                                }>]>>;
+                            }>]>>;
+                        }>]>>>;
+                        readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                        readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+                        readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                        readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                        readonly discover: Schema.optionalKey<Schema.Never>;
+                        readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.Never>;
+                        readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                        readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                        readonly grant: Schema.Literal<"client_credentials">;
+                        readonly tokenUrl: Schema.String;
+                        readonly revocationUrl: Schema.optionalKey<Schema.String>;
+                        readonly scopes: Schema.$Array<Schema.String>;
+                        readonly type: Schema.Literal<"oauth2">;
+                    }>]>>;
+                    readonly hosts: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                }>;
+                readonly cardinality: Schema.Literals<readonly ["one", "many"]>;
+                /**
+                 * The slot's provider defines an account check. Kept beside the definition, not in it, so
+                 * adding or editing a check never changes the provider's identity.
+                 */
+                readonly health: Schema.optionalKey<Schema.Literal<true>>;
+            }>>;
+            /** The build has SQL files in `migrations/` and owns a raw SQLite database. */
+            readonly sql: Schema.optionalKey<Schema.Literal<true>>;
+            /** The events the app declares, so a host lists them without evaluating the app. */
+            readonly events: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Struct<{
+                readonly description: Schema.String;
+                readonly filters: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly payload: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            }>>>;
+        }>;
+        readonly catalog: Schema.Struct<{
+            readonly tools: Schema.$Array<Schema.Struct<{
+                readonly schedules: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                    readonly name: Schema.NonEmptyString;
+                    readonly timing: Schema.Union<readonly [Schema.Struct<{
+                        readonly kind: Schema.Literal<"interval">;
+                        readonly milliseconds: Schema.Int;
+                    }>, Schema.Struct<{
+                        readonly kind: Schema.Literal<"cron">;
+                        readonly calendar: Schema.Struct<{
+                            readonly expression: Schema.NonEmptyString;
+                            readonly timezone: Schema.NonEmptyString;
+                        }>;
+                    }>]>;
+                    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                }>>>;
+                readonly name: Schema.NonEmptyString;
+                readonly router: Schema.optionalKey<Schema.NonEmptyString>;
+                readonly tags: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly description: Schema.String;
+                readonly inputSchema: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly readOnly: Schema.optionalKey<Schema.Boolean>;
+                readonly title: Schema.optionalKey<Schema.String>;
+                readonly outputSchema: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                readonly annotations: Schema.optionalKey<Schema.Struct<{
+                    readonly title: Schema.optionalKey<Schema.String>;
+                    readonly readOnlyHint: Schema.optionalKey<Schema.Boolean>;
+                    readonly destructiveHint: Schema.optionalKey<Schema.Boolean>;
+                    readonly idempotentHint: Schema.optionalKey<Schema.Boolean>;
+                    readonly openWorldHint: Schema.optionalKey<Schema.Boolean>;
+                }>>;
+                readonly _meta: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            }>>;
+            readonly routers: Schema.$Array<Schema.Struct<{
+                readonly path: Schema.String;
+                readonly title: Schema.optionalKey<Schema.String>;
+                readonly description: Schema.optionalKey<Schema.String>;
+                readonly icons: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                    readonly src: Schema.NonEmptyString;
+                    readonly mimeType: Schema.optionalKey<Schema.String>;
+                    readonly sizes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                    readonly theme: Schema.optionalKey<Schema.Literals<readonly ["light", "dark"]>>;
+                }>>>;
+                readonly tags: Schema.optionalKey<Schema.$Record<Schema.NonEmptyString, Schema.String>>;
+                readonly skill: Schema.optionalKey<Schema.NonEmptyString>;
+                readonly error: Schema.optionalKey<Schema.Union<readonly [typeof ProviderError, typeof McpError, typeof SkillLoadFailed, typeof HostDeclarationInvalid, typeof HostEvaluationFailed]>>;
+            }>>;
+        }>;
+        readonly catalogSummary: Schema.Struct<{
+            readonly tools: Schema.$Array<Schema.Struct<{
+                readonly schedules: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                    readonly name: Schema.NonEmptyString;
+                    readonly timing: Schema.Union<readonly [Schema.Struct<{
+                        readonly kind: Schema.Literal<"interval">;
+                        readonly milliseconds: Schema.Int;
+                    }>, Schema.Struct<{
+                        readonly kind: Schema.Literal<"cron">;
+                        readonly calendar: Schema.Struct<{
+                            readonly expression: Schema.NonEmptyString;
+                            readonly timezone: Schema.NonEmptyString;
+                        }>;
+                    }>]>;
+                    readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                }>>>;
+                readonly name: Schema.NonEmptyString;
+                readonly router: Schema.optionalKey<Schema.NonEmptyString>;
+                readonly tags: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                readonly description: Schema.String;
+                readonly readOnly: Schema.optionalKey<Schema.Boolean>;
+                readonly title: Schema.optionalKey<Schema.String>;
+                readonly annotations: Schema.optionalKey<Schema.Struct<{
+                    readonly title: Schema.optionalKey<Schema.String>;
+                    readonly readOnlyHint: Schema.optionalKey<Schema.Boolean>;
+                    readonly destructiveHint: Schema.optionalKey<Schema.Boolean>;
+                    readonly idempotentHint: Schema.optionalKey<Schema.Boolean>;
+                    readonly openWorldHint: Schema.optionalKey<Schema.Boolean>;
+                }>>;
+            }>>;
+            readonly routers: Schema.$Array<Schema.Struct<{
+                readonly path: Schema.String;
+                readonly title: Schema.optionalKey<Schema.String>;
+                readonly description: Schema.optionalKey<Schema.String>;
+                readonly icons: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+                    readonly src: Schema.NonEmptyString;
+                    readonly mimeType: Schema.optionalKey<Schema.String>;
+                    readonly sizes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                    readonly theme: Schema.optionalKey<Schema.Literals<readonly ["light", "dark"]>>;
+                }>>>;
+                readonly tags: Schema.optionalKey<Schema.$Record<Schema.NonEmptyString, Schema.String>>;
+                readonly skill: Schema.optionalKey<Schema.NonEmptyString>;
+                readonly error: Schema.optionalKey<Schema.Union<readonly [typeof ProviderError, typeof McpError, typeof SkillLoadFailed, typeof HostDeclarationInvalid, typeof HostEvaluationFailed]>>;
+            }>>;
+        }>;
+        readonly skills: Schema.Union<readonly [Schema.Struct<{
+            readonly skills: Schema.$Array<Schema.Struct<{
+                readonly files: Schema.$Array<Schema.Struct<{
+                    readonly path: Schema.NonEmptyString;
+                    readonly content: Schema.String;
+                }>>;
+                readonly name: Schema.NonEmptyString;
+                readonly description: Schema.String;
+                readonly license: Schema.optionalKey<Schema.String>;
+                readonly compatibility: Schema.optionalKey<Schema.String>;
+                readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                readonly "allowed-tools": Schema.optionalKey<Schema.String>;
+            }>>;
+            readonly dynamic: Schema.Boolean;
+            readonly cached: Schema.optionalKey<Schema.Boolean>;
+        }>, Schema.$Array<Schema.Struct<{
+            readonly files: Schema.$Array<Schema.Struct<{
+                readonly path: Schema.NonEmptyString;
+                readonly content: Schema.String;
+            }>>;
+            readonly name: Schema.NonEmptyString;
+            readonly description: Schema.String;
+            readonly license: Schema.optionalKey<Schema.String>;
+            readonly compatibility: Schema.optionalKey<Schema.String>;
+            readonly metadata: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+            readonly "allowed-tools": Schema.optionalKey<Schema.String>;
+        }>>]>;
+        readonly elicitationRequest: Schema.Struct<{
+            readonly mode: Schema.Literal<"form">;
+            readonly requestedSchema: Schema.toEncoded<Schema.Struct<{
+                readonly $schema: Schema.decodeTo<Schema.toType<Schema.optional<Schema.String>>, Schema.optionalKey<Schema.String>, never, never>;
+                readonly type: Schema.tag<"object">;
+                readonly properties: Schema.$Record<Schema.String, Schema.Union<readonly [Schema.Union<readonly [typeof import("effect/ai/McpSchema").LegacyTitledEnum, Schema.Union<readonly [typeof import("effect/ai/McpSchema").UntitledSingleSelectEnum, typeof import("effect/ai/McpSchema").TitledSingleSelectEnum]>, Schema.Union<readonly [typeof import("effect/ai/McpSchema").UntitledMultiSelectEnum, typeof import("effect/ai/McpSchema").TitledMultiSelectEnum]>]>, typeof import("effect/ai/McpSchema").ElicitationString, typeof import("effect/ai/McpSchema").ElicitationNumber, typeof import("effect/ai/McpSchema").ElicitationBoolean]>>;
+                readonly required: Schema.decodeTo<Schema.toType<Schema.optional<Schema.$Array<Schema.String>>>, Schema.optionalKey<Schema.$Array<Schema.String>>, never, never>;
+            }>>;
+            readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            readonly message: Schema.String;
+        }>;
+        readonly elicitationReply: Schema.Union<readonly [Schema.Struct<{
+            readonly ok: Schema.Literal<true>;
+            readonly response: Schema.Union<readonly [Schema.Struct<{
+                readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                readonly action: Schema.Literal<"accept">;
+                readonly content: Schema.decodeTo<Schema.toType<Schema.optional<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>>, Schema.optionalKey<Schema.$Record<Schema.String, Schema.Union<readonly [Schema.String, Schema.Finite, Schema.Boolean, Schema.$Array<Schema.String>]>>>, never, never>;
+            }>, Schema.Struct<{
+                readonly _meta: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                readonly action: Schema.Literals<readonly ["cancel", "decline"]>;
+            }>]>;
+        }>, Schema.Struct<{
+            readonly ok: Schema.Literal<false>;
+            readonly error: typeof ElicitationFailed;
+        }>]>;
+        readonly workflowStep: Schema.Union<readonly [Schema.Struct<{
+            readonly operation: Schema.Literal<"do">;
+            readonly name: Schema.NonEmptyString;
+            readonly options: Schema.Struct<{
+                readonly retries: Schema.optionalKey<Schema.Struct<{
+                    readonly limit: Schema.Int;
+                    readonly delay: Schema.Union<readonly [Schema.Finite, Schema.NonEmptyString]>;
+                    readonly backoff: Schema.optionalKey<Schema.Literals<readonly ["constant", "linear", "exponential"]>>;
+                }>>;
+                readonly timeout: Schema.optionalKey<Schema.Union<readonly [Schema.Finite, Schema.NonEmptyString]>>;
+            }>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"sleep">;
+            readonly name: Schema.NonEmptyString;
+            readonly duration: Schema.Union<readonly [Schema.Finite, Schema.NonEmptyString]>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"until">;
+            readonly name: Schema.NonEmptyString;
+            readonly timestamp: Schema.Finite;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"context">;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"invoke">;
+            readonly kind: Schema.Literals<readonly ["query", "mutation"]>;
+            readonly name: Schema.NonEmptyString;
+            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly stepId: Schema.NonEmptyString;
+            readonly timeout: Schema.Finite;
+        }>]>;
+        readonly workflowStepReply: Schema.Union<readonly [Schema.Struct<{
+            readonly ok: Schema.Literal<true>;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>, Schema.Struct<{
+            readonly ok: Schema.Literal<false>;
+            readonly error: typeof WorkflowFailure;
+        }>]>;
+        readonly workflowControl: Schema.Union<readonly [Schema.Struct<{
+            readonly operation: Schema.Literal<"start">;
+            readonly workflow: Schema.NonEmptyString;
+            readonly input: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+            readonly key: Schema.optionalKey<Schema.NonEmptyString>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"get">;
+            readonly run: Schema.brand<Schema.NonEmptyString, "wfr">;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"list">;
+            readonly workflow: Schema.optionalKey<Schema.NonEmptyString>;
+            readonly cursor: Schema.optionalKey<Schema.brand<Schema.NonEmptyString, "wfr">>;
+            readonly limit: Schema.optionalKey<Schema.Int>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"terminate">;
+            readonly run: Schema.brand<Schema.NonEmptyString, "wfr">;
+        }>]>;
+        readonly cacheCommand: Schema.Union<readonly [Schema.Struct<{
+            readonly operation: Schema.Literal<"read">;
+            readonly keys: Schema.$Array<Schema.String>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"acquire">;
+            readonly key: Schema.String;
+            readonly refresh: Schema.Boolean;
+            readonly version: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+            readonly reads: Schema.optionalKey<Schema.$Array<Schema.String>>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"claim">;
+            readonly key: Schema.String;
+            readonly version: Schema.NullOr<Schema.String>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"publish">;
+            readonly key: Schema.String;
+            readonly lease: Schema.String;
+            readonly entry: Schema.Struct<{
+                readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                readonly version: Schema.String;
+                readonly freshUntil: Schema.Finite;
+                readonly staleUntil: Schema.Finite;
+            }>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"release">;
+            readonly key: Schema.String;
+            readonly lease: Schema.String;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"renew">;
+            readonly key: Schema.String;
+            readonly lease: Schema.String;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"write">;
+            readonly entries: Schema.$Array<Schema.Struct<{
+                readonly key: Schema.String;
+                readonly entry: Schema.Struct<{
+                    readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+                    readonly version: Schema.String;
+                    readonly freshUntil: Schema.Finite;
+                    readonly staleUntil: Schema.Finite;
+                }>;
+            }>>;
+        }>, Schema.Struct<{
+            readonly operation: Schema.Literal<"invalidate">;
+            readonly key: Schema.String;
+        }>]>;
+        readonly cacheReply: Schema.Union<readonly [Schema.Struct<{
+            readonly ok: Schema.Literal<true>;
+            readonly value: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+        }>, Schema.Struct<{
+            readonly ok: Schema.Literal<false>;
+            readonly error: typeof import("../../../../app-cache/src/index.js").CacheError;
+        }>]>;
+        readonly accountCheck: Schema.Struct<{
+            readonly accountInfo: Schema.optionalKey<Schema.Struct<{
+                readonly externalId: Schema.optionalKey<Schema.String>;
+                readonly displayName: Schema.optionalKey<Schema.String>;
+                readonly username: Schema.optionalKey<Schema.String>;
+                readonly email: Schema.optionalKey<Schema.String>;
+                readonly avatarUrl: Schema.optionalKey<Schema.String>;
+                readonly profileUrl: Schema.optionalKey<Schema.String>;
+            }>>;
+        }>;
+        readonly accounts: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "acc">;
+            readonly provider: Schema.Struct<{
+                readonly name: Schema.NonEmptyString;
+                readonly auth: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+                    readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                    readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                    readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                        readonly in: Schema.Literal<"header">;
+                        readonly name: Schema.String;
+                        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>, Schema.Struct<{
+                            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>]>>;
+                        }>]>>;
+                    }>, Schema.Struct<{
+                        readonly in: Schema.Literal<"query">;
+                        readonly name: Schema.NonEmptyString;
+                        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>, Schema.Struct<{
+                            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>]>>;
+                        }>]>>;
+                    }>]>>>;
+                    readonly type: Schema.Literal<"secrets">;
+                    readonly label: Schema.String;
+                    readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                }>, Schema.Struct<{
+                    readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                    readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                    readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                        readonly in: Schema.Literal<"header">;
+                        readonly name: Schema.String;
+                        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>, Schema.Struct<{
+                            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>]>>;
+                        }>]>>;
+                    }>, Schema.Struct<{
+                        readonly in: Schema.Literal<"query">;
+                        readonly name: Schema.NonEmptyString;
+                        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>, Schema.Struct<{
+                            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>]>>;
+                        }>]>>;
+                    }>]>>>;
+                    readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                    readonly discover: Schema.String;
+                    readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.String>;
+                    readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                    readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+                    readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+                    readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                    readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                        readonly path: Schema.String;
+                    }>>;
+                    readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+                    readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                    readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+                    readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                    readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                    readonly type: Schema.Literal<"oauth2">;
+                }>, Schema.Struct<{
+                    readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                    readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                    readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                        readonly in: Schema.Literal<"header">;
+                        readonly name: Schema.String;
+                        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>, Schema.Struct<{
+                            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>]>>;
+                        }>]>>;
+                    }>, Schema.Struct<{
+                        readonly in: Schema.Literal<"query">;
+                        readonly name: Schema.NonEmptyString;
+                        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>, Schema.Struct<{
+                            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>]>>;
+                        }>]>>;
+                    }>]>>>;
+                    readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                    readonly authorizationUrl: Schema.String;
+                    readonly tokenUrl: Schema.String;
+                    readonly revocationUrl: Schema.optionalKey<Schema.String>;
+                    readonly scopes: Schema.$Array<Schema.String>;
+                    readonly issuer: Schema.optionalKey<Schema.String>;
+                    readonly discover: Schema.optionalKey<Schema.Never>;
+                    readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.Never>;
+                    readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                        readonly path: Schema.String;
+                    }>>;
+                    readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+                    readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                    readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+                    readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                    readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                    readonly type: Schema.Literal<"oauth2">;
+                }>, Schema.Struct<{
+                    readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                    readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                    readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                        readonly in: Schema.Literal<"header">;
+                        readonly name: Schema.String;
+                        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>, Schema.Struct<{
+                            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>]>>;
+                        }>]>>;
+                    }>, Schema.Struct<{
+                        readonly in: Schema.Literal<"query">;
+                        readonly name: Schema.NonEmptyString;
+                        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>, Schema.Struct<{
+                            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>]>>;
+                        }>]>>;
+                    }>]>>>;
+                    readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                    readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+                    readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                    readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                    readonly grant: Schema.Literal<"client_credentials">;
+                    readonly discover: Schema.String;
+                    readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.String>;
+                    readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                    readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+                    readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+                    readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                    readonly type: Schema.Literal<"oauth2">;
+                }>, Schema.Struct<{
+                    readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                    readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                    readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                        readonly in: Schema.Literal<"header">;
+                        readonly name: Schema.String;
+                        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>, Schema.Struct<{
+                            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>]>>;
+                        }>]>>;
+                    }>, Schema.Struct<{
+                        readonly in: Schema.Literal<"query">;
+                        readonly name: Schema.NonEmptyString;
+                        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>, Schema.Struct<{
+                            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>]>>;
+                        }>]>>;
+                    }>]>>>;
+                    readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                    readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+                    readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                    readonly discover: Schema.optionalKey<Schema.Never>;
+                    readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.Never>;
+                    readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                    readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                    readonly grant: Schema.Literal<"client_credentials">;
+                    readonly tokenUrl: Schema.String;
+                    readonly revocationUrl: Schema.optionalKey<Schema.String>;
+                    readonly scopes: Schema.$Array<Schema.String>;
+                    readonly type: Schema.Literal<"oauth2">;
+                }>]>>;
+                readonly hosts: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            }>;
+            readonly method: Schema.NonEmptyString;
+            /**
+             * Changes when the account is reconnected or its credentials replaced, not on renewal. Hosts
+             * send it since credential generations; `apps@0.0.1-beta.0` and `beta.1` ignore it.
+             */
+            readonly generation: Schema.optionalKey<Schema.Int>;
+            readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>, Schema.$Array<Schema.Struct<{
+            readonly id: Schema.brand<Schema.String, "acc">;
+            readonly provider: Schema.Struct<{
+                readonly name: Schema.NonEmptyString;
+                readonly auth: Schema.$Record<Schema.NonEmptyString, Schema.Union<readonly [Schema.Struct<{
+                    readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                    readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                    readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                        readonly in: Schema.Literal<"header">;
+                        readonly name: Schema.String;
+                        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>, Schema.Struct<{
+                            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>]>>;
+                        }>]>>;
+                    }>, Schema.Struct<{
+                        readonly in: Schema.Literal<"query">;
+                        readonly name: Schema.NonEmptyString;
+                        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>, Schema.Struct<{
+                            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>]>>;
+                        }>]>>;
+                    }>]>>>;
+                    readonly type: Schema.Literal<"secrets">;
+                    readonly label: Schema.String;
+                    readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                }>, Schema.Struct<{
+                    readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                    readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                    readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                        readonly in: Schema.Literal<"header">;
+                        readonly name: Schema.String;
+                        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>, Schema.Struct<{
+                            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>]>>;
+                        }>]>>;
+                    }>, Schema.Struct<{
+                        readonly in: Schema.Literal<"query">;
+                        readonly name: Schema.NonEmptyString;
+                        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>, Schema.Struct<{
+                            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>]>>;
+                        }>]>>;
+                    }>]>>>;
+                    readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                    readonly discover: Schema.String;
+                    readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.String>;
+                    readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                    readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+                    readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+                    readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                    readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                        readonly path: Schema.String;
+                    }>>;
+                    readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+                    readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                    readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+                    readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                    readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                    readonly type: Schema.Literal<"oauth2">;
+                }>, Schema.Struct<{
+                    readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                    readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                    readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                        readonly in: Schema.Literal<"header">;
+                        readonly name: Schema.String;
+                        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>, Schema.Struct<{
+                            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>]>>;
+                        }>]>>;
+                    }>, Schema.Struct<{
+                        readonly in: Schema.Literal<"query">;
+                        readonly name: Schema.NonEmptyString;
+                        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>, Schema.Struct<{
+                            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>]>>;
+                        }>]>>;
+                    }>]>>>;
+                    readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                    readonly authorizationUrl: Schema.String;
+                    readonly tokenUrl: Schema.String;
+                    readonly revocationUrl: Schema.optionalKey<Schema.String>;
+                    readonly scopes: Schema.$Array<Schema.String>;
+                    readonly issuer: Schema.optionalKey<Schema.String>;
+                    readonly discover: Schema.optionalKey<Schema.Never>;
+                    readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.Never>;
+                    readonly tokenResponse: Schema.optionalKey<Schema.Struct<{
+                        readonly path: Schema.String;
+                    }>>;
+                    readonly grant: Schema.optionalKey<Schema.Literal<"authorization_code">>;
+                    readonly authorizationParams: Schema.optionalKey<Schema.$Record<Schema.String, Schema.String>>;
+                    readonly tokenEndpointAuthMethod: Schema.optionalKey<Schema.Literals<readonly ["none", "client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>>;
+                    readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                    readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                    readonly type: Schema.Literal<"oauth2">;
+                }>, Schema.Struct<{
+                    readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                    readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                    readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                        readonly in: Schema.Literal<"header">;
+                        readonly name: Schema.String;
+                        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>, Schema.Struct<{
+                            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>]>>;
+                        }>]>>;
+                    }>, Schema.Struct<{
+                        readonly in: Schema.Literal<"query">;
+                        readonly name: Schema.NonEmptyString;
+                        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>, Schema.Struct<{
+                            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>]>>;
+                        }>]>>;
+                    }>]>>>;
+                    readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                    readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+                    readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                    readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                    readonly grant: Schema.Literal<"client_credentials">;
+                    readonly discover: Schema.String;
+                    readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.String>;
+                    readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                    readonly tokenUrl: Schema.optionalKey<Schema.Never>;
+                    readonly revocationUrl: Schema.optionalKey<Schema.Never>;
+                    readonly scopes: Schema.optionalKey<Schema.$Array<Schema.String>>;
+                    readonly type: Schema.Literal<"oauth2">;
+                }>, Schema.Struct<{
+                    readonly plain: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                    readonly raw: Schema.optionalKey<Schema.$Array<Schema.NonEmptyString>>;
+                    readonly request: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                        readonly in: Schema.Literal<"header">;
+                        readonly name: Schema.String;
+                        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>, Schema.Struct<{
+                            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>]>>;
+                        }>]>>;
+                    }>, Schema.Struct<{
+                        readonly in: Schema.Literal<"query">;
+                        readonly name: Schema.NonEmptyString;
+                        readonly value: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                            readonly field: Schema.NonEmptyString;
+                        }>, Schema.Struct<{
+                            readonly base64: Schema.$Array<Schema.Union<readonly [Schema.String, Schema.Struct<{
+                                readonly field: Schema.NonEmptyString;
+                            }>]>>;
+                        }>]>>;
+                    }>]>>>;
+                    readonly response: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                    readonly tokenEndpointAuthMethod: Schema.Literals<readonly ["client_secret_post", "client_secret_basic", "client_secret_basic_raw"]>;
+                    readonly resource: Schema.optionalKey<Schema.NullOr<Schema.String>>;
+                    readonly authorizationUrl: Schema.optionalKey<Schema.Never>;
+                    readonly discover: Schema.optionalKey<Schema.Never>;
+                    readonly authorizationServerMetadataUrl: Schema.optionalKey<Schema.Never>;
+                    readonly scopeSeparator: Schema.optionalKey<Schema.String>;
+                    readonly tokenRequestFormat: Schema.optionalKey<Schema.Literals<readonly ["form", "json"]>>;
+                    readonly grant: Schema.Literal<"client_credentials">;
+                    readonly tokenUrl: Schema.String;
+                    readonly revocationUrl: Schema.optionalKey<Schema.String>;
+                    readonly scopes: Schema.$Array<Schema.String>;
+                    readonly type: Schema.Literal<"oauth2">;
+                }>]>>;
+                readonly hosts: Schema.optionalKey<Schema.$Array<Schema.String>>;
+            }>;
+            readonly method: Schema.NonEmptyString;
+            /**
+             * Changes when the account is reconnected or its credentials replaced, not on renewal. Hosts
+             * send it since credential generations; `apps@0.0.1-beta.0` and `beta.1` ignore it.
+             */
+            readonly generation: Schema.optionalKey<Schema.Int>;
+            readonly fields: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+        }>>]>>;
+        readonly migrate: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.Int;
+            readonly name: Schema.NonEmptyString;
+        }>>;
+    };
+};
+export {};