@relyio/sdk 0.19.0 → 0.20.0

package/dist/index-D1fiaQlK.d.ts

@@ -0,0 +1,2284 @@
+import { cW as paths, cX as RetryConfig, cY as MergedRelyIOConfig, cZ as ApiResponse, ap as components, ar as FileUpload, cS as ConditionScalar, cT as ConditionTest, C as ConditionTree, cU as ConditionTests, s as KeyedMembers, an as FieldValues, ao as DeclaredFields, t as KeyedMembersOf, c_ as ExtensionSurfaces, c$ as ExtensionSettingField, d0 as ExtensionSurface, d1 as ActionField, d2 as ExtensionValueField, z as ReferenceConfig, p as KeyedFieldOptions, o as KeyedField } from './define-content-type-CVLUusfx.js';
+import { SchemaDefinition, SchemaRecordTypeNames, InferRecordType, SchemaContentTypeNames, SchemaEntry, SchemaLocaleCodes, RecordWriteFieldsOf, RecordUpdateFieldsOf } from './schema/index.js';
+
+/**
+ * Where the SDK's transport gets its truth.
+ *
+ * Every route this client calls is named by its **path template as the
+ * committed document spells it**, and the body type it expects is read out of
+ * that document rather than written down here. `api-schema.ts` beside this file
+ * is generated by `pnpm api:types` from `apps/services/api/openapi-spec.json`,
+ * which is itself generated from that service's `RouteContract`s
+ * (`INV-API-DOCUMENT-IS-DERIVED`). So the chain is: one declaration in
+ * `routes.ts` → the serializer that produces the body → the document → these
+ * types → the method that reads it.
+ *
+ * That chain is the answer to the question this phase exists to close. Before
+ * it, six SDK methods read a key the server does not send; each had no caller
+ * and no test, so nothing could see them. Now:
+ *
+ * - A route that changes **kind** — `collection` to `object`, say — changes
+ *   whether the document's 200 body carries `page` and whether `data` is an
+ *   array. `Wire<…>` follows, `readPayload` follows, and the method's declared
+ *   return type stops matching. `tsc` names the method.
+ * - A route that changes **path** or is deleted stops being a `keyof paths`, so
+ *   the call site fails on the literal.
+ * - A route that changes **dialect** changes `page` from `CursorPage` to
+ *   `OffsetPage`, and anything reading `nextCursor` fails.
+ *
+ * `/v1` lives in these templates because it lives in the document
+ * (`INV-API-VERSION-IS-DECIDED-ONCE`). Before this phase the SDK's base URL was
+ * `https://api.relyio.com` and its paths were `/{contentType}`, so every
+ * versioned request went to a path the router does not serve.
+ *
+ * Spec: `devtools/docs/guide/engineering/api-contract-spec.md`,
+ * `INV-API-CLIENT-IS-DERIVED`.
+ */
+
+/** Every path the committed document declares. */
+type ApiPath = keyof paths;
+type Verb = 'get' | 'post' | 'put' | 'patch' | 'delete';
+/** The verbs the document declares on this path — not the seven HTTP has. */
+type ApiMethod<P extends ApiPath> = {
+    [M in Verb]: M extends keyof paths[P] ? paths[P][M] extends {
+        responses: unknown;
+    } ? M : never : never;
+}[Verb];
+type Operation<P extends ApiPath, M extends ApiMethod<P>> = M extends keyof paths[P] ? paths[P][M] : never;
+type JsonBody<R> = R extends {
+    content: {
+        'application/json': infer B;
+    };
+} ? B : never;
+/**
+ * The success body the document declares, preferring 200 where a route serves
+ * both. A route with neither — `kind: 'empty'`, which serves 204 — resolves to
+ * `never`, and `readPayload` cannot be called on it.
+ */
+type ApiSuccessBody<P extends ApiPath, M extends ApiMethod<P>> = Operation<P, M> extends {
+    responses: infer R;
+} ? 200 extends keyof R ? JsonBody<R[200]> : 201 extends keyof R ? JsonBody<R[201]> : never : never;
+/**
+ * The document's success body with the payload typed as the caller's `T`.
+ *
+ * The array arm is tested **first** on purpose: `{ data: unknown[] }` also
+ * satisfies `{ data: unknown }`, so the object arm would swallow every
+ * collection and hand a list route's caller a single entity — which is the
+ * exact defect class (`ContentClient.children` reading `.data.items` from an
+ * object route) that this phase makes unrepresentable.
+ */
+type Wire<P extends ApiPath, M extends ApiMethod<P>, T> = ApiSuccessBody<P, M> extends {
+    data: unknown[];
+} ? Omit<ApiSuccessBody<P, M>, 'data'> & {
+    data: T[];
+} : ApiSuccessBody<P, M> extends {
+    data: unknown;
+} ? Omit<ApiSuccessBody<P, M>, 'data'> & {
+    data: T;
+} : ApiSuccessBody<P, M>;
+/**
+ * The path parameters the document declares for this operation, or `never`
+ * where it declares none.
+ *
+ * `never` rather than `{}`: a route with no segments must **forbid** a `path`
+ * argument, not merely tolerate an empty one, and `keyof Record<string, never>`
+ * is `string`, so an empty-object encoding cannot be told apart from a real
+ * one at the type level.
+ */
+type PathParamsOf<P extends ApiPath, M extends ApiMethod<P>> = Operation<P, M> extends {
+    parameters: {
+        path?: infer X;
+    };
+} ? [X] extends [undefined] ? never : NonNullable<X> : never;
+/**
+ * The query parameters the document declares for this operation, or `never` where it declares
+ * none (REL-687).
+ *
+ * The service declares them beside each route — a query DTO's whitelisted properties, the names a
+ * handler reads, `?_fresh` on a read the edge keeps — and `apps/services/api`'s
+ * `contract/query-parameters.spec.ts` holds the document to what each handler reads. So a name the
+ * API stops reading stops compiling here, and a name it refuses — `offset` on the entry list, which
+ * the SDK once sent on every `.offset()` and the API answered with a 400 — never compiled at all.
+ *
+ * `never` for the same reason {@link PathParamsOf} uses it: a route with no query must forbid one.
+ */
+type QueryOf<P extends ApiPath, M extends ApiMethod<P>> = Operation<P, M> extends {
+    parameters: {
+        query?: infer Q;
+    };
+} ? [Q] extends [undefined] ? never : NonNullable<Q> : never;
+/** What {@link matchRoute} recovers from a URL the client emitted. */
+interface RouteMatch {
+    /** The document's path template — the value a tag translator switches on. */
+    path: ApiPath;
+    /** The template's `{name}` segments, decoded: the inverse of {@link fillPath}. */
+    params: Record<string, string>;
+    /** The query string; a key that appears more than once comes back as an array. */
+    query: Record<string, string | string[]>;
+}
+interface MatchRouteOptions {
+    /**
+     * The client's `baseUrl`, when it carries a path prefix of its own
+     * (`https://example.com/relyio`). Its path is removed before the template is
+     * matched. Unneeded for the default `https://api.relyio.com`.
+     */
+    baseUrl?: string;
+}
+/**
+ * Recover the route a URL names: the inverse of {@link fillPath}, over the same
+ * committed document (`INV-API-CLIENT-IS-DERIVED`).
+ *
+ * `matchRoute(url).path` is an `ApiPath`, so anything that keys behaviour on a
+ * request — a cache-tag translator, say — switches on the document's templates
+ * and never on a route table of its own.
+ *
+ * Returns `null` for a URL no declared template matches — a presigned storage
+ * URL, or a path outside `baseUrl` — rather than a guess.
+ */
+declare function matchRoute(url: string | URL, options?: MatchRouteOptions): RouteMatch | null;
+
+/**
+ * The part of a request a retry decision is allowed to look at.
+ *
+ * `method` is typed as a plain `string` rather than as `RequestConfig['method']`
+ * on purpose. The five verbs that union names are the five the typed transport
+ * can express today; the question "may this be sent twice?" is a fact about
+ * HTTP, and an unrecognised verb has to reach the conservative arm rather than
+ * be unrepresentable.
+ */
+interface RetryableRequest {
+    method: string;
+    headers?: Record<string, string>;
+}
+/**
+ * Whether a failed request may be sent again, and after how long.
+ *
+ * The two halves are separate because they fail separately. The incumbent loop
+ * had neither: it asked `error.retryable` and nothing else, so a `POST` that met
+ * a 500 was sent again twice — and `SERVICE_INDETERMINATE`, whose whole meaning
+ * is "the service could not decide", is marked retryable, which means the write
+ * may already have landed. Meanwhile the `Retry-After` the service sent was
+ * collected by the transport and read by nobody, so a 429 whose window is
+ * measured in minutes was retried after an exponential guess capped at ten
+ * seconds.
+ *
+ * `error` is `Error`, not `SDKError`, because that is what the loop actually
+ * holds: a `TypeError: fetch failed` is only mapped to an `SDKError` **after**
+ * the loop gives up, so a policy typed to `SDKError` could not see the transport
+ * failures it most needs to retry.
+ */
+interface RetryPolicy {
+    /**
+     * Never replays a request that could apply twice: a write is retried only
+     * when it carries `Idempotency-Key`, or the verb is idempotent.
+     *
+     * @param attempt - How many attempts have been made, 1 for the first.
+     */
+    shouldRetry(attempt: number, error: Error, request: RetryableRequest): boolean;
+    /** Honours `Retry-After` / `RateLimitError.resetAt` over exponential backoff. */
+    delayFor(attempt: number, error: Error): number;
+}
+/**
+ * Whether sending this request a second time can apply it a second time.
+ *
+ * Two ways to be safe, and they are genuinely different questions: the verb may
+ * be idempotent by definition, or the request may carry an `Idempotency-Key`
+ * that makes the service answer a replay from the original outcome rather than
+ * applying it again.
+ */
+declare function isReplaySafe(request: RetryableRequest): boolean;
+/**
+ * The policy the SDK ships with.
+ *
+ * Construction takes the same `RetryConfig` the SDK has always exported; what
+ * it no longer takes is a `retryCondition`, because a caller-supplied predicate
+ * over `(error, attempt)` structurally **cannot** see the request and so cannot
+ * express the rule this class exists for.
+ */
+declare class DefaultRetryPolicy implements RetryPolicy {
+    private readonly config;
+    constructor(config: RetryConfig);
+    shouldRetry(attempt: number, error: Error, request: RetryableRequest): boolean;
+    delayFor(attempt: number, error: Error): number;
+}
+/**
+ * The retry policy a client sends with, at `maxAttempts` attempts (the first included): the SDK's
+ * own, from `retryAttempts`, and the CLI's (REL-721).
+ *
+ * The backoff numbers are stated here once. The CLI ran a second policy beside this one —
+ * `axios-retry` with its own delays and its own reading of a refusal, which retried by numeric
+ * status — so a refusal one client gave up on, the other sent again. Now both ask this function, and
+ * a change to when a request is replayed reaches both.
+ */
+declare function retryPolicyFor(maxAttempts: number): RetryPolicy;
+
+/**
+ * What a call site supplies beside the route it named.
+ *
+ * `path` is required exactly when the document's template has segments, and
+ * forbidden when it does not — so a call that forgot to scope a request, or one
+ * that scoped a request the route does not scope, is a compile error rather
+ * than a URL with a literal `{id}` in it.
+ */
+type SendOptions<P extends ApiPath, M extends ApiMethod<P>> = {
+    /**
+     * Query string values: exactly the names the document declares for this route, at the types it
+     * declares them (`QueryOf`, REL-687). An undeclared name is a compile error, not a 400.
+     */
+    query?: QueryOf<P, M>;
+    body?: unknown;
+    /** Request headers this call adds, e.g. `If-Match` / `Idempotency-Key` (API4). */
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+    timeout?: number;
+} & ([PathParamsOf<P, M>] extends [never] ? {
+    path?: never;
+} : {
+    path: PathParamsOf<P, M>;
+});
+/**
+ * Core HTTP client for the RelyIO SDK.
+ *
+ * `send` is **the** typed entry: it names a route by the path template the
+ * committed document declares, and returns that operation's body type with the
+ * payload typed as `T`. `readPayload` from `@relyio/api-contract/client` is
+ * then the one unwrap — there is no second spelling and no runtime test of
+ * which envelope arrived (`INV-API-CLIENT-IS-DERIVED`).
+ *
+ * What the class makes public is what something outside it calls: `send` and `fetchPayload` are
+ * the requests; `configure`, `withHeaders` and `setApiKey` are the owning client's (`updateConfig()`,
+ * `with()`, `setApiKey()`). There are no verb helpers, no header or base-URL accessors and no
+ * untyped `request` (REL-717): a route is named by its document path, or it is not called.
+ */
+declare class HttpClient {
+    /** What every request reads off the configuration, derived by {@link configure} and nowhere else. */
+    protected connection: Connection;
+    /**
+     * Set on a view {@link withHeaders} made: the client every request is sent through, and the
+     * headers laid beneath each request's own. A view keeps no connection of its own that matters —
+     * everything it is asked to change, it changes on that client.
+     */
+    protected view?: {
+        readonly client: ControlledHttpClient;
+        readonly headers: Readonly<Record<string, string>>;
+        /** The End user's token function this view asks in place of its client's, when it names one. */
+        readonly getToken?: EndUserTokenSource;
+    };
+    constructor(config: MergedRelyIOConfig);
+    protected announce(): void;
+    /**
+     * Send bytes to an address that is not a RelyIO route — an asset upload's presigned `PUT` and its
+     * multipart parts — through the client's configured `fetch`, so a wrapper that records, proxies or
+     * forbids network access sees every request this client makes (REL-2671). Nothing else is added: no
+     * key, no retry, no timeout, because the address belongs to the storage service, not to RelyIO.
+     *
+     * Static so the instances a customer holds stay `send` and `fetchPayload` (REL-3107). The `fetch`
+     * is read per call, from the client a view sends through, like the requests are.
+     */
+    static transfer(client: HttpClient, url: string, init: RequestInit): Promise<Response>;
+    /**
+     * Call a route the committed document declares, and get back the body that
+     * document says it serves.
+     */
+    send<P extends ApiPath, M extends ApiMethod<P>, T = unknown>(path: P, method: M, options: SendOptions<P, M>): Promise<ApiResponse<Wire<P, M, T>>>;
+    /**
+     * Call a route and return its payload — `send` plus the one unwrap, which is
+     * what all but a handful of call sites want.
+     */
+    fetchPayload<P extends ApiPath, M extends ApiMethod<P>, T = unknown>(path: P, method: M, options: SendOptions<P, M>): Promise<Wire<P, M, T> extends {
+        data: unknown;
+    } ? Wire<P, M, T>['data'] : never>;
+    /**
+     * Make an HTTP request, retrying only where a retry is safe.
+     *
+     * The headers are merged **once**, before the first attempt, and every attempt
+     * sends that same object. That is what makes a minted `Idempotency-Key` stable
+     * across the retries of one logical write: the service sees one key and
+     * answers the replay from the original outcome instead of applying it twice.
+     *
+     * The loop always makes one attempt. The incumbent's `while (attempt <
+     * maxAttempts)` made none at `retryAttempts: 0` — a value the config validator
+     * then accepted, and now refuses — and then dereferenced an unassigned
+     * `lastError`. `retryAttempts` is the most attempts, the first included; an
+     * `HttpClient` constructed directly is not validated, so the first attempt
+     * stays unconditional.
+     *
+     * A request that would carry no `X-API-Key` makes none: it rejects with
+     * `MissingApiKeyError` before `fetch` is called, is not retried, and names
+     * `apiKey`. This is where a client built without a key learns it — the
+     * constructor accepts one so that a module-scope client can be evaluated by a
+     * build that holds no key (REL-1120) — and so does one whose `setApiKey` was
+     * given none.
+     *
+     * The End user's token is asked for once, after the key is known to be there and before the first
+     * attempt — of `getToken`, the nearest view's function, or the configuration's — so every retry
+     * of one call sends the token its first attempt sent. See `RelyIOConfig.getToken`.
+     */
+    private request;
+    /**
+     * One attempt.
+     *
+     * The caller's `signal` and the timeout both end it, through one controller.
+     * The incumbent handed `fetch` the caller's signal **instead of** its own, so a
+     * request that passed a signal had no timeout at all — and a caller abort then
+     * surfaced as `Request timed out`. `timedOut` is what tells the two apart: a
+     * timeout is a `TimeoutError`, a caller abort is the platform's `AbortError`,
+     * rethrown as it came.
+     */
+    private makeRequest;
+    /**
+     * The headers without those a browser controls itself, when this is a browser; unchanged when it
+     * is not.
+     *
+     * A name is matched without regard to case (RFC 9110 §5.1), because a browser refuses `Origin`
+     * whatever case a page spells it in. This matched only the all-lowercase and all-uppercase
+     * spellings, so `Origin` and `User-Agent` — how people write them — reached `fetch` (REL-1409).
+     */
+    private filterHeadersForBrowser;
+    /**
+     * Prepare request body based on content type and environment
+     */
+    private prepareRequestBody;
+    private parseResponse;
+    private resolveUrl;
+    private mergeRequestConfig;
+    private buildQueryString;
+    private headersToObject;
+    private log;
+}
+/**
+ * The client the SDK's own factory holds: {@link HttpClient} plus the three things only the owning
+ * client does to it — `configure` (`updateConfig()`), `withHeaders` (`with()`) and `setApiKey`
+ * (`setApiKey()`). It is not exported from the package, so a customer holding the client from
+ * `getHttpClient()` sees `send` and `fetchPayload` and nothing else (REL-3107).
+ */
+declare class ControlledHttpClient extends HttpClient {
+    /**
+     * A view of this client that sends every request through it with `headers` added — beneath the
+     * request's own, over this client's — and changes nothing else: its key, base URL, timeout,
+     * retries and `fetch` are this client's as they are when each request is sent, so a later
+     * `configure()` or `setApiKey()` on this client reaches the view, and one on the view reaches
+     * this client. `client.with({ dataset })` is one (REL-2417).
+     *
+     * `options.getToken` is the End user's token function the view asks in place of this client's,
+     * and of any view it is made from: `client.with({ getToken })` (REL-3882).
+     */
+    withHeaders(headers: Readonly<Record<string, string>>, options?: {
+        readonly getToken?: EndUserTokenSource;
+    }): ControlledHttpClient;
+    /**
+     * Run on `config` from now on: every later request — whoever holds this client — is sent to its
+     * `baseUrl`, with its headers, key and dataset, its timeout and retries, through its `fetch`, and
+     * logged by its `debug` options.
+     *
+     * The client's own `updateConfig()` calls this rather than building a second client, so a
+     * `content()` or other sub-client taken before the update sends through the update too. Anything
+     * set on this client since it was last configured — `setApiKey()` — is replaced by what `config`
+     * says.
+     */
+    configure(config: MergedRelyIOConfig): void;
+    /**
+     * Replace the key every later request sends as `X-API-Key`, and the `apiKey` the configuration
+     * reports.
+     *
+     * The key is read the way construction reads it (`presentCredential`): an absent, empty or blank key is
+     * no key, so the header is dropped and the next request is refused with `MissingApiKeyError`
+     * before anything is sent. A key header of any other spelling — one given in `headers` — goes
+     * too, from the headers sent and from the headers the configuration reports, so the old key is
+     * never sent beside the new one.
+     *
+     * The configuration is the one the owning `TypedRelyIOClient` holds (it hands its own to the
+     * constructor), so its `getConfig().apiKey` — what a surface reads to decide a key's kind — is the
+     * key sent from here on.
+     *
+     * This replaced `setAuthToken`, which added `Authorization: Bearer` beside an `X-API-Key` it
+     * never touched: the API reads `X-API-Key` first, so the old key was the one used (REL-1385).
+     */
+    setApiKey(apiKey: string): void;
+}
+/** What `getToken` is: asked per call, answering the signed-in End user's token or `null`. */
+type EndUserTokenSource = NonNullable<MergedRelyIOConfig['getToken']>;
+/** Everything a request reads off the configuration, replaced whole whenever it changes. */
+interface Connection {
+    /**
+     * The configuration itself, for what is read per request — `fetch`, the `browser` options,
+     * `debug` — and the object `setApiKey` writes the key into, which the owning client reports.
+     */
+    readonly config: MergedRelyIOConfig;
+    readonly baseUrl: string;
+    readonly defaultHeaders: Readonly<Record<string, string>>;
+    readonly timeout: number;
+    readonly retryPolicy: RetryPolicy;
+}
+
+/**
+ * Any schema the client can be typed by. `any` is deliberate: the client accepts whatever content
+ * types, singletons, queries and settings groups a customer declares.
+ *
+ * This is the constraint `TypedRelyIOClient`'s `TSchema` carries, so `RegisteredSchema` is inferred
+ * against the same one — `createClient` returns `TypedRelyIOClient<RegisteredSchema>`, and a schema
+ * inferred against any wider alias would not be provably inside the client's bound.
+ */
+type AnySchemaDefinition = SchemaDefinition<any, any, any, any, any>;
+/**
+ * The seam `relyio generate-types` fills (`INV-SS-TYPES-INFERRED`).
+ *
+ * Empty here on purpose. The generated `schema.ts` augments it —
+ *
+ * ```ts
+ * declare module '@relyio/sdk' {
+ *   interface Register {
+ *     schema: typeof schema
+ *   }
+ * }
+ * ```
+ *
+ * — and from then on `createClient({ apiKey })`, with no generic and no `schema:`, is typed by that
+ * schema. The pattern is TanStack Router's. It is type-level only: nothing at runtime reads it.
+ */
+interface Register {
+}
+/**
+ * The schema the project registered through `Register`, or `undefined` when nothing did — which is
+ * the untyped client, exactly as before the generator ran.
+ */
+type RegisteredSchema = Register extends {
+    schema: infer S extends AnySchemaDefinition;
+} ? S : undefined;
+
+/**
+ * One Record type's Records over the Content API (spec 1, REL-3771): `relyio.records('order')`.
+ *
+ * A Record is an app's data — an order, a stock level, a cart — written by your server with a
+ * secret key and live the moment it lands: no draft, no publication, no locale, no version. A
+ * publishable key lists and gets the Records a Record type's read Policy grants it — anonymously, or
+ * as the End user whose token it carries (spec 4, REL-3883) — and creates, updates and deletes them
+ * only as that End user, as the type's write Policy allows (REL-3884): RelyIO sets the owner from
+ * the token. With no token it writes nothing (`PUBLISHABLE_KEY_REFUSED`).
+ *
+ * Every body is read from the committed document (`INV-API-CLIENT-IS-DERIVED`): the paths are the
+ * document's, and `RecordMetadata` is its schema by name.
+ */
+
+/** What the API reports about a Record beside its fields. */
+type RecordMetadata = components['schemas']['RecordMetadata'];
+/** A Record as a read answers it: its fields at the top level, and `_metadata`. */
+type BaseRecord = Record<string, unknown> & {
+    _metadata: RecordMetadata;
+};
+/** What a Record read and write take beside their own options. */
+interface RecordCallOptions {
+    /** The dataset, by id or name, over the client's. */
+    dataset?: string;
+    signal?: AbortSignal;
+}
+/**
+ * What a Record read may expand (REL-3772): include paths, in the grammar `content().get` takes —
+ * `lines.product`, `convertedTo.lines.product(title)`. A reference to an entry expands into the
+ * entry as this key reads it — published with a secret key, its draft with a preview key — and one
+ * to a Record into the Record. A reference to an entry the key cannot see, or that is gone, reads
+ * as `null` — unless it is a pinned reference (`pin: 'version'`), which reads the entry as it was
+ * at the version the Record pinned, whatever it has done since, its `_metadata.pin` naming that
+ * version and the one the key reads now (REL-3776).
+ */
+interface RecordReadOptions extends RecordCallOptions {
+    include?: readonly string[];
+    /**
+     * The locale each included entry is composed in, with its schema's fallback; the schema's
+     * default when absent. A Record has no locale of its own (REL-3776).
+     */
+    locale?: string;
+}
+/** What an update takes: the revision the change was made on. */
+interface RecordUpdateOptions extends RecordCallOptions {
+    /**
+     * `_metadata.revision` of the read the change was made on. A Record written since is refused
+     * with `ResourceConflictError`, its `blockage` (`revision-stale`) naming the fields that changed,
+     * and nothing is written.
+     */
+    revision: number;
+}
+/** A list's options: one page of the Records `where` keeps, in one order. */
+interface RecordListOptions<TFields> extends RecordReadOptions {
+    /** Field conditions, in the grammar `content().list({ where })` takes. */
+    where?: {
+        [K in keyof TFields]?: unknown;
+    } & Record<string, unknown>;
+    /** One key: `createdAt`, `updatedAt`, `id` or a field holding one value. Default `createdAt:desc`. */
+    sort?: `${'createdAt' | 'updatedAt' | 'id' | (keyof TFields & string)}:${'asc' | 'desc'}`;
+    limit?: number;
+    cursor?: string;
+    /** Answer `meta.count`: how many Records `where` keeps across every page. */
+    count?: boolean;
+    /** Count the values of each of these fields among the Records `where` keeps, under `meta.facets`. */
+    facets?: ReadonlyArray<keyof TFields & string>;
+}
+/** What an upload of a Record's File takes beside its bytes (REL-3824). */
+interface RecordFileUploadOptions extends RecordCallOptions {
+    /** The File's name, as a read will answer it. */
+    name: string;
+    /** Its media type: one the field's `accept` admits. */
+    type: string;
+}
+/** The bytes of a File: what `fetch` sends as a body, of a length known before it is sent. */
+type RecordFileBytes = Blob | ArrayBuffer | Uint8Array;
+/** One facet's buckets: each value and how many Records hold it, most frequent first. */
+interface RecordFacetBucket {
+    readonly value: unknown;
+    readonly count: number;
+}
+/** One page of a Record list, as the API answers it. */
+interface RecordList<T> {
+    data: T[];
+    page: {
+        nextCursor: string | null;
+        hasMore: boolean;
+    };
+    meta: {
+        count?: number;
+        facets?: Record<string, RecordFacetBucket[]>;
+    };
+}
+/**
+ * One Record type's Records.
+ *
+ * @example
+ * ```typescript
+ * const orders = relyio.records('order')
+ * const order = await orders.create({ shopperEmail: 'ada@example.com', status: 'paid', total: 19 })
+ * const { data: paid, meta } = await orders.list({
+ *   where: { status: 'paid' },
+ *   sort: 'createdAt:asc',
+ *   count: true,
+ * })
+ * ```
+ */
+declare class RecordsClient<TRecord extends BaseRecord = BaseRecord, TInput = Record<string, unknown>, 
+/** What an update takes: the create's values without the type's Counters (REL-3765). */
+TUpdate = TInput> {
+    private readonly httpClient;
+    readonly recordType: string;
+    constructor(httpClient: HttpClient, recordType: string);
+    /**
+     * Store a Record, live the moment it lands. Values that break the Record type's fields are
+     * refused with `ValidationError` naming each field, and nothing is stored. Values a unique set of
+     * the type claims, held by another Record, are refused with `ResourceConflictError` — its
+     * `blockage` is `{ kind: 'value-taken', facts: { fields, recordId } }` (REL-3782) — with no
+     * `recordId` for an End user's write, whose read Policy may hide the holder (REL-3863).
+     */
+    create(fields: TInput, options?: RecordCallOptions): Promise<TRecord>;
+    /** One page of the Records `where` keeps, newest first unless `sort` names one key. */
+    list(options?: RecordListOptions<Omit<TRecord, '_metadata'>>): Promise<RecordList<TRecord>>;
+    /**
+     * Upload a File for one of this Record type's file fields (REL-3824), and answer what a create or
+     * update sets the field to. The bytes go straight to object storage at the address the upload
+     * names, never through RelyIO; a File outside the field's `accept` or over its `maxSize` is
+     * refused with `ValidationError` naming the field before any byte is sent. An upload no write
+     * names within a day is deleted with its bytes. Server-side only, as every Record call is.
+     *
+     * @example
+     * ```typescript
+     * const invoice = await relyio.records('order').upload('invoice', pdfBytes, {
+     *   name: 'invoice-1001.pdf',
+     *   type: 'application/pdf',
+     * })
+     * await relyio.records('order').update(id, { invoice }, { revision })
+     * ```
+     */
+    upload(field: string, bytes: RecordFileBytes, options: RecordFileUploadOptions): Promise<FileUpload>;
+    /**
+     * One Record by its id, or `null` when none is stored. A Record type nobody deployed throws
+     * `ResourceNotFoundError` naming it, so it never reads as a missing Record.
+     */
+    get(id: string, options?: RecordReadOptions): Promise<TRecord | null>;
+    /**
+     * Change the fields named, against the revision the change was made on, and answer the Record at
+     * its next revision. A field given `null` is removed; one not named keeps its value. A Record
+     * written since `revision` is refused with `ResourceConflictError` — its `blockage` is
+     * `{ kind: 'revision-stale', facts: { changedFields } }` — and nothing is written. Values that
+     * break the Record type are refused with `ValidationError` naming each field, and values another
+     * Record holds under a unique set with `ResourceConflictError`, its blockage `value-taken`.
+     *
+     * @example
+     * ```typescript
+     * const order = await relyio.records('order').get(id)
+     * await relyio.records('order').update(id, { status: 'shipped' }, {
+     *   revision: order._metadata.revision,
+     * })
+     * ```
+     */
+    update(id: string, fields: {
+        [K in keyof TUpdate]?: TUpdate[K] | null;
+    }, options: RecordUpdateOptions): Promise<TRecord>;
+    /**
+     * Remove a Record. Another Record holding it through a reference declared to block its delete —
+     * the default — is refused with `ResourceConflictError`, its `blockage`
+     * (`{ kind: 'referenced', facts: { referrers } }`) naming each; one declared `nullify` is cleared.
+     */
+    delete(id: string, options?: RecordCallOptions): Promise<void>;
+}
+
+/**
+ * `@relyio/sdk/automations` — an Automation, declared (spec 3, REL-3845; ADR 0021).
+ *
+ * One file per Automation at `relyio/automations/<name>.ts`, default-exporting what
+ * {@link defineAutomation} returns; the file's name is the Automation's. An Automation is a trigger
+ * and a sequence of steps, and all of it is data: `steps` is called **once**, when the Manifest
+ * loads, with typed references to the event and to earlier steps' outputs, and returns plain data.
+ * No code of yours runs when an event arrives, except inside a Function step.
+ *
+ * @example
+ * // relyio/automations/order-paid.ts
+ * import { defineAutomation, fields, or, records, tpl } from '@relyio/sdk/automations'
+ * import reserveStock from '../functions/reserve-stock'
+ *
+ * export default defineAutomation({
+ *   on: records.order.updated({ where: { status: { becomes: 'paid' } } }),
+ *   steps: ({ event, step }) => {
+ *     const reserve = step.fn('reserve', reserveStock, { orderId: event.record._metadata.id })
+ *     const fraud = step.agent('fraud', {
+ *       instructions: tpl`Read order ${event.record.number} and the customer's past orders`,
+ *       context: { order: event.record },
+ *       output: { verdict: fields.enum({ options: { 'looks fine': 'Looks fine', 'needs review': 'Needs review' } }) },
+ *     })
+ *     return [reserve, fraud, step.if('ship', fraud.output.verdict.eq('looks fine'), { then: […] })]
+ *   },
+ * })
+ *
+ * **Typed.** Once `relyio generate-types` has registered the schema (`Register`), `records.<type>`
+ * takes only the Record types it declares and `event.record` is typed by its fields. A Function
+ * step takes the Function by import, so its input is checked against the Function's input Fields and
+ * its `output` has exactly the Function's output Fields: a misspelt one is a type error, and so is a
+ * step reading one declared after it. The plan refuses both again, for a Manifest read as data.
+ *
+ * **Conditions** are the list grammar's operators (`eq`, `ne`, `in`, `gt`, `exists`, …) on a
+ * reference, combined with {@link and}, {@link or} and {@link not}. `becomes` — changed in this
+ * write and now equal — is a trigger's `where` alone.
+ *
+ * **Extensions** (REL-3846): `relyio/extensions.ts` declares the Extensions the Project uses with
+ * `defineExtensions` (`@relyio/sdk/extensions`), and hands out a typed handle for each. An Automation
+ * imports it: `on: stripe.paymentIntentSucceeded()` starts on one of its Triggers, and
+ * `step.action('email', resend.send, { … })` sends through one of its Actions — input and output
+ * typed by the Extension. Using an Extension the file does not declare is refused by the plan.
+ */
+
+/** What a Record event says happened to one Record. */
+type AutomationRecordAction = 'created' | 'updated' | 'deleted' | 'expired';
+/** What an entry event says happened to one entry. */
+type AutomationEntryAction = 'created' | 'updated' | 'published' | 'unpublished' | 'deleted' | 'archived' | 'restored';
+/** A `becomes` test: changed in this write and now equal. A trigger's `where` alone holds one. */
+interface AutomationBecomesTest {
+    readonly root: 'event';
+    readonly path: readonly string[];
+    readonly operator: 'becomes';
+    readonly value: ConditionScalar;
+}
+/** A trigger's `where`: a condition over `event`, whose tests may also be `becomes`. */
+type AutomationWhere = ConditionTest | AutomationBecomesTest | {
+    readonly and: readonly AutomationWhere[];
+} | {
+    readonly or: readonly AutomationWhere[];
+} | {
+    readonly not: AutomationWhere;
+};
+/** An Automation's trigger, as data. */
+type AutomationTrigger = {
+    readonly kind: 'record';
+    readonly recordType: string;
+    readonly action: AutomationRecordAction;
+    readonly where?: AutomationWhere;
+} | {
+    readonly kind: 'entry';
+    readonly contentType: string;
+    readonly action: AutomationEntryAction;
+    readonly where?: AutomationWhere;
+}
+/**
+ * An entry of any content type: `where` is a plain condition over {@link AnyEntryEvent} — the
+ * entry's uid and content type, and what changed — with no `becomes`.
+ */
+ | {
+    readonly kind: 'anyEntry';
+    readonly action: AutomationEntryAction;
+    readonly where?: ConditionTree;
+} | {
+    readonly kind: 'schedule';
+    readonly cron: string;
+    readonly timezone: string;
+}
+/** Another Automation's run failed; `where` is a plain condition over {@link RunFailedEvent}. */
+ | {
+    readonly kind: 'runFailed';
+    readonly where?: ConditionTree;
+}
+/**
+ * One of an Extension's Triggers: `trigger` is its slug in the Extension catalog. `where` is a plain
+ * condition over {@link ExtensionTriggerEvent}.
+ */
+ | {
+    readonly kind: 'extension';
+    readonly extension: string;
+    readonly trigger: string;
+    readonly where?: ConditionTree;
+};
+/** A JSON value, as a step's input holds it literally. */
+type AutomationJson = string | number | boolean | null | readonly AutomationJson[] | {
+    readonly [key: string]: AutomationJson;
+};
+/** A reference: the value at `path` under `root` — `event`, or an earlier step's name. */
+interface AutomationRef {
+    readonly kind: 'ref';
+    readonly root: string;
+    readonly path: readonly string[];
+}
+/** A value a step is handed, as data. */
+type AutomationValue = {
+    readonly kind: 'literal';
+    readonly value: AutomationJson;
+} | AutomationRef | {
+    readonly kind: 'template';
+    readonly parts: ReadonlyArray<string | AutomationRef>;
+} | {
+    readonly kind: 'list';
+    readonly items: readonly AutomationValue[];
+} | {
+    readonly kind: 'object';
+    readonly fields: Readonly<Record<string, AutomationValue>>;
+};
+/** A step's input, by key. */
+type AutomationInput = Readonly<Record<string, AutomationValue>>;
+/** A Wait's length: whole minutes, hours or days, at most 30 days. */
+type AutomationDuration = `${number}m` | `${number}h` | `${number}d`;
+/** One Record or entry by its uid: what a Look-up reads. */
+type AutomationItemRef = {
+    readonly kind: 'record';
+    readonly recordType: string;
+    readonly uid: AutomationValue;
+} | {
+    readonly kind: 'entry';
+    readonly contentType: string;
+    readonly uid: AutomationValue;
+};
+/** Which of an entry's states a Look-up reads: what readers see, or the editor's view. */
+type AutomationLookupState = 'published' | 'draft';
+/** A type an Agent step may propose a change to: a content type's entries, or a Record type's. */
+type AutomationProposeTarget = {
+    readonly kind: 'entry';
+    readonly contentType: string;
+} | {
+    readonly kind: 'record';
+    readonly recordType: string;
+};
+/** One Automation step, as data. */
+type AutomationStep = {
+    readonly kind: 'function';
+    readonly name: string;
+    readonly function: string;
+    readonly input: AutomationInput;
+} | {
+    readonly kind: 'agent';
+    readonly name: string;
+    readonly agent?: string;
+    readonly instructions: AutomationValue;
+    readonly context: AutomationInput;
+    readonly output: readonly object[];
+    readonly propose?: readonly AutomationProposeTarget[];
+} | {
+    readonly kind: 'action';
+    readonly name: string;
+    readonly extension: string;
+    readonly action: string;
+    readonly input: AutomationInput;
+} | {
+    readonly kind: 'lookup';
+    readonly name: string;
+    readonly item: Extract<AutomationItemRef, {
+        readonly kind: 'record';
+    }>;
+} | {
+    readonly kind: 'lookup';
+    readonly name: string;
+    readonly item: Extract<AutomationItemRef, {
+        readonly kind: 'entry';
+    }>;
+    readonly state: AutomationLookupState;
+} | {
+    readonly kind: 'if';
+    readonly name: string;
+    readonly condition: ConditionTree;
+    readonly then: readonly AutomationStep[];
+    readonly else: readonly AutomationStep[];
+} | {
+    readonly kind: 'wait';
+    readonly name: string;
+    readonly duration: AutomationDuration;
+} | {
+    readonly kind: 'ask';
+    readonly name: string;
+    readonly to: readonly string[];
+    readonly question: AutomationValue;
+    readonly choices: readonly string[];
+    readonly timeout: AutomationDuration;
+    readonly onTimeout?: string;
+    readonly sample?: string;
+    readonly approve?: AutomationRef;
+};
+/** What an Automation declares, as data: what the Manifest carries for one file. */
+interface AutomationDefinition {
+    readonly description?: string;
+    readonly on: AutomationTrigger;
+    /** What each run is about: one Record or entry (REL-3853). */
+    readonly about?: AutomationItemRef;
+    readonly steps: readonly AutomationStep[];
+}
+/** Where a reference's value type rides, for the compiler alone. */
+declare const REF_VALUE: unique symbol;
+/** A list is compared by its members, as a condition compares a list. */
+type MemberOf<T> = T extends ReadonlyArray<infer Member> ? Member : T;
+/** The values a path holding `T` is compared with. */
+type ComparedWith<T> = unknown extends T ? ConditionScalar : MemberOf<NonNullable<T>> extends infer Member ? Member extends ConditionScalar ? Member : never : never;
+/** `becomes`, offered on a trigger's `where` alone. */
+interface BecomesTest<T> {
+    /** Changed in this write, and now equal to `value`. */
+    becomes(value: ComparedWith<T>): AutomationBecomesTest;
+}
+/**
+ * The paths under a reference to `T`. Where its shape is not known — no schema registered — a
+ * reference is `any`: an index signature would read every step as possibly undefined under
+ * `noUncheckedIndexedAccess`, and a typed project registers its schema.
+ */
+type RefChildren<T, B extends boolean> = unknown extends T ? any : NonNullable<T> extends readonly unknown[] ? unknown : NonNullable<T> extends object ? {
+    readonly [K in keyof NonNullable<T> & string]-?: Ref<NonNullable<T>[K], B>;
+} : unknown;
+/**
+ * A reference to a value of type `T` when the step runs: hand it to a step's input, interpolate it
+ * with {@link tpl}, or test it (`.eq(…)`, `.in([…])`, `.exists()`) for a condition. A field named like
+ * a test (`eq`, `in`) is not reachable as a path. `B`: whether `becomes` is offered (a `where`).
+ */
+type Ref<T, B extends boolean = false> = {
+    readonly [REF_VALUE]: T;
+} & ConditionTests<T> & (B extends true ? BecomesTest<T> : unknown) & RefChildren<T, B>;
+/** A reference whose value is a `T`: what a step's input takes where it takes a `T`. */
+type RefTo<T> = {
+    readonly [REF_VALUE]: T;
+};
+/** Where a template's parts ride at run time. */
+declare const TEMPLATE: unique symbol;
+/** Text written with {@link tpl}: literal parts and references, rendered when the step runs. */
+interface AutomationTemplate {
+    readonly [TEMPLATE]: ReadonlyArray<string | AutomationRef>;
+}
+/** What a step's input takes where its Field takes a `T`. */
+type Accepts<T> = T | RefTo<T> | (string extends NonNullable<T> ? AutomationTemplate : never) | AcceptsWithin<NonNullable<T>>;
+/**
+ * A list or object a step's input takes, references at any depth. Distributed over each member of
+ * `T`, so a union — `AutomationJson`, a webhook's body — takes a list or an object holding
+ * references, as one member alone does.
+ */
+type AcceptsWithin<T> = T extends ReadonlyArray<infer Member> ? ReadonlyArray<Accepts<Member>> : T extends object ? {
+    readonly [K in keyof T]: Accepts<T[K]>;
+} : never;
+/** A step's input: each key as its Field types it, a value or a reference to one. */
+type StepInput<V> = {
+    readonly [K in keyof V]: Accepts<V[K]>;
+};
+/**
+ * Text with references in it, rendered when the step runs.
+ *
+ * @example
+ * tpl`Order ${event.record.number} held: ${fraud.output.reason}`
+ */
+declare function tpl(strings: TemplateStringsArray, ...values: ReadonlyArray<RefTo<unknown> | ConditionScalar>): AutomationTemplate;
+/** Every test holds. */
+declare function and(...conditions: readonly ConditionTree[]): ConditionTree;
+declare function and(...conditions: readonly AutomationWhere[]): AutomationWhere;
+/** Some test holds. */
+declare function or(...conditions: readonly ConditionTree[]): ConditionTree;
+declare function or(...conditions: readonly AutomationWhere[]): AutomationWhere;
+/** The test does not hold. */
+declare function not(condition: ConditionTree): ConditionTree;
+declare function not(condition: AutomationWhere): AutomationWhere;
+/** Where a trigger's event type rides, for the compiler alone. */
+declare const EVENT_TYPE: unique symbol;
+/** A trigger, as `on` takes it: its data, and the type of the event it hands `steps`. */
+interface AutomationTriggerHandle<E> {
+    readonly trigger: AutomationTrigger;
+    readonly [EVENT_TYPE]?: E;
+}
+/** The Record type names a schema declares, or any name without one. */
+type RecordTypeNameIn$1<S> = S extends AnySchemaDefinition ? SchemaRecordTypeNames<S> : string;
+type ContentTypeNameIn<S> = S extends AnySchemaDefinition ? SchemaContentTypeNames<S> : string;
+/** An entry's values, of one content type, typed by the registered schema when there is one. */
+type EntryValuesIn<S, K> = S extends AnySchemaDefinition ? Omit<SchemaEntry<S, K & SchemaContentTypeNames<S>>, '_metadata'> : Record<string, unknown>;
+/** A Record of one Record type, typed by the registered schema when there is one. */
+type RecordIn$1<S, K> = S extends AnySchemaDefinition ? InferRecordType<NonNullable<S['recordTypes']>[K & keyof NonNullable<S['recordTypes']>]> : BaseRecord;
+/** A Record event: the Record as the write left it, and the names of the fields it changed. */
+interface RecordEvent<R> {
+    readonly record: R;
+    readonly changed: readonly string[];
+}
+/** An entry event: the entry as the write left it, and the names of the fields it changed. */
+interface EntryEvent {
+    readonly entry: unknown;
+    readonly changed: readonly string[];
+}
+/** One field's `where`: its value, or the list grammar's operators and `becomes`. */
+type FieldWhere<T> = ComparedWith<T> | ({
+    readonly becomes?: ComparedWith<T>;
+} & {
+    readonly [Op in 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte']?: ComparedWith<T>;
+} & {
+    readonly in?: ReadonlyArray<ComparedWith<T>>;
+    readonly nin?: ReadonlyArray<ComparedWith<T>>;
+    readonly exists?: boolean;
+});
+/**
+ * A trigger's `where`: field by field over the item — `{ status: { becomes: 'paid' } }`, every field
+ * holding — or a condition over the event, written with `becomes` and the list grammar.
+ */
+type TriggerWhere<E, Item> = {
+    readonly [F in keyof Item & string]?: FieldWhere<Item[F]>;
+} | ((event: Ref<E, true>) => AutomationWhere);
+/** Where a type's item rides at run time: `records.order` says it is the Record type `order`. */
+declare const ITEM: unique symbol;
+/** Where one item by uid rides at run time: what `<type>.ref(uid)` returns. */
+declare const ITEM_REF: unique symbol;
+/** Where a type's or an item's value type rides, for the compiler alone. */
+declare const ITEM_TYPE: unique symbol;
+/** What a type, or one item of it, holds: a Record of `R`, or an entry with the values `V`. */
+type ItemType<R = unknown, V = unknown> = {
+    readonly kind: 'record';
+    readonly record: R;
+} | {
+    readonly kind: 'entry';
+    readonly values: V;
+};
+/** The type a Record or entry type's handle names, as data. */
+type ItemTypeOf = {
+    readonly kind: 'record';
+    readonly recordType: string;
+} | {
+    readonly kind: 'entry';
+    readonly contentType: string;
+};
+/**
+ * A uid: a reference to one — `event.record._metadata.id`, a reference field, an earlier step's
+ * output — or a uid written out.
+ */
+type UidRef = string | RefTo<string | null | undefined>;
+/**
+ * One Record or entry, by its uid, typed by its type: `records.order.ref(event.record._metadata.id)`.
+ * `step.lookup` reads one, and a run may be declared to be about one (REL-4152).
+ */
+interface AutomationItemHandle<I extends ItemType = ItemType> {
+    readonly [ITEM_REF]: AutomationItemRef;
+    readonly [ITEM_TYPE]?: I;
+}
+/** The triggers of one Record type. */
+interface RecordTriggers<R> {
+    /** A typed reference to one Record of this type, by its uid. */
+    ref(uid: UidRef): AutomationItemHandle<{
+        readonly kind: 'record';
+        readonly record: R;
+    }>;
+    readonly [ITEM]: ItemTypeOf;
+    readonly [ITEM_TYPE]?: {
+        readonly kind: 'record';
+        readonly record: R;
+    };
+    created(options?: {
+        where?: TriggerWhere<RecordEvent<R>, R>;
+    }): AutomationTriggerHandle<RecordEvent<R>>;
+    updated(options?: {
+        where?: TriggerWhere<RecordEvent<R>, R>;
+    }): AutomationTriggerHandle<RecordEvent<R>>;
+    deleted(options?: {
+        where?: TriggerWhere<RecordEvent<R>, R>;
+    }): AutomationTriggerHandle<RecordEvent<R>>;
+    expired(options?: {
+        where?: TriggerWhere<RecordEvent<R>, R>;
+    }): AutomationTriggerHandle<RecordEvent<R>>;
+}
+/** The triggers of one content type, whose entries hold the values `V`. */
+type EntryTriggers<V = Record<string, unknown>> = {
+    readonly [A in AutomationEntryAction]: (options?: {
+        where?: TriggerWhere<EntryEvent, Record<string, unknown>>;
+    }) => AutomationTriggerHandle<EntryEvent>;
+} & {
+    /** A typed reference to one entry of this type, by its uid. */
+    ref(uid: UidRef): AutomationItemHandle<{
+        readonly kind: 'entry';
+        readonly values: V;
+    }>;
+    readonly [ITEM]: ItemTypeOf;
+    readonly [ITEM_TYPE]?: {
+        readonly kind: 'entry';
+        readonly values: V;
+    };
+};
+/** Each Record type's triggers, by name: typed by the registered schema, any name without one. */
+type RecordTriggerTable = string extends RecordTypeNameIn$1<RegisteredSchema> ? {
+    readonly [recordType: string]: any;
+} : {
+    readonly [K in RecordTypeNameIn$1<RegisteredSchema>]: RecordTriggers<RecordIn$1<RegisteredSchema, K>>;
+};
+/** Each content type's triggers, by name. */
+type EntryTriggerTable = string extends ContentTypeNameIn<RegisteredSchema> ? {
+    readonly [contentType: string]: any;
+} : {
+    readonly [K in ContentTypeNameIn<RegisteredSchema>]: EntryTriggers<EntryValuesIn<RegisteredSchema, K>>;
+};
+/**
+ * `records.<type>.created | updated | deleted | expired`: a Record event of one Record type.
+ * `records.<type>` itself names the type to `step.lookup`, and `records.<type>.ref(uid)` one Record.
+ */
+declare const records: RecordTriggerTable;
+/**
+ * `entries.<type>.created | updated | published | …`: an entry event of one content type.
+ * `entries.<type>` itself names the type to `step.lookup`, and `entries.<type>.ref(uid)` one entry.
+ */
+declare const entries: EntryTriggerTable;
+/**
+ * What a run started by an entry of any content type reads under `event` (REL-3861): what every
+ * entry event holds whatever its type — the entry's uid and content type, and the names of the
+ * fields the write changed. No field of the entry: no one content type declares it.
+ */
+interface AnyEntryEvent {
+    readonly entry: {
+        readonly _metadata: {
+            readonly id: string;
+            readonly type: string;
+        };
+    };
+    readonly changed: readonly string[];
+}
+/** The triggers of an entry of any content type, one per entry action. */
+type AnyEntryTriggers = {
+    readonly [A in AutomationEntryAction]: (options?: {
+        readonly where?: (event: Ref<AnyEntryEvent>) => ConditionTree;
+    }) => AutomationTriggerHandle<AnyEntryEvent>;
+};
+/**
+ * `anyEntry.created | updated | published | …`: an entry event of any content type — what a site
+ * that revalidates every page it renders listens to. `where` is a function of the event, which holds
+ * the entry's `_metadata.id` and `_metadata.type` and `changed` alone, and no `becomes`:
+ * `anyEntry.published({ where: event => event.entry._metadata.type.in(['post']) })`.
+ */
+declare const anyEntry: AnyEntryTriggers;
+/** A clock: `schedule.cron('0 8 * * 1', { timezone: 'Europe/Berlin' })`, on Production only. */
+declare const schedule: {
+    cron(cron: string, options: {
+        readonly timezone: string;
+    }): AutomationTriggerHandle<Record<string, never>>;
+};
+/**
+ * What a run started by another run's failure reads under `event` (REL-4152): the failed run, its
+ * Automation and Branch, what it was about, the step it failed at, the error, and the event that set
+ * it off by type and id. Never that event's body: a Record's values stay on the failed run.
+ */
+interface RunFailedEvent {
+    readonly runId: string;
+    /** The Automation whose run failed. */
+    readonly automation: string;
+    readonly branchId: string;
+    /** The Record or entry the failed run was about — and so the one this run is about. */
+    readonly about: {
+        readonly kind: 'record' | 'entry';
+        readonly type: string;
+        readonly uid: string;
+    } | null;
+    readonly step: {
+        readonly name: string;
+        /** `function`, `agent`, `action`, `if` or `wait`. */
+        readonly kind: string;
+        readonly attempts: number;
+    };
+    readonly error: {
+        readonly code: string;
+        readonly message: string;
+    };
+    readonly trigger: {
+        readonly eventType: string;
+        readonly eventId: string;
+    };
+}
+/** One value's `where` with no `becomes`: the value, or the list grammar's operators. */
+type ValueWhere<T> = ComparedWith<T> | ({
+    readonly [Op in 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte']?: ComparedWith<T>;
+} & {
+    readonly in?: ReadonlyArray<ComparedWith<T>>;
+    readonly nin?: ReadonlyArray<ComparedWith<T>>;
+    readonly exists?: boolean;
+});
+/** Where each name a failed run's `where` shorthand filters on sits under `event`. */
+declare const RUN_FAILED_PATHS: {
+    readonly automation: readonly ["automation"];
+    readonly step: readonly ["step", "name"];
+    readonly code: readonly ["error", "code"];
+};
+/**
+ * A failed run's `where`: by its Automation, the step it failed at and the error's code —
+ * `{ automation: 'order-paid', code: { in: ['send-refused'] } }`, every one holding — or a condition
+ * over {@link RunFailedEvent}. No `becomes`: a failure changes no field.
+ */
+type RunFailedWhere = {
+    readonly [K in keyof typeof RUN_FAILED_PATHS]?: ValueWhere<string>;
+} | ((event: Ref<RunFailedEvent>) => ConditionTree);
+/**
+ * Another Automation's run failed: `automations.runFailed({ where })`, on the failed run's Branch.
+ * An Automation never hears its own failure, and a run a failure started never announces its own.
+ */
+declare const automations: {
+    runFailed(options?: {
+        readonly where?: RunFailedWhere;
+    }): AutomationTriggerHandle<RunFailedEvent>;
+};
+/**
+ * What a run started by an Extension's Trigger reads under `event`: what the third party sent, as the
+ * Trigger's payload fields declare it (`event.payload.data.object.id`).
+ */
+interface ExtensionTriggerEvent<P> {
+    readonly payload: P;
+}
+/**
+ * One of an Extension's Triggers, as its handle in `relyio/extensions.ts` builds it: the Extension by
+ * slug, the Trigger by its slug in the catalog, and `where`, a plain condition over the event — no
+ * `becomes`, since the third party's event names no field RelyIO saw change. Call the handle
+ * (`stripe.paymentIntentSucceeded({ where })`) rather than this.
+ */
+declare function extensionTrigger<P>(extension: string, trigger: string, options?: {
+    readonly where?: (event: Ref<ExtensionTriggerEvent<P>>) => ConditionTree;
+}): AutomationTriggerHandle<ExtensionTriggerEvent<P>>;
+/**
+ * Every trigger, under one name: `on.records.order.updated(…)`, as `records.order.updated(…)`. An
+ * Extension's Trigger is its handle's: `on: stripe.paymentIntentSucceeded()`.
+ */
+declare const on: {
+    readonly records: {
+        readonly [recordType: string]: any;
+    };
+    readonly entries: {
+        readonly [contentType: string]: any;
+    };
+    readonly anyEntry: AnyEntryTriggers;
+    readonly schedule: {
+        cron(cron: string, options: {
+            readonly timezone: string;
+        }): AutomationTriggerHandle<Record<string, never>>;
+    };
+    readonly automations: {
+        runFailed(options?: {
+            readonly where?: RunFailedWhere;
+        }): AutomationTriggerHandle<RunFailedEvent>;
+    };
+};
+/** An Extension's Action, as `relyio/extensions.ts` hands one out (REL-3846): input and output typed. */
+interface AutomationAction<I = Record<string, unknown>, O = Record<string, unknown>, E extends string = string, N extends string = string> {
+    readonly _tag: 'action';
+    /** The Extension, by slug: a handle from `relyio/extensions.ts` carries it as a literal type. */
+    readonly extension: E;
+    /**
+     * The Action, by its slug in the Extension catalog: what the step stores, and what a Function's
+     * `actions.<extension>.<action>` names it by (REL-3856).
+     */
+    readonly action: N;
+    /** Never present at run time: the Action's input and output, as types. */
+    readonly [REF_VALUE]?: {
+        readonly input: I;
+        readonly output: O;
+    };
+}
+/** A step as `steps` builds it: its data, a Function step's Function still the imported value. */
+type AutomationStepDraft = (Omit<Extract<AutomationStep, {
+    kind: 'function';
+}>, 'function'> & {
+    readonly function: FunctionDefinition;
+}) | Exclude<AutomationStep, {
+    kind: 'function' | 'if';
+}> | (Omit<Extract<AutomationStep, {
+    kind: 'if';
+}>, 'then' | 'else'> & {
+    readonly then: readonly AutomationStepDraft[];
+    readonly else: readonly AutomationStepDraft[];
+});
+/** Where a step handle's data rides at run time. */
+declare const STEP: unique symbol;
+/** A step, as `steps` returns it and an If's branches list it. */
+interface StepHandle {
+    readonly name: string;
+    readonly [STEP]: AutomationStepDraft;
+}
+/** A step whose output later steps read: `<step>.output.<field>`. */
+interface StepWithOutput<O> extends StepHandle {
+    readonly output: Ref<O>;
+}
+/** A Field set's values, as a Function's and an Agent step's output Fields declare them. */
+type ValuesOf$1<F extends KeyedMembers> = FieldValues<DeclaredFields<{
+    readonly fields: readonly KeyedMembersOf<F>[];
+}>>;
+/** What `step.agent` takes. */
+interface AgentStepConfig<O extends KeyedMembers> {
+    /** The agent, built-in or the project's, by id or slug; RelyIO's default when left out. */
+    readonly agent?: string;
+    readonly instructions: string | AutomationTemplate;
+    /** What the agent is handed to read, by key. */
+    readonly context?: {
+        readonly [key: string]: unknown;
+    };
+    /** The Fields its answer must fill: a mismatch fails the step. */
+    readonly output: O;
+}
+/**
+ * What a proposing `step.agent` takes besides (REL-4154): the types it may propose a change to —
+ * `entries.productPage`, `records.order`. It is offered ai-gateway's proposal tools for those types
+ * alone and makes at most one proposal, which nothing applies until an Ask approves it.
+ */
+interface ProposingAgentStepConfig<O extends KeyedMembers> extends AgentStepConfig<O> {
+    readonly propose: readonly [LookupType, ...LookupType[]];
+}
+/** The proposal a proposing Agent step made: what an Ask's `approve` names. */
+interface AutomationProposal {
+    readonly id: string;
+    /** The proposal's kind: `field_update`, `operation`, `record_update`, … */
+    readonly kind: string;
+    /** How many units it changes: entries, or Records. */
+    readonly counts: {
+        readonly units: number;
+    };
+}
+/** A proposing Agent step's output: its Fields, and the proposal — `null` when it proposed none. */
+type ProposingOutput<V> = V & {
+    readonly proposal: AutomationProposal | null;
+};
+/**
+ * What a Look-up of a Record answers: `found`, and the Record as it stands now when it was. Read
+ * `found` before the Record: an item deleted, never there, or a reference with no value is
+ * `{ found: false }`.
+ */
+interface LookedUpRecord<R> {
+    readonly found: boolean;
+    readonly record?: R;
+}
+/** The locale codes the registered schema declares, or any code without one. */
+type LocaleCodeIn<S> = S extends AnySchemaDefinition ? SchemaLocaleCodes<S> : string;
+/** An entry as a Look-up reads it: its shared values, and each locale it admits with its own. */
+interface LookedUpEntryItem<V> {
+    readonly _metadata: {
+        readonly id: string;
+        readonly type: string;
+    };
+    /** The values of the fields that are not localized. */
+    readonly fields: Partial<V>;
+    /** Each locale the state admits: its publication status and its localized values. */
+    readonly locales: {
+        readonly [L in LocaleCodeIn<RegisteredSchema>]?: {
+            readonly status: 'published' | 'draft';
+            readonly fields: Partial<V>;
+        };
+    };
+}
+/** What a Look-up of an entry answers: `found`, and the entry when it was. */
+interface LookedUpEntry<V> {
+    readonly found: boolean;
+    readonly entry?: LookedUpEntryItem<V>;
+}
+type IsAny<T> = 0 extends 1 & T ? true : false;
+/** What a Look-up of the type or item `H` answers. */
+type LookedUp<H> = IsAny<H> extends true ? {
+    readonly found: boolean;
+    readonly record?: any;
+    readonly entry?: any;
+} : H extends {
+    readonly [ITEM_TYPE]?: infer I;
+} ? I extends {
+    readonly kind: 'record';
+    readonly record: infer R;
+} ? LookedUpRecord<R> : I extends {
+    readonly kind: 'entry';
+    readonly values: infer V;
+} ? LookedUpEntry<V> : never : never;
+/** What a Look-up of `H` takes beside it: an entry's `state`; a Record has no draft. */
+type LookupOptions<H> = IsAny<H> extends true ? {
+    readonly state?: AutomationLookupState;
+} : H extends {
+    readonly [ITEM_TYPE]?: {
+        readonly kind: 'entry';
+    };
+} ? {
+    /** `published` (the default): what readers see. `draft`: the editor's view. */
+    readonly state?: AutomationLookupState;
+} : never;
+/** A Record or entry type, as `step.lookup` takes it: `records.order`, `entries.product`. */
+type LookupType = {
+    readonly [ITEM]: ItemTypeOf;
+};
+/** What `step.ask` takes. */
+interface AskStepConfig<C extends string> {
+    /**
+     * The roles asked: `viewer`, `editor`, `admin` or a custom role the schema declares, as a
+     * workflow stage's `allowedRoles`. Editors and Admins when left out. People only, never an agent.
+     */
+    readonly to?: readonly string[];
+    /** The question, rendered when the step runs: text, or {@link tpl} over the event and earlier outputs. */
+    readonly question: string | AutomationTemplate;
+    /** The answers a person may give. */
+    readonly choices: readonly C[];
+    /** How long the question stays open, up to 30 days; 7 days when left out. */
+    readonly timeout?: AutomationDuration;
+    /** The answer the step continues with once the timeout falls; without one, the step fails then. */
+    readonly onTimeout?: NoInfer<C>;
+    /** The answer a pull request's Preview run and an editor's test give at once; the first choice by default. */
+    readonly sample?: NoInfer<C>;
+}
+/** What an Ask answers later steps: the choice made, and by whom, or that the timeout fell. */
+interface AskOutput<C extends string> {
+    readonly answer: C;
+    /** What the person wrote beside the choice, at most 2,000 characters. */
+    readonly note?: string;
+    /** The user who answered; absent on a timeout and a Preview's sample. */
+    readonly answeredBy?: string;
+    /** When, as ISO-8601; absent on a timeout and a Preview's sample. */
+    readonly answeredAt?: string;
+    /** Whether the step continued with `onTimeout` because nobody answered in time. */
+    readonly timedOut: boolean;
+}
+/** An approving Ask's choices, in order: a Preview's sample is the first. */
+declare const APPROVE_CHOICES: readonly ["approve", "reject"];
+type ApproveChoice = (typeof APPROVE_CHOICES)[number];
+/**
+ * What an approving `step.ask` takes (REL-4154): `approve` names an earlier Agent step's proposal,
+ * and the choices are `approve` and `reject`. Only members holding `to`'s roles and the authority
+ * the proposal's apply needs are asked or may answer. A timeout never approves.
+ */
+interface ApproveStepConfig {
+    readonly to?: readonly string[];
+    readonly question: string | AutomationTemplate;
+    /** The proposal: `<agent step>.output.proposal`. */
+    readonly approve: Ref<AutomationProposal | null>;
+    readonly timeout?: AutomationDuration;
+    /** What the step continues with once the timeout falls: only ever `reject`. */
+    readonly onTimeout?: 'reject';
+    /** What a Preview answers at once: `approve` by default. */
+    readonly sample?: ApproveChoice;
+}
+/** What became of an approved — or not — proposal, by its units. */
+interface ApproveCounts {
+    readonly applied: number;
+    readonly stale: number;
+    readonly failed: number;
+}
+/**
+ * An approving Ask's output: the answer, and what became of the proposal — `applied`; `rejected`,
+ * answered so or timed out; `stale`, a Record that moved since the agent read it; or `failed`.
+ */
+interface ApproveOutput extends AskOutput<ApproveChoice> {
+    readonly outcome: 'applied' | 'rejected' | 'stale' | 'failed';
+    readonly counts: ApproveCounts;
+}
+/** What `steps` is handed to build steps with. */
+interface StepBuilder {
+    /** Run one of the project's Functions, taken by import, with its input. */
+    fn<F extends FunctionDefinition>(name: string, fn: F, input: StepInput<FunctionInputOf<F>>): StepWithOutput<FunctionOutputOf<F>>;
+    /**
+     * Ask an agent to read, answer the declared Fields and propose one change to the types `propose`
+     * names. Nothing it proposes is written until an Ask approves it (`step.ask(…, { approve })`).
+     */
+    agent<const O extends KeyedMembers>(name: string, config: ProposingAgentStepConfig<O>): StepWithOutput<ProposingOutput<ValuesOf$1<O>>>;
+    /** Ask an agent to read and answer the declared Fields. It reads; it never writes or sends. */
+    agent<const O extends KeyedMembers>(name: string, config: AgentStepConfig<O>): StepWithOutput<ValuesOf$1<O>>;
+    /** Send through an Extension's Action, from the events worker; Recorded in a Preview without its Connection. */
+    action<I, O>(name: string, action: AutomationAction<I, O>, input: StepInput<I>): StepWithOutput<O>;
+    /**
+     * Read one Record or entry again, as it stands now, by its uid — `found`, or not: an item deleted,
+     * never there, or a reference with no value is `{ found: false }`, never a failed step. An entry
+     * reads `published` by default, or the editor's view with `{ state: 'draft' }`. One item, never a
+     * query; unmetered.
+     *
+     * @example
+     * const recheck = step.lookup('recheck', records.order, event.record._metadata.id)
+     * step.if('still-unpaid', recheck.output.record.status.ne('paid'), { then: [remind] })
+     */
+    lookup<H extends LookupType>(name: string, type: H, uid: UidRef, options?: LookupOptions<H>): StepWithOutput<LookedUp<H>>;
+    /** Read one item, named by `<type>.ref(uid)`, again as it stands now. */
+    lookup<H extends AutomationItemHandle>(name: string, item: H, options?: LookupOptions<H>): StepWithOutput<LookedUp<H>>;
+    /** Then one step list or the other, by a condition over the event and earlier outputs. */
+    if(name: string, condition: ConditionTree, branches: {
+        readonly then?: readonly StepHandle[];
+        readonly else?: readonly StepHandle[];
+    }): StepHandle;
+    /** Hold the run, up to 30 days: `'90m'`, `'2h'`, `'3d'`. */
+    wait(name: string, duration: AutomationDuration): StepHandle;
+    /**
+     * Ask the people holding `to`'s roles, through the Studio inbox and an email, and continue with
+     * the first answer — one of `choices` — or with `onTimeout` once `timeout` falls.
+     */
+    ask<const C extends string>(name: string, config: AskStepConfig<C>): StepWithOutput<AskOutput<C>>;
+    /**
+     * Ask whether to apply an Agent step's proposal: `approve` applies it through ai-gateway's apply
+     * path as the person who answered, and the run continues once it is applied, with the outcome.
+     *
+     * @example
+     * const approval = step.ask('approve', { to: ['editor'], question: 'Publish the page?', approve: draft.output.proposal, onTimeout: 'reject' })
+     * step.if('moved', approval.output.outcome.eq('stale'), { then: [tellOps] })
+     */
+    ask(name: string, config: ApproveStepConfig): StepWithOutput<ApproveOutput>;
+}
+/** What `defineAutomation` takes. */
+interface AutomationConfig<E> {
+    readonly description?: string;
+    /**
+     * The trigger: `records.<type>.<action>(…)`, `entries.<type>.<action>(…)`, `anyEntry.<action>(…)`,
+     * `schedule.cron(…)`,
+     * `automations.runFailed(…)`, or an Extension's Trigger from `relyio/extensions.ts`.
+     */
+    readonly on: AutomationTriggerHandle<E>;
+    /**
+     * What each run is about, so the runs about one order are found across Automations: one Record or
+     * entry, by a uid the event names — `({ event }) =>
+     * records.order.ref(event.payload.data.object.metadata.orderId)`. Left out, a run is about what its
+     * trigger names: the Record or entry of a RelyIO event, the outside object of an Extension's
+     * Trigger (Stripe's payment intent), the failed run's item, or nothing for a clock.
+     */
+    readonly about?: (context: {
+        readonly event: Ref<E>;
+    }) => AutomationItemHandle;
+    /**
+     * Called once, when the Manifest loads, with a reference to the event and the step builder;
+     * returns the steps in the order a run takes them.
+     */
+    readonly steps: (context: {
+        readonly event: Ref<E>;
+        readonly step: StepBuilder;
+    }) => readonly StepHandle[];
+}
+/**
+ * What an Automation file default-exports: its definition as data, each Function step still naming
+ * the Function it imported. The CLI names those by their files ({@link resolveAutomation}).
+ */
+interface AutomationFile {
+    readonly _tag: 'automation';
+    readonly description?: string;
+    readonly on: AutomationTrigger;
+    readonly about?: AutomationItemRef;
+    readonly steps: readonly AutomationStepDraft[];
+}
+/**
+ * Declare an Automation. The file's name is its name; `relyio deploy` reads it into the Manifest,
+ * plans it and ships it with the rest.
+ */
+declare function defineAutomation<E>(config: AutomationConfig<E>): AutomationFile;
+/** Whether `value` is what `defineAutomation` returns: how the CLI reads an Automation file. */
+declare function isAutomationFile(value: unknown): value is AutomationFile;
+/**
+ * The Automation as the Manifest carries it: each Function step's Function named by `nameOf` — the
+ * CLI's, which knows which file under `relyio/functions/` exported it. A Function no file exported
+ * is refused by name.
+ */
+declare function resolveAutomation(file: AutomationFile, nameOf: (fn: FunctionDefinition) => string | undefined): AutomationDefinition;
+
+/**
+ * `@relyio/sdk/extensions` — the Extensions a Project uses (spec 3, REL-3846; ADR 0019).
+ *
+ * One file, `relyio/extensions.ts`, names each Extension the Project uses and its settings — set once
+ * for the Project, never per Environment — and hands out a typed handle for each. An Automation
+ * imports the handle: its Triggers start an Automation (`on: vercel.deploymentSucceeded()`), and its
+ * Actions are what `step.action` sends through, their input and output typed by the Extension.
+ *
+ * @example
+ * // relyio/extensions.ts
+ * import { defineExtensions } from '@relyio/sdk/extensions'
+ *
+ * const extensions = defineExtensions({
+ *   slack: { defaultChannel: '#orders' },
+ *   vercel: {},
+ * })
+ * export const { slack, vercel } = extensions
+ * export default extensions
+ *
+ * **Never a secret here.** A Connection — an API key, a signing secret, a webhook URL — is made in
+ * the Dashboard, once per Environment, and sealed. A setting is text anyone reading the repository
+ * may see. Declaring an Extension connects nothing: `relyio plan` says which still need connecting
+ * in Production, and which Automations will deploy paused there until they are. Preview never pauses:
+ * an Action with no Preview Connection is Recorded with its sample result.
+ *
+ * **Typed.** Each Extension's settings, Actions and Triggers are RelyIO's own declaration of it
+ * (`@relyio/api-contract`'s `EXTENSION_SURFACES`, which the Extension catalog delivers): an Extension
+ * RelyIO does not have, a setting it does not declare, or a value its setting does not take — a
+ * Slack channel without its `#` — is a type error, and the plan refuses it again for a Manifest read
+ * as data.
+ */
+
+/** One Extension a Project uses: its settings, by key. */
+interface ExtensionUse {
+    readonly settings: Readonly<Record<string, string>>;
+}
+/** What `relyio/extensions.ts` declares, as data: every Extension the Project uses, by slug. */
+type ExtensionsDeclaration = Readonly<Record<string, ExtensionUse>>;
+/** Every Extension a Project may declare, and what its code may name of each. */
+type Surfaces = ExtensionSurfaces;
+/** The value one setting takes: one of its options, text starting with its prefix, or text. */
+type SettingValue<F extends ExtensionSettingField> = F extends {
+    readonly type: 'select';
+    readonly options: ReadonlyArray<infer Option>;
+} ? Option : F extends {
+    readonly type: 'text';
+    readonly prefix: infer Prefix extends string;
+} ? `${Prefix}${string}` : string;
+type Flatten<T> = {
+    readonly [K in keyof T]: T[K];
+};
+/** The settings an Extension takes: its required ones required, the rest optional, nothing else. */
+type SettingsFrom<F extends ExtensionSettingField> = Flatten<{
+    readonly [Field in F as Field extends {
+        readonly required: true;
+    } ? Field['key'] : never]: SettingValue<Field>;
+} & {
+    readonly [Field in F as Field extends {
+        readonly required: true;
+    } ? never : Field['key']]?: SettingValue<Field>;
+}>;
+/**
+ * The settings `defineExtensions` takes for Extension `S`. An Extension with none takes `{}` and
+ * nothing in it.
+ */
+type ExtensionSettings<S extends keyof Surfaces> = [
+    Surfaces[S]['settings'][number]
+] extends [never] ? Readonly<Record<string, never>> : SettingsFrom<Surfaces[S]['settings'][number]>;
+/** What `defineExtensions` takes: each Extension the Project uses, by slug, with its settings. */
+type ExtensionsConfig = {
+    readonly [S in keyof Surfaces]?: ExtensionSettings<S>;
+};
+/** A value field's JSON type, as TypeScript reads it. */
+type JsonOf<T extends ExtensionValueField['type']> = T extends 'string' ? string : T extends 'number' ? number : T extends 'boolean' ? boolean : T extends 'array' ? readonly unknown[] : Readonly<Record<string, unknown>>;
+/** A dot-separated path's first segment. */
+type Head<P extends string> = P extends `${infer First}.${string}` ? First : P;
+/** The fields whose path starts with segment `K`. */
+type Under<F extends ExtensionValueField, K extends string> = F extends ExtensionValueField ? Head<F['path']> extends K ? F : never : never;
+/** The fields under `K`, their paths with `K.` taken off; never for the field at `K` itself. */
+type Rebased<F extends ExtensionValueField, K extends string> = F extends ExtensionValueField ? F['path'] extends `${K}.${infer Rest}` ? Omit<F, 'path'> & {
+    readonly path: Rest;
+} : never : never;
+/** A field's value: its JSON type, and an object of strings for one declaring string values. */
+type FieldValueOf<F extends ExtensionValueField> = F extends {
+    readonly values: 'string';
+} ? Readonly<Record<string, string>> : JsonOf<F['type']>;
+/** The value at `K`: the field there, or an object of the fields under it. */
+type ValueAt<F extends ExtensionValueField, K extends string> = [
+    Extract<F, {
+        readonly path: K;
+    }>
+] extends [never] ? ValuesOf<Rebased<F, K>> : FieldValueOf<Extract<F, {
+    readonly path: K;
+}>>;
+/**
+ * Value fields as an object: `payload.data.object.id` a `string` at `payload.data.object.id`. A
+ * segment is required when a field under it is.
+ */
+type ValuesOf<F extends ExtensionValueField> = Flatten<{
+    readonly [K in Head<F['path']> as true extends Under<F, K>['required'] ? K : never]: ValueAt<F, K>;
+} & {
+    readonly [K in Head<F['path']> as true extends Under<F, K>['required'] ? never : K]?: ValueAt<F, K>;
+}>;
+/** A Trigger's payload, as an object; one that declares nothing, `{}`. */
+type ValuesOfList<L extends readonly ExtensionValueField[]> = [L[number]] extends [never] ? Record<string, never> : ValuesOf<L[number]>;
+/** An action field's value, as TypeScript reads it (`@relyio/api-contract`'s `ACTION_FIELD_TYPES`). */
+type ActionValueOf<T extends ActionField['type']> = T extends 'text' | 'url' ? string : T extends 'number' ? number : T extends 'boolean' ? boolean : T extends 'headers' ? Readonly<Record<string, string>> : AutomationJson;
+/** An Action's input or output fields as an object: required ones required, the rest optional. */
+type ActionValuesOf<L extends readonly ActionField[]> = Flatten<{
+    readonly [F in L[number] as F extends {
+        readonly required: true;
+    } ? F['key'] : never]: ActionValueOf<F['type']>;
+} & {
+    readonly [F in L[number] as F extends {
+        readonly required: true;
+    } ? never : F['key']]?: ActionValueOf<F['type']>;
+}>;
+/** A Trigger's handle: call it for the Automation's `on`, with a `where` over its event if needed. */
+type ExtensionTriggerHandle<P> = (options?: {
+    readonly where?: (event: Ref<ExtensionTriggerEvent<P>>) => ConditionTree;
+}) => AutomationTriggerHandle<ExtensionTriggerEvent<P>>;
+/**
+ * The handle an Extension's declaration gives: each of its Actions and Triggers, by the name it gives
+ * them, typed by their fields.
+ */
+type HandleOf<X extends ExtensionSurface, S extends string = string> = {
+    readonly [A in keyof X['actions']]: X['actions'][A] extends {
+        readonly action: infer N extends string;
+        readonly step: {
+            readonly input: infer I extends readonly ActionField[];
+            readonly output: infer O extends readonly ActionField[];
+        };
+    } ? AutomationAction<ActionValuesOf<I>, ActionValuesOf<O>, S, N> : never;
+} & {
+    readonly [T in keyof X['triggers']]: X['triggers'][T] extends {
+        readonly payload: infer P extends readonly ExtensionValueField[];
+    } ? ExtensionTriggerHandle<ValuesOfList<P>> : never;
+};
+/**
+ * A contributed field kind's options (spec 4, REL-3894): its base reference's, without `to`, which
+ * the kind names, and never `localized` — a user is no translation.
+ */
+type ContributedFieldOptions<TTo extends string, TMulti extends boolean, TRequired extends boolean> = Omit<ReferenceConfig<TTo, TMulti>, 'to'> & {
+    readonly required?: TRequired;
+    readonly to?: never;
+} & KeyedFieldOptions<never>;
+/**
+ * A contributed field kind's builder — `clerk.userRef()`: a reference to the Extension's Managed
+ * Record type, typed exactly as `fields.reference` types a reference to it, which the Studio picks through
+ * the kind's picker. The schema, reads, writes and Policies treat it as that reference.
+ */
+type ContributedFieldKindBuilder<TTo extends string> = <TMulti extends boolean = false, TRequired extends boolean = false>(options?: ContributedFieldOptions<TTo, TMulti, TRequired>) => KeyedField<'reference', ReferenceConfig<TTo, TMulti> & {
+    required?: TRequired;
+}>;
+/** An Extension's contributed field kinds, by the name its declaration gives them. */
+type FieldKindsOf<X extends ExtensionSurface> = {
+    readonly [K in keyof X['fieldKinds']]: X['fieldKinds'][K] extends {
+        readonly base: {
+            readonly to: infer To extends string;
+        };
+    } ? ContributedFieldKindBuilder<To> : never;
+};
+/** An Extension's Managed Record types, by the name its declaration gives them (REL-3863). */
+type RecordTypesOf<X extends ExtensionSurface> = {
+    readonly [K in keyof X['recordTypes']]: X['recordTypes'][K];
+};
+/** Extension `S`'s handle. */
+type ExtensionHandle<S extends keyof Surfaces> = HandleOf<Surfaces[S], S & string> & FieldKindsOf<Surfaces[S]> & RecordTypesOf<Surfaces[S]>;
+/** Where the declaration rides on what `defineExtensions` returns. */
+declare const DECLARED = "declared";
+/**
+ * Where an {@link ExtensionsFile}'s type keeps the settings it was declared with, for
+ * {@link ClaimsOf} to read. Type-level only: no value carries it.
+ */
+declare const DECLARED_SETTINGS: unique symbol;
+/**
+ * What `relyio/extensions.ts` default-exports: the declaration the CLI reads into the Manifest, and
+ * a handle for each Extension it declares.
+ */
+type ExtensionsFile<C> = ExtensionsFileData & {
+    readonly [S in keyof C & keyof Surfaces]: ExtensionHandle<S>;
+} & {
+    readonly [DECLARED_SETTINGS]?: C;
+};
+/** The setting an identity Extension declares its Claims in (`@relyio/api-contract`'s `IDENTITY_CLAIMS_SETTING`). */
+type ClaimsSetting = 'claims';
+/** `S` without the whitespace `String.prototype.trim` takes off either end. */
+type Trimmed<S extends string> = S extends `${' ' | '\n' | '\t' | '\r'}${infer Rest}` ? Trimmed<Rest> : S extends `${infer Rest}${' ' | '\n' | '\t' | '\r'}` ? Trimmed<Rest> : S;
+/**
+ * The Claim names a `claims` setting declares, read as `claimNamesOf` reads it at deploy: split on
+ * commas, each trimmed, empty ones dropped. Text TypeScript does not know (`string`) may name any.
+ */
+type ClaimNames<S extends string> = string extends S ? string : S extends `${infer First},${infer Rest}` ? ClaimNames<First> | ClaimNames<Rest> : Trimmed<S> extends '' ? never : Trimmed<S>;
+/** Every Claim name the Extensions in `C` declare: an identity Extension's `claims` setting. */
+type DeclaredClaimNames<C> = {
+    readonly [S in keyof C]: C[S] extends {
+        readonly [K in ClaimsSetting]: infer T extends string;
+    } ? ClaimNames<T> : never;
+}[keyof C];
+/**
+ * The Claims a Project relies on, typed from its `relyio/extensions.ts`: `ClaimsOf<typeof
+ * extensions>` is an object with one optional key per Claim its identity Extension's `claims`
+ * setting names — `claims: 'plan, role'` is `{ plan?: unknown; role?: unknown }`. A Claim named and
+ * missing from a token is absent, and a setting is text, so each value is `unknown`: what a Claim may
+ * hold is for the Policy that tests it to say.
+ *
+ * Type a Policy's `claims` root with it, so a misspelt Claim is a compile error:
+ *
+ * @example
+ * import type { ClaimsOf } from '@relyio/sdk/extensions'
+ * import { conditionRoot } from '@relyio/sdk/schema'
+ * import extensions from './extensions'
+ *
+ * const claims = conditionRoot<ClaimsOf<typeof extensions>>('claims')
+ * claims.plan.eq('paid') // ✓
+ * claims.plna.eq('paid') // ✗ `plna` is no Claim the Project declares
+ */
+type ClaimsOf<F> = F extends {
+    readonly [DECLARED_SETTINGS]?: infer C;
+} ? {
+    readonly [N in DeclaredClaimNames<C>]?: unknown;
+} : never;
+/** `C`, refusing a key no Extension declares — at the top and in each Extension's settings. */
+type Exactly<C> = {
+    readonly [S in keyof C]: S extends keyof Surfaces ? C[S] & {
+        readonly [K in Exclude<keyof C[S], keyof ExtensionSettings<S>>]: never;
+    } : never;
+};
+/**
+ * Declare the Extensions the Project uses, with their settings, and take a typed handle for each.
+ * The file is `relyio/extensions.ts`; `relyio deploy` reads its default export into the Manifest.
+ */
+declare function defineExtensions<const C extends ExtensionsConfig>(config: C & Exactly<C>): ExtensionsFile<C>;
+/** What the CLI reads of `relyio/extensions.ts`' default export, whatever it declares. */
+interface ExtensionsFileData {
+    readonly _tag: 'extensions';
+    readonly [DECLARED]: ExtensionsDeclaration;
+}
+/** Whether `value` is what `defineExtensions` returns: how the CLI reads `relyio/extensions.ts`. */
+declare function isExtensionsFile(value: unknown): value is ExtensionsFileData;
+/** The declaration as the Manifest carries it. */
+declare function extensionsDeclarationOf(file: ExtensionsFileData): ExtensionsDeclaration;
+
+/**
+ * The atomic Record batch (spec 1, REL-3774): `relyio.records.batch([...])` — an ordered list of
+ * Record operations across Record types, run in one transaction, all or none.
+ *
+ * Each operation is `create`, `update`, `delete`, `increment` or `decrement`, and names its Record by
+ * `id`, by `where` (the one Record of its type whose top-level fields have those values), or both —
+ * `where` then a precondition. A refused operation rolls the whole batch back, and the refusal names
+ * it: {@link refusedOperationOf} reads its index off the error. A counter moved past its bound is a
+ * `ResourceConflictError` whose `blockage` is `counter-out-of-bounds`, naming the field, the bound and
+ * the value it holds.
+ *
+ * Every batch is sent with an `Idempotency-Key` — yours, or one minted for the call — so a batch
+ * retried after a lost answer is answered as done, never written twice.
+ */
+
+/** A condition's value: what one top-level field holds, compared for equality. */
+type RecordConditionValue = string | number | boolean | null;
+/**
+ * Which stored Record an operation lands on: by `id`, by `where`, or both. Every `where` is read
+ * before the batch's first operation runs, so it names a Record stored before the batch — never one
+ * an earlier operation of the same batch creates.
+ */
+type RecordBatchTarget = {
+    id: string;
+    where?: Record<string, RecordConditionValue>;
+} | {
+    id?: undefined;
+    where: Record<string, RecordConditionValue>;
+};
+/** One operation of a batch. `type` is a Record type the schema declares. */
+type RecordBatchOperation<TType extends string = string> = {
+    op: 'create';
+    type: TType;
+    fields: Record<string, unknown>;
+} | ({
+    op: 'update';
+    type: TType;
+    /** The fields to change; one given `null` is removed. A counter is never set. */
+    fields: Record<string, unknown>;
+    /** The revision the change was made on; absent, the update writes over the one stored. */
+    revision?: number;
+} & RecordBatchTarget) | ({
+    op: 'delete';
+    type: TType;
+} & RecordBatchTarget) | ({
+    op: 'increment' | 'decrement';
+    type: TType;
+    /** The counter. */
+    field: string;
+    /** A whole number above zero. */
+    by: number;
+} & RecordBatchTarget);
+/** What a batch takes beside its operations. */
+interface RecordBatchOptions extends RecordCallOptions {
+    /**
+     * The key naming this batch. Sent again — by you, or by a retry — the batch is answered as the
+     * first was and written once; with other operations it is refused. Minted for you when absent.
+     */
+    idempotencyKey?: string;
+}
+/** What a committed batch answers: each operation, in order, and whether this is a replay. */
+type RecordBatchResult = components['schemas']['RecordBatchResult'];
+/** What one operation of a committed batch did. */
+type RecordBatchOperationResult = components['schemas']['RecordBatchOperationResult'];
+/**
+ * The index, from 0, of the batch operation a refusal names: a `ResourceConflictError`'s
+ * `blockage.facts.operation`, or the first violation under `operations[<index>]` of a
+ * `ValidationError`. `undefined` for an error that names none — one about the whole batch, such as
+ * an allowance, or no batch refusal at all.
+ */
+declare function refusedOperationOf(error: unknown): number | undefined;
+
+/**
+ * `@relyio/sdk/functions` — a Function, declared (spec 2, REL-3819; ADR 0021).
+ *
+ * One file per Function at `relyio/functions/<name>.ts`, default-exporting what
+ * {@link defineFunction} returns; the file's name is the Function's. Everything but `run` is data —
+ * its input and output Fields, its reach, its Secrets and its Ways in — which `relyio deploy` reads
+ * into the Manifest and plans. `run` is the code: the CLI bundles the file and uploads the bundle.
+ *
+ * @example
+ * // relyio/functions/checkout.ts
+ * import { defineFunction, fields } from '@relyio/sdk/functions'
+ *
+ * export default defineFunction({
+ *   input: { cartId: fields.shortText({ required: true }) },
+ *   output: { orderId: fields.shortText({ required: true }) },
+ *   records: { read: ['cart', 'product'], write: ['order', 'inventory'] },
+ *   network: [{ host: 'api.stripe.com' }],
+ *   secrets: { STRIPE_SECRET_KEY: { hosts: ['api.stripe.com'] } },
+ *   route: { method: 'POST', path: '/checkout' },
+ *   async run({ input, records }) {
+ *     const cart = await records.cart.get(input.cartId)
+ *     // records.review here is a type error: checkout does not declare it
+ *     …
+ *   },
+ * })
+ *
+ * **Typed from the schema.** Once `relyio generate-types` has registered the schema (`Register`), a
+ * Record type the reach names must be one the schema declares, and `records.<type>` is typed by its
+ * fields. A type the reach does not name is not on `records` at all.
+ *
+ * The capability object's runtime is the Functions runner's (spec 2, F2); this module declares its
+ * types and the data `defineFunction` evaluates to.
+ */
+
+/** Where a Function runs: a Dynamic Worker by default, a Container when it says so. */
+type FunctionRuntime = 'isolate' | 'container';
+/** A Container's instance type (Cloudflare's names): up to `standard-4`, 4 vCPU and 12 GiB. */
+type FunctionContainerSize = 'lite' | 'basic' | 'standard-1' | 'standard-2' | 'standard-3' | 'standard-4';
+/** A whole number of seconds or minutes: `'30s'`, `'5m'`. */
+type FunctionDuration = `${number}s` | `${number}m`;
+/** The methods a route answers. */
+type FunctionRouteMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+/** A host a Function may call. `preview: 'send'`: a Preview branch's request to it is sent, not Recorded. */
+interface FunctionNetworkHost {
+    readonly host: string;
+    readonly preview?: 'send';
+}
+/**
+ * An Extension's Action a Function may send through (spec 3, REL-3856), as the declaration carries
+ * it: the Extension's and the Action's catalog slugs.
+ */
+interface FunctionActionReach {
+    readonly extension: string;
+    readonly action: string;
+}
+/**
+ * An Action handle `reach.actions` takes: what `relyio/extensions.ts`' handles hand out
+ * (`resend.send`), its Extension and Action slugs and its input and output carried as types.
+ */
+type FunctionActionHandle = AutomationAction<unknown, unknown>;
+/** A Secret a Function declares: the hosts it may be sent to. Its value is set per Environment. */
+interface FunctionSecretDeclaration {
+    readonly hosts: readonly string[];
+}
+/** An HTTP route: static segments and `:params` — `'/orders/:id'`. */
+interface FunctionRoute {
+    readonly method: FunctionRouteMethod;
+    readonly path: string;
+    /** Present: a Public route on the Project's host, called without a key, 60 calls a minute per address unless `perIp` says otherwise. */
+    readonly public?: {
+        readonly perIp?: number;
+        /** A Secret this Function declares, holding the Turnstile secret key a call's token is verified with. */
+        readonly turnstile?: string;
+    };
+    /** Browser origins allowed to call the route: `['https://shop.example.com']`. */
+    readonly cors?: readonly string[];
+}
+/** An agent tool, offered in the AI Workspace and over MCP. */
+interface FunctionTool {
+    readonly description: string;
+}
+/** A schedule, to the minute, on Production only: `{ cron: '0 8 * * 1', timezone: 'Europe/Berlin' }`. */
+interface FunctionSchedule {
+    readonly cron: string;
+    readonly timezone: string;
+}
+/**
+ * A stored Field, as the content model compiles a keyed one. Plain data: what the Manifest carries
+ * and `@relyio/manifest` validates.
+ */
+type FunctionFieldDeclaration = object;
+/**
+ * What a Function declares besides its code, every default filled: the Functions area's data shape
+ * (`@relyio/manifest`'s `FunctionDeclaration`, which the CLI's type test holds this to).
+ */
+interface FunctionDeclaration {
+    readonly description?: string;
+    readonly runtime: FunctionRuntime;
+    readonly container?: {
+        readonly size: FunctionContainerSize;
+    };
+    readonly limits?: {
+        readonly cpu?: FunctionDuration;
+        readonly duration?: FunctionDuration;
+    };
+    readonly input: readonly FunctionFieldDeclaration[];
+    readonly output?: readonly FunctionFieldDeclaration[];
+    readonly records: {
+        readonly read: readonly string[];
+        readonly write: readonly string[];
+    };
+    readonly content: 'published' | 'none';
+    readonly network: readonly FunctionNetworkHost[];
+    readonly secrets: Readonly<Record<string, FunctionSecretDeclaration>>;
+    /** The Actions it may send (REL-3856); absent when it declares none. */
+    readonly actions?: readonly FunctionActionReach[];
+    /** Who besides a secret key may call its SDK Way in (spec 4, REL-3892); absent when undeclared. */
+    readonly endUsers?: FunctionEndUsers;
+    readonly route?: FunctionRoute;
+    readonly tool?: FunctionTool;
+    readonly schedule?: FunctionSchedule;
+}
+/**
+ * The Record type names a schema declares, or any name without one. Generic over the schema on
+ * purpose: written over `RegisteredSchema` directly, the conditional was resolved once, before the
+ * program's `Register` augmentation was in view, and answered `string` (measured).
+ */
+type RecordTypeNameIn<S> = S extends AnySchemaDefinition ? SchemaRecordTypeNames<S> : string;
+/** The Record type names the registered schema declares, or any name before one is registered. */
+type FunctionRecordTypeName = RecordTypeNameIn<RegisteredSchema>;
+/** A Record type of a schema, by name. */
+type RecordTypeIn<S, K> = S extends AnySchemaDefinition ? NonNullable<S['recordTypes']>[K & keyof NonNullable<S['recordTypes']>] : never;
+/** A Record of one Record type as a read answers it, typed by the schema when there is one. */
+type RecordIn<S, K> = S extends AnySchemaDefinition ? InferRecordType<RecordTypeIn<S, K>> : BaseRecord;
+/** What a create of one Record type takes. */
+type WriteIn<S, K> = S extends AnySchemaDefinition ? RecordWriteFieldsOf<RecordTypeIn<S, K>> : Record<string, unknown>;
+/** What an update of one Record type takes: the create's values without its Counters. */
+type UpdateIn<S, K> = S extends AnySchemaDefinition ? RecordUpdateFieldsOf<RecordTypeIn<S, K>> : Record<string, unknown>;
+/** A Record of one Record type of the registered schema. */
+type RecordOf<K> = RecordIn<RegisteredSchema, K>;
+/**
+ * A File a run sets (REL-3832), as `records.file(bytes, { name })` answers it: its name, media type
+ * and size, and the bytes held beside it until the write naming it is sent. Set it as the value of
+ * a File field in a create, an update or a batch; the run asks RelyIO for the upload, puts the bytes
+ * and sends the write naming it, so a retried run names the File its first attempt stored.
+ */
+interface FunctionFile {
+    readonly name: string;
+    /** The media type: as given, else read off the name's extension, else `application/octet-stream`. */
+    readonly type: string;
+    /** In bytes. */
+    readonly size: number;
+}
+/** What a write takes: a File field takes a {@link FunctionFile} where it takes an upload. */
+type WithFunctionFiles<T> = {
+    [F in keyof T]: FileUpload extends NonNullable<T[F]> ? T[F] | FunctionFile : T[F];
+};
+/** A Counter move in a run: the Record by `id`, `where` or both, the Counter, and how far. */
+type FunctionCounterMove = RecordBatchTarget & {
+    readonly field: string;
+    /** A whole number above zero. */
+    readonly by: number;
+};
+/**
+ * What a run may do with a Record type it only reads (REL-3822), on the run's Dataset, through spec
+ * 1's Record reader. `get` answers `null` for a Record not stored. A Record type the reach does not
+ * name is refused at run time too, not only by these types.
+ */
+interface FunctionRecordReader<K> {
+    get(id: string): Promise<RecordOf<K> | null>;
+    list(options?: {
+        /** Field conditions, in the grammar `relyio.records(type).list({ where })` takes. */
+        where?: Record<string, unknown>;
+        /** One key and its direction: `createdAt:desc` when absent. */
+        sort?: `${string}:${'asc' | 'desc'}`;
+        /** At most 100. */
+        limit?: number;
+        cursor?: string;
+    }): Promise<{
+        data: RecordOf<K>[];
+        page: {
+            nextCursor: string | null;
+            hasMore: boolean;
+        };
+    }>;
+    count(options?: {
+        where?: Record<string, unknown>;
+    }): Promise<number>;
+}
+/**
+ * What a run may do with a Record type it writes: read it, and write it one operation at a time —
+ * each sent as a batch of one, keyed as every batch of the run is, so a retried run writes it once.
+ * A refusal throws {@link FunctionBatchRefused} naming operation 0.
+ */
+interface FunctionRecordWriter<K> extends FunctionRecordReader<K> {
+    create(fields: WithFunctionFiles<WriteIn<RegisteredSchema, K>>): Promise<RecordOf<K>>;
+    update(id: string, fields: {
+        [F in keyof UpdateIn<RegisteredSchema, K>]?: WithFunctionFiles<UpdateIn<RegisteredSchema, K>>[F] | null;
+    }, options?: {
+        revision?: number;
+    }): Promise<RecordOf<K>>;
+    delete(id: string): Promise<void>;
+    increment(move: FunctionCounterMove): Promise<RecordOf<K>>;
+    decrement(move: FunctionCounterMove): Promise<RecordOf<K>>;
+}
+/**
+ * The synchronous collector `records.batch` hands its callback: each call adds one operation, over
+ * the Record types the Function writes, and nothing is read inside it. The batch is sent once the
+ * callback returns — all or none. Each answers `undefined`, and the callback must too: one that
+ * awaits returns a promise, which is a type error here and refused at run time.
+ */
+interface FunctionRecordBatch<W extends string> {
+    create(type: W, fields: Record<string, unknown>): undefined;
+    update(type: W, target: RecordBatchTarget & {
+        fields: Record<string, unknown>;
+        revision?: number;
+    }): undefined;
+    delete(type: W, target: RecordBatchTarget): undefined;
+    increment(type: W, move: FunctionCounterMove): undefined;
+    decrement(type: W, move: FunctionCounterMove): undefined;
+}
+/** What a committed batch answers: the Records it created, in order, and every operation's outcome. */
+type FunctionBatchResult = RecordBatchResult & {
+    /** The Records its creates stored, in the order the batch sent them. */
+    readonly created: BaseRecord[];
+};
+/**
+ * What a refused batch throws in a run (REL-3822), a one-operation write's included: nothing of the
+ * batch was written. `operation` is the refused operation's index from 0, `code` the API's code
+ * (`RESOURCE_CONFLICT`, `CONTENT_INVALID`, `ACCESS_DENIED`, …), `reason` what it named — a
+ * blockage's kind such as `counter-out-of-bounds`, or an issue's code — and `field` the Record field
+ * it is about, when it names one: which line of a checkout ran out of stock.
+ */
+interface FunctionBatchRefused extends Error {
+    readonly name: 'BatchRefused';
+    readonly operation: number | null;
+    readonly code: string;
+    readonly reason: string | null;
+    readonly field: string | null;
+    readonly details: Readonly<Record<string, unknown>>;
+}
+/** Whether `error` is a run's refused batch — what `records.batch` and every single write throw. */
+declare function isBatchRefused(error: unknown): error is FunctionBatchRefused;
+/** `records` in a run: exactly the Record types the reach names, and a batch over those it writes. */
+type FunctionRecords<R extends string, W extends string> = {
+    readonly [K in R | W]: K extends W ? FunctionRecordWriter<K> : FunctionRecordReader<K>;
+} & {
+    batch(collect: (batch: FunctionRecordBatch<W>) => undefined): Promise<FunctionBatchResult>;
+    /**
+     * A File for a File field of a Record type the Function writes (REL-3832): the bytes and the
+     * name, and the media type when the name's extension does not say it. Answers at once — inside a
+     * batch's collector too — and is set by the write that names it.
+     */
+    file(bytes: Uint8Array | ArrayBuffer, options: {
+        readonly name: string;
+        readonly type?: string;
+    }): FunctionFile;
+};
+/**
+ * Which Way in started a run, or `editor`: a test run from the Function editor, which always runs in
+ * the person's own Preview branch.
+ */
+type FunctionWayIn = 'sdk' | 'route' | 'tool' | 'schedule' | 'automation' | 'editor';
+/**
+ * Whether a publishable key may call a Function from a browser (spec 4, REL-3892): `'required'` for
+ * a signed-in End user only — the call carries their token — or `'optional'` with or without one.
+ */
+type FunctionEndUsers = 'required' | 'optional';
+/**
+ * The Claims a run's End user carries: those the registered `relyio/extensions.ts` declares
+ * (`ClaimsOf`), once `Register` names it — `declare module '@relyio/sdk' { interface Register {
+ * extensions: typeof extensions } }` — else any name, each `unknown`.
+ */
+type FunctionEndUserClaims = Register extends {
+    extensions: infer F;
+} ? ClaimsOf<F> : {
+    readonly [claim: string]: unknown;
+};
+/**
+ * The End user a run's call carried a verified token for (spec 4, REL-3892): their subject — the
+ * `sub` an Owner field stores — and the Claims the Project declares, as the token carries them. A
+ * Record the run creates naming no owner is theirs; what the run may touch is still its reach, never
+ * their Policies.
+ */
+interface FunctionEndUser {
+    readonly subject: string;
+    readonly claims: FunctionEndUserClaims;
+}
+/** What a run knows of itself: its id survives every retry. */
+interface FunctionRunInfo {
+    readonly id: string;
+    readonly attempt: number;
+    readonly wayIn: FunctionWayIn;
+    /**
+     * Who called, as the run record names them: `api-key:<keyId>`, `task:<taskId>` for a scheduled or
+     * Automation run, or `user:<userId>` for a person's tool call or test run.
+     */
+    readonly caller: string;
+    readonly environment: 'production' | 'preview';
+    /**
+     * The Branch the run runs on (spec 3, REL-3853): what a checkout hands Stripe as
+     * `metadata.relyio_branch`, so a Preview payment's events run that Branch's Automations.
+     */
+    readonly branchId: string;
+    /**
+     * What started a run no request started: a schedule's firing — `{ type: 'function.schedule',
+     * scheduledFor }`, the UTC instant it was for — or the event an Automation step reacts to.
+     * Absent from a run an SDK call, a route or a tool started.
+     */
+    readonly event?: Readonly<Record<string, unknown>>;
+    /**
+     * The End user whose token the call carried, verified (spec 4, REL-3892) — with any key on the SDK
+     * Way in or a keyed route, and on a Public route that was sent one. Absent otherwise.
+     */
+    readonly endUser?: FunctionEndUser;
+}
+/** Published content, read through the read core: present when the reach declares `content: 'published'`. */
+interface FunctionContent {
+    get(type: string, id: string): Promise<Record<string, unknown> | null>;
+    list(type: string, options?: {
+        where?: Record<string, RecordConditionValue>;
+        limit?: number;
+    }): Promise<{
+        data: Record<string, unknown>[];
+    }>;
+}
+/**
+ * A Function's input or output values, as its Fields declare them: what its run is handed and
+ * returns, and what `relyio.functions.<name>(input)` takes and answers once `Register` names it.
+ */
+type FunctionFieldValues<F extends KeyedMembers> = FieldValues<DeclaredFields<{
+    readonly fields: readonly KeyedMembersOf<F>[];
+}>>;
+/** What one Action handle's call takes and answers. */
+type ActionCallOf<H> = H extends AutomationAction<infer I, infer O, string, string> ? (input: I) => Promise<O> : never;
+/**
+ * `actions` in a run (REL-3856): `actions.<extension>.<action>(input)` for exactly the Actions the
+ * reach declares, typed by the Extension's own declaration. A call is sent through the events
+ * worker's one send point with the run's Environment — the run holds no key — and answers the
+ * Action's result; in a Preview without a Preview Connection, the Action's sample, the call Recorded
+ * on the run. A refusal throws {@link FunctionActionRefused}.
+ */
+type FunctionActions<A extends FunctionActionHandle> = {
+    readonly [E in A['extension']]: {
+        readonly [N in Extract<A, {
+            readonly extension: E;
+        }>['action']]: ActionCallOf<Extract<A, {
+            readonly extension: E;
+            readonly action: N;
+        }>>;
+    };
+};
+/**
+ * What a refused Action call throws in a run (REL-3856): nothing stands sent. `code` names why —
+ * `extension-not-connected` (the Extension has no Connection in the run's Environment: Functions are
+ * never paused, their call fails), `action-input-invalid`, `action-send-failed`, `action-refused`
+ * (its third party refused it, with that party's message), `action-send-in-doubt` (it may have
+ * arrived), or the API's own (`ACCESS_DENIED` for an Action outside the reach) — and `retryable`
+ * whether another attempt could send it. A refused or in-doubt call is answered the same on the
+ * run's next attempt, and never sent again.
+ */
+interface FunctionActionRefused extends Error {
+    readonly name: 'ActionRefused';
+    readonly code: string;
+    readonly retryable: boolean;
+    readonly extension: string;
+    readonly action: string;
+}
+/** Whether `error` is a run's refused Action call. */
+declare function isActionRefused(error: unknown): error is FunctionActionRefused;
+/** Everything a run is handed (spec 2, "The capability object"). No key, no project id. */
+interface FunctionCapabilities<I extends KeyedMembers, R extends string, W extends string, C extends 'published' | 'none', S extends string, A extends FunctionActionHandle = never> {
+    readonly input: FunctionFieldValues<I>;
+    readonly records: FunctionRecords<R, W>;
+    /** The Actions the reach declares, each sent without the run holding its key (REL-3856). */
+    readonly actions: FunctionActions<A>;
+    /** Published entries; `undefined` unless the reach declares `content: 'published'`. */
+    readonly content: C extends 'published' ? FunctionContent : undefined;
+    /** The gateway's fetch: only the hosts the reach declares answer. */
+    readonly fetch: typeof globalThis.fetch;
+    /** Each declared Secret as a placeholder the gateway swaps for its value on the way to its hosts. */
+    readonly secrets: {
+        readonly [K in S]: string;
+    };
+    readonly run: FunctionRunInfo;
+    /**
+     * The HTTP request, for a run a route started. Its body is the bytes the caller sent, unparsed —
+     * `await request.text()` or `arrayBuffer()` is what a webhook's sender signed.
+     */
+    readonly request: Request | undefined;
+}
+/**
+ * A response a route Function shapes itself (REL-3829): return `respond({ … })` from `run` and the
+ * route answers with that status, those headers and that body — a redirect after a form post, a
+ * `201`, a webhook's plain-text `ok`. A string body is sent as it is; any other value as JSON;
+ * `null` or none sends no body. Any other output a route Function returns is answered as JSON with
+ * `200`. The hop's own headers (`content-length`, `transfer-encoding`, …) are RelyIO's to set.
+ */
+interface FunctionResponse {
+    readonly _tag: 'function-response';
+    readonly status: number;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly body: unknown;
+}
+/**
+ * Shape a route Function's response.
+ *
+ * @example
+ * return respond({ status: 303, headers: { location: 'https://acme.example/thanks' } })
+ */
+declare function respond(response: {
+    /** 200–599. */
+    readonly status: number;
+    readonly headers?: Readonly<Record<string, string>>;
+    readonly body?: unknown;
+}): FunctionResponse;
+/** What `defineFunction` takes. Every part but `run` is data. */
+interface FunctionConfig<I extends KeyedMembers, O extends KeyedMembers, R extends FunctionRecordTypeName, W extends FunctionRecordTypeName, C extends 'published' | 'none', S extends string, A extends FunctionActionHandle = never> {
+    description?: string;
+    /** `'isolate'` when left out. */
+    runtime?: FunctionRuntime;
+    container?: {
+        size: FunctionContainerSize;
+    };
+    limits?: {
+        cpu?: FunctionDuration;
+        duration?: FunctionDuration;
+    };
+    /** The input's Fields, under their ids, as the content model's `fields.*` write them. */
+    input?: I;
+    output?: O;
+    /** Reach: the Record types it reads and writes, by name. None when left out. */
+    records?: {
+        read?: readonly R[];
+        write?: readonly W[];
+    };
+    /** Reach: `'published'` to read published content. `'none'` when left out. */
+    content?: C;
+    /** Reach: the hosts it calls. None when left out. */
+    network?: readonly FunctionNetworkHost[];
+    secrets?: {
+        readonly [K in S]: FunctionSecretDeclaration;
+    };
+    /**
+     * Reach: the Extensions' Actions it may send, by the handles `relyio/extensions.ts` gives —
+     * `actions: [resend.send]`. None when left out; `actions.<extension>.<action>` for any other is a
+     * type error, and refused at run time.
+     */
+    actions?: readonly A[];
+    /**
+     * Who besides a secret key may call it through `relyio.functions.<name>(input)` (spec 4,
+     * REL-3892): `'required'` lets a publishable key call it for a signed-in End user, whose token it
+     * carries; `'optional'` lets a publishable key call it with or without one. Left out, a secret key
+     * alone. Either way the run is bound by its reach, and `run.endUser` names who called.
+     */
+    endUsers?: FunctionEndUsers;
+    route?: FunctionRoute;
+    tool?: FunctionTool;
+    schedule?: FunctionSchedule;
+    run(capabilities: FunctionCapabilities<I, R, W, C, S, A>): Promise<FunctionFieldValues<O> | FunctionResponse | void> | FunctionFieldValues<O> | FunctionResponse | void;
+}
+/** Where a Function's input and output types ride on its definition, for the compiler alone. */
+declare const FUNCTION_FIELDS: unique symbol;
+/**
+ * What a Function file default-exports: its declaration as data, and its code. `I` and `O` are its
+ * input and output Fields, carried for the compiler alone, so an Automation's Function step that
+ * takes it by import types its input and its output from them (spec 3, REL-3845).
+ */
+interface FunctionDefinition<I extends KeyedMembers = KeyedMembers, O extends KeyedMembers = KeyedMembers> {
+    readonly _tag: 'function';
+    readonly declaration: FunctionDeclaration;
+    readonly run: (capabilities: never) => unknown;
+    /** Never present at run time: the input and output Fields, as types. */
+    readonly [FUNCTION_FIELDS]?: {
+        readonly input: I;
+        readonly output: O;
+    };
+}
+/** A Function's input values, as its Fields declare them. */
+type FunctionInputOf<F> = F extends FunctionDefinition<infer I, KeyedMembers> ? FunctionFieldValues<I> : never;
+/** A Function's output values, as its Fields declare them. */
+type FunctionOutputOf<F> = F extends FunctionDefinition<KeyedMembers, infer O> ? FunctionFieldValues<O> : never;
+/**
+ * Declare a Function. The file's name is its name; `relyio deploy` reads the declaration, bundles the
+ * file and ships both with the schema.
+ */
+declare function defineFunction<const I extends KeyedMembers = Record<never, never>, const O extends KeyedMembers = Record<never, never>, const R extends FunctionRecordTypeName = never, const W extends FunctionRecordTypeName = never, const C extends 'published' | 'none' = 'none', const S extends string = never, const A extends FunctionActionHandle = never>(config: FunctionConfig<I, O, R, W, C, S, A>): FunctionDefinition<I, O>;
+/** Whether `value` is what `defineFunction` returns: how the CLI reads a Function file's default export. */
+declare function isFunctionDefinition(value: unknown): value is FunctionDefinition;
+
+export { type AutomationTemplate as $, type AnySchemaDefinition as A, type BaseRecord as B, type RecordConditionValue as C, DefaultRetryPolicy as D, type AutomationRecordAction as E, type FunctionFieldValues as F, type AutomationEntryAction as G, HttpClient as H, type AutomationBecomesTest as I, type AutomationWhere as J, type AutomationTrigger as K, type AutomationJson as L, type MatchRouteOptions as M, type AutomationRef as N, type AutomationValue as O, type AutomationInput as P, type QueryOf as Q, type Register as R, type SendOptions as S, type AutomationDuration as T, type AutomationItemRef as U, type AutomationLookupState as V, type Wire as W, type AutomationProposeTarget as X, type AutomationStep as Y, type AutomationDefinition as Z, type Ref as _, type RegisteredSchema as a, isExtensionsFile as a$, type Accepts as a0, type StepInput as a1, tpl as a2, and as a3, or as a4, not as a5, type AutomationTriggerHandle as a6, type RecordEvent as a7, type EntryEvent as a8, type TriggerWhere as a9, type LookedUpEntry as aA, type LookedUp as aB, type LookupOptions as aC, type AskStepConfig as aD, type AskOutput as aE, type ApproveStepConfig as aF, type ApproveCounts as aG, type ApproveOutput as aH, type StepBuilder as aI, type AutomationConfig as aJ, type AutomationFile as aK, defineAutomation as aL, isAutomationFile as aM, resolveAutomation as aN, type ExtensionUse as aO, type ExtensionsDeclaration as aP, type ExtensionSettings as aQ, type ExtensionsConfig as aR, type ExtensionTriggerHandle as aS, type HandleOf as aT, type ContributedFieldOptions as aU, type ContributedFieldKindBuilder as aV, type ExtensionHandle as aW, type ExtensionsFile as aX, type ClaimsOf as aY, defineExtensions as aZ, type ExtensionsFileData as a_, type UidRef as aa, type AutomationItemHandle as ab, type RecordTriggers as ac, type EntryTriggers as ad, records as ae, entries as af, type AnyEntryEvent as ag, type AnyEntryTriggers as ah, anyEntry as ai, schedule as aj, type RunFailedEvent as ak, type RunFailedWhere as al, automations as am, type ExtensionTriggerEvent as an, extensionTrigger as ao, on as ap, type AutomationAction as aq, type AutomationStepDraft as ar, type StepHandle as as, type StepWithOutput as at, type AgentStepConfig as au, type ProposingAgentStepConfig as av, type AutomationProposal as aw, type ProposingOutput as ax, type LookedUpRecord as ay, type LookedUpEntryItem as az, type ApiPath as b, extensionsDeclarationOf as b0, type FunctionRuntime as b1, type FunctionContainerSize as b2, type FunctionDuration as b3, type FunctionRouteMethod as b4, type FunctionNetworkHost as b5, type FunctionActionReach as b6, type FunctionActionHandle as b7, type FunctionSecretDeclaration as b8, type FunctionRoute as b9, type FunctionConfig as bA, type FunctionDefinition as bB, type FunctionInputOf as bC, type FunctionOutputOf as bD, defineFunction as bE, isFunctionDefinition as bF, type FunctionTool as ba, type FunctionSchedule as bb, type FunctionFieldDeclaration as bc, type FunctionDeclaration as bd, type FunctionRecordTypeName as be, type FunctionFile as bf, type FunctionCounterMove as bg, type FunctionRecordReader as bh, type FunctionRecordWriter as bi, type FunctionRecordBatch as bj, type FunctionBatchResult as bk, type FunctionBatchRefused as bl, isBatchRefused as bm, type FunctionRecords as bn, type FunctionWayIn as bo, type FunctionEndUsers as bp, type FunctionEndUserClaims as bq, type FunctionEndUser as br, type FunctionRunInfo as bs, type FunctionContent as bt, type FunctionActions as bu, type FunctionActionRefused as bv, isActionRefused as bw, type FunctionCapabilities as bx, type FunctionResponse as by, respond as bz, type ApiMethod as c, type ApiSuccessBody as d, type RouteMatch as e, type RetryPolicy as f, type RetryableRequest as g, RecordsClient as h, isReplaySafe as i, type RecordCallOptions as j, type RecordFacetBucket as k, type RecordFileBytes as l, matchRoute as m, type RecordFileUploadOptions as n, type RecordList as o, type RecordListOptions as p, type RecordMetadata as q, retryPolicyFor as r, type RecordReadOptions as s, type RecordUpdateOptions as t, refusedOperationOf as u, type RecordBatchOperation as v, type RecordBatchOperationResult as w, type RecordBatchOptions as x, type RecordBatchResult as y, type RecordBatchTarget as z };