@relyio/sdk 0.12.0 → 0.14.0

package/dist/index-DOhFQbv7.d.ts

@@ -0,0 +1,3065 @@
+import { c$ as paths, d0 as MergedRelyIOConfig, cS as ApiResponse, cR as RequestConfig, aM as EntryMetadata, cs as BaseContent, ap as Reading, al as CheckedIncludes, d1 as ReadWhere, cx as WhereClause, aq as ReadWith, cD as UpdateInput, at as UntypedReading, cB as RevisedContent, cA as CreateInput, cC as RestoredContent, cl as SDKError, cY as BaseValidationError, cX as ValidationViolation, b2 as AssetServedBlocks, d2 as CheckedInclude, d3 as components, cq as AssetFileBlock, ct as BaseSingleton, cu as BaseSettingsGroup, aN as InferContentType, an as ContentReading, aT as InferSingleton, cm as RelyIOConfig, b0 as InferAssetType, ak as AssetReading, as as SingletonReading, aY as InferSettingsGroup, ar as SettingsReading, cn as RelyIOConfigUpdate } from './define-content-type-DOrZb_a_.js';
+import { a as SchemaDefinition, b as SchemaContentTypeNames, j as SchemaEntryOf, f as SchemaLocaleCodes, c as SchemaSingletonNames, A as AggregateBlock, K as QueryParameterValue, F as FullTextSearch, e as SchemaQueryNames, J as InferQueryParams, L as AnyQueryParameters, h as SchemaAssetTypeNames, g as SchemaSettingsGroupNames } from './define-schema-5aHmsA8j.js';
+import { VisitorResyncReason } from './live-visitor.js';
+import { DevUnreadableReason } from './dev-handshake/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$1 = '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$1]: M extends keyof paths[P] ? paths[P][M] extends {
+        responses: unknown;
+    } ? M : never : never;
+}[Verb$1];
+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;
+
+/**
+ * Dev-mode detection for `relyio dev` sandboxes — the SDK's I/O shell over `../dev-handshake`.
+ *
+ * Every rule about the handshake — the path, the env names, the required fields, the deadline —
+ * lives in `@relyio/sdk/dev-handshake`, which `relyio dev` imports too. What is left here is the
+ * part that is genuinely the SDK's: reading env and walking the filesystem from the cwd, both of
+ * which have to happen without a static `node:*` import so the module stays browser-safe.
+ *
+ * Node access goes through `process.getBuiltinModule` (Node ≥ 20.16 / 22, and the platform targets
+ * Node 24), which is absent in browsers and edge runtimes — so the resolver is inert everywhere it
+ * should be, and a bundler never has to shim `fs`.
+ *
+ * **Order: env, then file.** The wrapped-child env is the primary carrier and wins. Before REL-647
+ * it won *unconditionally*, because it had no deadline to lose on; it now goes through the same
+ * rule the file does.
+ */
+
+/**
+ * What the handshake says about the sandbox, as the preview toolbar displays it
+ * (`sdk-surfaces-spec.md` decision 22). `TypedRelyIOClient.sandbox` returns it.
+ *
+ * **Plain data, on purpose.** In Next the toolbar is rendered from a server layout, and a client
+ * cannot cross the RSC boundary — while the browser cannot read the handshake at all, because this
+ * module is inert without `process.getBuiltinModule`. So the server-created client's `sandbox` is the
+ * prop the toolbar is handed, and it has to survive `JSON` unchanged: strings and `null`, dates as
+ * the ISO strings the handshake carried, no class instances.
+ *
+ * **No key.** The handshake also carries the sandbox's preview key; that is the client's credential,
+ * held beside this value in {@link DevResolution} and never inside it, so handing the state around
+ * does not hand the key with it.
+ *
+ * - `active` — the client targets the sandbox. `branchId` is `null` from the env carrier, which names
+ *   no branch; only `.relyio/dev.json` does. `expiresAt` is `null` for an unbounded sandbox.
+ * - `expired` / `unreadable` — a handshake was found and refused; the client targets the configured
+ *   dataset and key, and `mergeConfig` has said so on the console.
+ * - `absent` — no handshake on either carrier. This is also what a browser or edge runtime reads,
+ *   since neither can see the env or the file.
+ * - `disabled` — detection did not run: `dev: false` was passed, or `NODE_ENV === 'production'`
+ *   and `dev: true` was not.
+ */
+type SandboxState = {
+    state: 'active';
+    datasetId: string;
+    branchId: string | null;
+    expiresAt: string | null;
+    source: 'env' | 'file';
+} | {
+    state: 'expired';
+    expiredAt: string;
+} | {
+    state: 'unreadable';
+    reason: DevUnreadableReason;
+} | {
+    state: 'absent';
+} | {
+    state: 'disabled';
+};
+/** The sandbox the client targets, once a carrier has been accepted. */
+type ActiveSandbox = Extract<SandboxState, {
+    state: 'active';
+}>;
+
+/**
+ * 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`).
+ *
+ * The verb helpers below stay for the escape hatch `getHttpClient()` exposes;
+ * nothing inside the SDK uses them.
+ */
+declare class HttpClient {
+    /** What every request reads off the configuration, derived by {@link configure} and nowhere else. */
+    private 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.
+     */
+    private view?;
+    constructor(config: MergedRelyIOConfig);
+    /**
+     * 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).
+     */
+    withHeaders(headers: Readonly<Record<string, string>>): HttpClient;
+    /**
+     * 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 — `setDefaultHeaders()`, `setBaseUrl()` — is
+     * replaced by what `config` says.
+     */
+    configure(config: MergedRelyIOConfig): void;
+    private announce;
+    /**
+     * 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.
+     */
+    request<T = unknown>(config: RequestConfig): Promise<ApiResponse<T>>;
+    /**
+     * Make a GET request
+     */
+    get<T = unknown>(url: string, params?: Record<string, unknown>): Promise<ApiResponse<T>>;
+    /**
+     * Make a POST request
+     */
+    post<T = unknown>(url: string, data?: unknown, params?: Record<string, unknown>): Promise<ApiResponse<T>>;
+    /**
+     * Make a PUT request
+     */
+    put<T = unknown>(url: string, data?: unknown, params?: Record<string, unknown>): Promise<ApiResponse<T>>;
+    /**
+     * Make a DELETE request
+     */
+    delete<T = unknown>(url: string, params?: Record<string, unknown>): Promise<ApiResponse<T>>;
+    /**
+     * Make a PATCH request
+     */
+    patch<T = unknown>(url: string, data?: unknown, params?: Record<string, unknown>): Promise<ApiResponse<T>>;
+    /**
+     * Add headers to every later request, each replacing any header of the same name — the name
+     * matched without regard to case — until the client is next configured.
+     */
+    setDefaultHeaders(headers: Record<string, string>): 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 (`presentKey`): 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;
+    /**
+     * Get current default headers
+     */
+    getDefaultHeaders(): Record<string, string>;
+    /**
+     * Update base URL
+     */
+    setBaseUrl(baseUrl: string): void;
+    /**
+     * Get current base URL
+     */
+    getBaseUrl(): string;
+    /**
+     * 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;
+}
+
+/**
+ * API4's two request headers, as the SDK's writes send them.
+ *
+ * `Idempotency-Key` is an option on every write whose route declares it (`idempotencyKey`), and the
+ * SDK mints one when none is given. `If-Match` is never an option: a checked write builds it from
+ * the entry it was read as (`versionCheckOf`), from the `_metadata` every read carries in its body
+ * whether or not the edge cache served it (REL-2418). The SDK does not read the separate
+ * `X-Entity-Tag` header, which the edge removes from what it stores; the API keeps sending it for
+ * callers using plain HTTP (REL-2427). A batch operation carries its check in its own body, as
+ * `ifMatch` (`batch/batch-operations.ts`, REL-2421).
+ */
+interface RetryableWriteOptions {
+    /**
+     * A key that makes a retry of **this** write safe.
+     *
+     * A replay inside the service's window returns the original outcome rather
+     * than applying twice. The service derives that response from committed state
+     * pinned to the recorded version — it does not store bytes — so a replay after
+     * the version has been pruned is refused `RESOURCE_EXPIRED` rather than
+     * answered from a stale copy.
+     *
+     * **The SDK mints one when you do not.** It used to be caller-supplied and
+     * nothing else, which meant the default write carried no key while the retry
+     * loop replayed it anyway — the one mechanism that makes a replay safe was
+     * optional on the one path that needed it. Supply your own to make a key
+     * outlive the process: a job that may be restarted wants a key derived from
+     * the work, not one minted per call.
+     */
+    idempotencyKey?: string;
+}
+/**
+ * An entry a read handed back, as much of it as a version check needs: its `_metadata`'s id, the
+ * locale it was read in and the two counters it was read at (REL-2418).
+ *
+ * Every read carries these in its body, whether origin or the edge cache served it — the edge
+ * removes only the separate `X-Entity-Tag` header from what it stores, so a check taken from that
+ * header vanished after a cached read. A `Pick` of the document's `EntryMetadata`, so a counter the
+ * API stops reporting stops compiling here.
+ */
+interface ReadEntry {
+    readonly _metadata: Pick<EntryMetadata, 'id' | 'locale' | 'version' | 'sharedVersion'>;
+}
+/**
+ * The version check a write takes from the entry it was read as: the entry's id, the locale it was
+ * read in — which the write addresses, so a read negotiated from `Accept-Language` is written back
+ * to that locale — and the `If-Match` tag over its two counters, spelled as the API mints it.
+ */
+declare function versionCheckOf(entry: ReadEntry): {
+    id: string;
+    locale: string;
+    ifMatch: string;
+};
+
+/**
+ * The client's locale as a sub-client holds it: a function it asks on every call, or a locale fixed
+ * when it was built.
+ *
+ * `TypedRelyIOClient` hands every sub-client and builder a function over the configuration it holds,
+ * so one taken before `updateConfig({ locale })` sends the locale the client holds when the call is
+ * made, and none once `updateConfig({ locale: null })` has cleared it (REL-1453). A string is a locale
+ * fixed at construction — a handle built directly, as the tests build one — and stays what it was.
+ */
+type ClientLocale = string | (() => string | undefined);
+
+/**
+ * Two read terms every read that takes them writes the same way: the children an entry embeds,
+ * and the refusal of a condition on `_metadata`. Here once, for the list and entry reads
+ * (`read-options.ts`), the search family and the query call alike.
+ */
+
+/**
+ * Children population options: how deep, and how many per parent.
+ *
+ * The API expands an entry's children of **every** content type (`?children=true|1|2|3`); there is
+ * no filter by type. The option that used to name types was sent as `?children=<type>,<type>`,
+ * which the API parsed as no expansion at all, and `depth` was never sent (REL-1118).
+ */
+interface ChildrenOptions {
+    /** Levels of children to embed: 1 (the default) to 3 */
+    depth?: 1 | 2 | 3;
+    /** Maximum children per parent: 1 to 50, default 25 */
+    limit?: number;
+}
+
+/**
+ * The options a content type's reads take, and the one place each becomes the query its route
+ * declares (REL-2415, REL-2417; REL-2409 decisions Q3, Q5, Q6, Q9, Q10, Q11, Q12, Q14, Q15 and Q16).
+ *
+ * Every read takes **one options object**, with one name per concern. Each option that becomes a
+ * query term is typed from the query the committed document declares for its route (`QueryOf`,
+ * REL-687), and {@link listQuery} / {@link entryQuery} return that query type — so an option whose
+ * term the API stops reading stops compiling here, and a term the API does not read (`offset`,
+ * refused with a 400 on every list) cannot be offered. Two options are headers, which no route
+ * declares: `dataset` (`X-RelyIO-Dataset`) and `fresh: true` (`Cache-Control: no-cache`), written
+ * by {@link readHeaders}.
+ *
+ * `pageSize` is not offered: `limit` is the page size of a cursor read and of a page-number read
+ * alike (`listPageLimit` in `@relyio/content-db` reads `limit` first).
+ *
+ * `select` and `sort` are a list's alone: `GET /v1/{contentType}/{id}` declares neither `fields`
+ * nor `sort`, so `get` offers neither.
+ */
+
+/** One declared term's value, as the document types it. */
+type Term<P extends ApiPath, M extends ApiMethod<P>, K extends keyof QueryOf<P, M>> = QueryOf<P, M>[K];
+/**
+ * What `list` answers: the API's own `{ data, page }`, the page in the cursor dialect —
+ * `{ nextCursor, hasMore }` and no total, which the dialect cannot carry (Q10).
+ */
+type EntryList<E> = Wire<'/v1/{contentType}', 'get', E>;
+/**
+ * The Fields an entry of `T` declares, by key: what `select` picks and `sort` orders by. Any name
+ * where `T` declares none — a client no schema types — since the API alone knows which exist.
+ */
+type FieldKey<T> = [Exclude<keyof T, '_metadata'>] extends [never] ? string : Exclude<keyof T, '_metadata'> & string;
+/**
+ * The entry's own dates a list can be ordered by beside its Fields: the system keys the list route
+ * documents as indexed (`GetEntriesDto.sort`), which `@relyio/content-db` reads at the top level of
+ * the entry rather than under its fields.
+ */
+type SystemSortKey = 'createdAt' | 'updatedAt' | 'publishedAt' | 'firstPublishedAt';
+/**
+ * How a list is ordered: a direction per key, the **key order** the priority —
+ * `{ featured: 'desc', publishedAt: 'desc' }` orders by `featured` and breaks its ties by
+ * `publishedAt` (Q14). Each key is a Field `T` declares or a {@link SystemSortKey}.
+ */
+type SortOption<T> = {
+    readonly [K in FieldKey<T> | SystemSortKey]?: 'asc' | 'desc';
+};
+/**
+ * The locale codes a read of `R` may name: the codes the schema declares, or any where no schema
+ * types the read.
+ */
+type ReadLocale<R extends Reading> = R extends {
+    readonly locale: infer C extends string;
+} ? C : string;
+/**
+ * What `locale` takes (Q16): one code; a list of codes, the first answered at the top level and
+ * the others under `_metadata.localizations`; or `'*'`, every locale the entry has. Each code is
+ * one the schema declares.
+ */
+type LocaleOption<C extends string> = C | '*' | readonly [C, ...C[]];
+/**
+ * How fresh an answer must be:
+ *
+ * - a feed position (`'<cursor>'`, a change's `fresh`) — no answer older than that change, which the
+ *   edge still caches under that position (the sdk-surfaces spec's meaning). Live refetches use it;
+ * - `true` — past every cache, to origin, with `Cache-Control: no-cache`. For write flows, a re-read
+ *   after a conflict; never for live refetches, which would send every viewer to origin at once.
+ */
+type FreshOption = true | NonNullable<Term<'/v1/{contentType}', 'get', '_fresh'>>;
+/**
+ * The options every entry read takes, beside how a list pages and what it keeps.
+ *
+ * - `include` — the references to expand, each path checked against the type (REL-1801); the read's
+ *   type follows the paths.
+ * - `locale` — {@link LocaleOption}; replaces the client's locale for this read.
+ * - `dataset` — the dataset this one read is of, by id or name; the client's otherwise.
+ * - `fresh` — {@link FreshOption}.
+ * - `children` — each entry's children, of every content type, under `_children`: `true` for one
+ *   level, or a depth of 1 to 3 and at most `limit` per parent (REL-1118).
+ */
+interface EntryReadOptions<R extends Reading, P extends readonly string[], L extends LocaleOption<ReadLocale<R>> | undefined = undefined> {
+    /** Include paths: the references to expand into the entries they point at (REL-1801). */
+    readonly include?: CheckedIncludes<R, P>;
+    /** The locale, locales or `'*'` to read, over the client's locale (Q16). */
+    readonly locale?: L;
+    /** The dataset to read, by id or name, over the client's (Q9). */
+    readonly dataset?: string;
+    /** How fresh the answer must be: a feed position, or `true` for past every cache. */
+    readonly fresh?: FreshOption;
+    /** Embed each entry's children: `true`, or a depth and a per-parent limit (REL-1118). */
+    readonly children?: true | ChildrenOptions;
+}
+/** The options a list read takes beside how it pages: what it keeps, how, and how many a page holds. */
+interface ListReadOptions<T extends BaseContent, R extends Reading, P extends readonly string[], S extends readonly FieldKey<T>[] | undefined = undefined, L extends LocaleOption<ReadLocale<R>> | undefined = undefined> extends EntryReadOptions<R, P, L> {
+    /**
+     * The conditions an entry must meet, by the paths the API filters on (REL-2136). A condition on
+     * `_metadata` is refused before anything is sent.
+     */
+    readonly where?: ReadWhere<WhereClause<T>, R>;
+    /** How many entries a page holds, whether it is read by cursor or by number. */
+    readonly limit?: Term<'/v1/{contentType}', 'get', 'limit'>;
+    /**
+     * The entry's own Fields to return, beside `_metadata` and every Field an include path starts
+     * at (Q15). An expanded reference's Fields are picked in its include path:
+     * `include: ['author(name)']`.
+     */
+    readonly select?: S;
+    /** The order, by Field or system date, the key order the priority (Q14). */
+    readonly sort?: SortOption<T>;
+}
+/**
+ * Which page: the cursor a page handed back (`page.nextCursor`), or a page number (1-based) for an
+ * archive page like `/blog/page/3` — one or the other, never both (Q6).
+ */
+type Paging = {
+    readonly cursor?: Term<'/v1/{contentType}', 'get', 'cursor'>;
+    readonly page?: never;
+} | {
+    readonly page?: Term<'/v1/{contentType}', 'get', 'page'>;
+    readonly cursor?: never;
+};
+/** What `list(options)` takes. */
+type ListOptions<T extends BaseContent, R extends Reading, P extends readonly string[], S extends readonly FieldKey<T>[] | undefined = undefined, L extends LocaleOption<ReadLocale<R>> | undefined = undefined> = ListReadOptions<T, R, P, S, L> & Paging;
+/** What `listAll(options)` takes: a list's options, paged by the walk itself. */
+type ListAllOptions<T extends BaseContent, R extends Reading, P extends readonly string[], S extends readonly FieldKey<T>[] | undefined = undefined, L extends LocaleOption<ReadLocale<R>> | undefined = undefined> = ListReadOptions<T, R, P, S, L>;
+/** What `get(idOrSlug, options)` takes. */
+type GetOptions<R extends Reading, P extends readonly string[], L extends LocaleOption<ReadLocale<R>> | undefined = undefined> = EntryReadOptions<R, P, L>;
+/**
+ * What a one-document read takes — `singleton(key).get(options)` and `settings(group).get(options)`
+ * (REL-2419, REL-2409 decision Q18): a content read's options where their routes declare them.
+ *
+ * - `include`, `dataset` and `fresh` are a content read's.
+ * - `locale` is **one** declared code. Neither route declares `locales`: a singleton's or a group's
+ *   read composes one locale's fields and no `_metadata.localizations`, so a list or `'*'` would be
+ *   typed as an answer neither gives.
+ * - No `select`, `sort` or paging: neither route declares `fields`, `sort` or a page; no `children`:
+ *   neither declares it.
+ */
+interface DocumentReadOptions<R extends Reading, P extends readonly string[]> {
+    /** Include paths: the references to expand into the entries they point at (REL-1801). */
+    readonly include?: CheckedIncludes<R, P>;
+    /** The locale to read, over the client's locale. */
+    readonly locale?: ReadLocale<R>;
+    /** The dataset to read, by id or name, over the client's (Q9). */
+    readonly dataset?: string;
+    /** How fresh the answer must be: a feed position, or `true` for past every cache. */
+    readonly fresh?: FreshOption;
+}
+/**
+ * What `version()` takes on every handle (REL-2427): the version to read, and the locale whose
+ * timeline it is numbered in — versions are numbered per locale, so version 2 is different content
+ * in each one. `locale` defaults to the client's.
+ */
+interface VersionOptions {
+    readonly version: number;
+    readonly locale?: string;
+}
+/** The Field an include path starts at: `sections` for `sections.features(name)`. */
+type IncludeRoot<X extends string> = X extends `${infer Head}.${string}` ? PathName<Head> : PathName<X>;
+type PathName<X extends string> = X extends `${infer Name}(${string}` ? Name : X;
+/**
+ * `E` with only the Fields `select` named, `_metadata`, and each Field an include path starts at —
+ * which the API keeps in the projection, since an expanded reference needs its own Field. `E` when
+ * nothing is selected.
+ */
+type SelectedFields<E, S, I extends string> = S extends readonly [] | undefined ? E : S extends readonly string[] ? Pick<E, Extract<keyof E, S[number] | IncludeRoot<I> | '_metadata'>> : E;
+/**
+ * The fields of the other locales a list of codes or `'*'` asked for, keyed by code: a locale with
+ * no visible fields is left out, so each is optional.
+ */
+type Localizations<E, C extends string> = {
+    readonly [K in C]?: Partial<Omit<E, '_metadata'>>;
+};
+/**
+ * `E` as a read in `L` returns it. A list of codes or `'*'` adds `_metadata.localizations`, keyed by
+ * the codes it can hold; one code, or none, leaves `E` as it is.
+ */
+type Localized<E, L, C extends string> = L extends '*' | readonly string[] ? E extends {
+    readonly _metadata: infer M;
+} ? Omit<E, '_metadata'> & {
+    _metadata: Omit<M, 'localizations'> & {
+        localizations: Localizations<E, L extends readonly string[] ? L[number] : C>;
+    };
+} : E : E;
+/** What a read of `R` returns under its include paths `P`, selection `S` and locale `L`. */
+type ReadAs<R extends Reading, P extends readonly string[], S = undefined, L = undefined> = Localized<SelectedFields<ReadWith<R, P[number]>, S, P[number]>, L, ReadLocale<R>>;
+/**
+ * Where a read reads and how fresh it must be, as an implementation reads them whatever the type
+ * parameters checked: the clump every read takes — an entry read, a list, a one-document read, a
+ * search, an ad-hoc query and React's keyed reads alike. One declaration, because each surface
+ * restating it had already drifted (`fresh` was `true | string` in one, `FreshOption` in another).
+ * A read that takes one code (a search, a one-document read) narrows `locale` to `string`.
+ */
+interface WrittenReadScope {
+    readonly locale?: string | readonly string[];
+    readonly dataset?: string;
+    readonly fresh?: FreshOption;
+}
+/**
+ * A `sort` as an implementation reads it, whatever keys the type checked ({@link SortOption}): a
+ * direction per key, the key order the priority.
+ */
+type WrittenSort = Readonly<Record<string, 'asc' | 'desc' | undefined>>;
+
+/**
+ * The verbs every handle over the entry routes (`/v1/{type}`, `/v1/{type}/{id}`) shares — a content
+ * type's and an asset type's alike (REL-2419, REL-2409 decision Q18): `list`, `listAll`, `get`,
+ * `update` and `delete`, written once. An asset is an entry on the same routes, so a second copy of
+ * these per handle is what drifted before: the asset handle had none of the options, the not-found
+ * split or the check from the entry.
+ *
+ * What differs per handle is in the type parameters, not in a copy:
+ *
+ * - `Revised` — what an update answers;
+ * - `Placement` — what a write may place beside its data, as its route reads it: a content entry's
+ *   `slug`, `parentId` and `sortOrder`; an asset's `slug` alone, since the asset branch of
+ *   `PATCH /{type}/{id}` reads no other (`EntriesController.updateEntry`).
+ */
+declare abstract class EntryHandle<T extends BaseContent, R extends Reading, Revised, Placement extends object> {
+    protected readonly httpClient: HttpClient;
+    protected readonly typeName: string;
+    /** The client's locale, asked on every call rather than copied when this handle was taken. */
+    protected readonly clientLocale: () => string | undefined;
+    /**
+     * @param typeName - The content or asset type the routes are addressed by
+     * @param locale - The client's locale: the function `TypedRelyIOClient` hands over, asked on
+     *   every call
+     */
+    constructor(httpClient: HttpClient, typeName: string, locale?: ClientLocale);
+    /**
+     * One page of this type's entries: the API's own `{ data, page }`, as it answered (REL-2415).
+     *
+     * Page by `cursor` — the `page.nextCursor` a page handed back — to walk, or by `page` number for an
+     * archive page like `/blog/page/3`; `limit` is the page size for both. The page is the cursor
+     * dialect's `{ nextCursor, hasMore }`: a list carries no total.
+     *
+     * The rest of the options have one name per concern (REL-2417): `select` the entry's own Fields,
+     * `sort` an order whose key order is the priority, `locale` a code, a list of codes or `'*'`,
+     * `dataset` this read's dataset, `fresh` how fresh the answer must be, `children` the children to
+     * embed. See `ListReadOptions`.
+     *
+     * @example
+     * ```typescript
+     * const { data, page } = await relyio.content('post').list({
+     *   where: { category: 'news' },
+     *   include: ['author'],
+     *   select: ['title', 'slug'],
+     *   sort: { featured: 'desc', publishedAt: 'desc' },
+     *   limit: 10,
+     *   page: 3,
+     * })
+     * ```
+     */
+    list<const P extends readonly string[] = [], const S extends readonly FieldKey<T>[] | undefined = undefined, const L extends LocaleOption<ReadLocale<R>> | undefined = undefined>(options?: ListOptions<T, R, P, S, L>): Promise<EntryList<ReadAs<R, P, S, L>>>;
+    /**
+     * Every entry of this type that `where` keeps, page after page, as an async iterable: the walk
+     * follows each page's cursor and stops where the API says there is no more (REL-2415).
+     * `Array.fromAsync(relyio.content('post').listAll())` makes it an array. `limit` is how many each
+     * request reads; every other option is a list's, sent with each page.
+     *
+     * Iterating throws when a page says there is more and hands back no cursor to read it by, rather
+     * than ending the walk short.
+     */
+    listAll<const P extends readonly string[] = [], const S extends readonly FieldKey<T>[] | undefined = undefined, const L extends LocaleOption<ReadLocale<R>> | undefined = undefined>(options?: ListAllOptions<T, R, P, S, L>): AsyncIterable<ReadAs<R, P, S, L>>;
+    private walk;
+    /**
+     * One entry by its id or slug, or `null` when there is no such entry (REL-2415).
+     *
+     * `null` only for a missing **entry**: a type the schema does not declare, or a dataset with no
+     * schema deployed, throws `ResourceNotFoundError` naming which (`context.resourceType`), so an
+     * undeployed type never reads as a missing page.
+     *
+     * It takes the options of a list that are not about which entries or in what order — `include`,
+     * `locale`, `dataset`, `fresh`, `children` (REL-2417). The route declares no `fields`, so there is
+     * no `select`.
+     *
+     * @example
+     * ```typescript
+     * const post = await relyio.content('post').get('hello-world', { include: ['author'] })
+     * if (post === null) return notFound()
+     * ```
+     */
+    get<const P extends readonly string[] = [], const L extends LocaleOption<ReadLocale<R>> | undefined = undefined>(idOrSlug: string, options?: GetOptions<R, P, L>): Promise<ReadAs<R, P, undefined, L> | null>;
+    /**
+     * Update an entry you read, checked against the version it was read at (REL-2418).
+     *
+     * The check comes from the entry's own `_metadata`, which every read carries whether or not the
+     * cache served it, and the write addresses the locale the entry was read in — so a read whose
+     * locale came from the browser's language is written back to that locale. If the entry changed
+     * since the read, the write is refused with `ResourceConflictError` naming the version you
+     * read and the version it holds now: re-read it with `fresh: true` and retry. The SDK does not
+     * retry on its own.
+     *
+     * Pass an id instead to write **unchecked**, on purpose — an import that holds only ids stays one
+     * request per row.
+     *
+     * @example
+     * ```typescript
+     * const post = await relyio.content('post').get('hello-world')
+     * if (post) await relyio.content('post').update(post, { title: 'Hello, world' })
+     * ```
+     */
+    update(entry: ReadEntry, data: UpdateInput<T>, options?: Placement & RetryableWriteOptions): Promise<Revised>;
+    /**
+     * Update an entry by id, with no version check (partial update), on purpose: an import that holds
+     * only ids stays one request per row. `locale` defaults to the client's own.
+     */
+    update(id: string, data: UpdateInput<T>, options?: Placement & {
+        locale?: string;
+    } & RetryableWriteOptions): Promise<Revised>;
+    /**
+     * Delete an entry you read, checked against the version it was read at, as {@link update} is:
+     * an entry changed since the read is refused with `ResourceConflictError` and stays.
+     */
+    delete(entry: ReadEntry, options?: RetryableWriteOptions): Promise<void>;
+    /** Delete an entry by id, with no version check. */
+    delete(id: string, options?: RetryableWriteOptions): Promise<void>;
+}
+
+/** What a content entry's write places beside its data, as `PATCH /{contentType}/{id}` reads it. */
+interface EntryPlacement {
+    slug?: string;
+    parentId?: string;
+    sortOrder?: number;
+}
+/**
+ * What a checked write takes beside the entry it was read as (REL-2418). No `locale` and no
+ * `ifMatch`: the entry names both, and a second source for either is how a check was dropped.
+ */
+interface EntryWriteOptions extends EntryPlacement, RetryableWriteOptions {
+}
+/** What `create(data, options)` takes beside the data. */
+interface CreateEntryOptions extends EntryPlacement, RetryableWriteOptions {
+    /** The locale the entry is created in; the client's own when left out. */
+    locale?: string;
+    /** The dataset to write, by id or name, over the client's. */
+    dataset?: string;
+}
+/**
+ * One content type's entries: read with `list`, `listAll` and `get`, written with `create`,
+ * `update` and `delete` (each from {@link EntryHandle}), and their history and children beside.
+ *
+ * @example
+ * ```typescript
+ * const products = client.content('product')
+ *
+ * // One page, one options object
+ * const { data: active, page } = await products.list({
+ *   where: { status: 'active' },
+ *   locale: 'en',
+ *   include: ['brand'],
+ *   limit: 20,
+ * })
+ *
+ * // Every entry, page after page
+ * for await (const product of products.listAll()) console.log(product.title)
+ * ```
+ */
+declare class ContentClient<T extends BaseContent = BaseContent, R extends Reading = UntypedReading<T>> extends EntryHandle<T, R, RevisedContent<T>, EntryPlacement> {
+    /**
+     * Create a new content entry.
+     *
+     * `locale` defaults to the client's own, and `dataset` to the client's (`client.with({ dataset })`
+     * sets it for every call).
+     *
+     * @example
+     * ```typescript
+     * const post = await relyio.content('post').create({ title: 'Hello' }, { slug: 'hello' })
+     * ```
+     */
+    create(data: CreateInput<T>, options?: CreateEntryOptions): Promise<T>;
+    /**
+     * Get version history for one locale of an entry.
+     *
+     * Versions are numbered per locale, so this is one locale's timeline: `locale` defaults to the
+     * client's own, else the schema default; no fallback is applied, and a locale
+     * with no history returns an empty array rather than another locale's rows. Every row names the
+     * locale it belongs to.
+     */
+    versions(id: string, options?: {
+        limit?: number;
+        locale?: string;
+    }): Promise<Array<T & {
+        versionNumber: number;
+        locale: string;
+    }>>;
+    /**
+     * One version of an entry: `version(id, { version, locale })`.
+     *
+     * `locale` defaults to the client's own, else the schema default. Version numbers are per locale,
+     * so version 2 is different content in each one.
+     *
+     * There is no `null`: a version the locale does not have, an entry that is not there, a type the
+     * schema does not declare and a dataset with no schema all throw `ResourceNotFoundError`, its
+     * `context.resourceType` naming which (REL-2409 Q12).
+     */
+    version(id: string, options: VersionOptions): Promise<T>;
+    /**
+     * Revert one locale of an entry you read to a previous version: `restore(entry, { version })`,
+     * checked against the version the entry carries, in the locale it was read in — as
+     * `update(entry, data)` is. An entry changed since the read is refused with
+     * `ResourceConflictError`: re-read it with `fresh: true` and retry.
+     *
+     * Only that locale's fields change — shared fields and every other locale are left untouched. The
+     * restore is validated as strictly as a publish, so it cannot publish invalid content, and it
+     * records a new version of its own rather than rewinding the counter — so the revert is auditable
+     * and itself reversible.
+     *
+     * @returns The entry, its `_metadata.leftOut` naming each value of the version the active schema
+     *   no longer declares, and `_metadata.brokenLinks` the entry links it left pointing nowhere.
+     */
+    restore(entry: ReadEntry, options: {
+        version: number;
+    } & RetryableWriteOptions): Promise<RestoredContent<T>>;
+    /**
+     * Revert one locale of an entry by id, with no version check: `restore(id, { version, locale })`.
+     *
+     * `locale` is **required**, and that is not a convention: versions are numbered per locale, so
+     * `version` alone is ambiguous, and defaulting it would silently revert the wrong translation.
+     */
+    restore(id: string, options: {
+        version: number;
+        locale: string;
+    } & RetryableWriteOptions): Promise<RestoredContent<T>>;
+    /**
+     * The direct children of a hierarchical entry, each read as `get` reads an entry.
+     *
+     * It takes `get`'s options — `include` (checked against the type), `locale` (a code, a list or
+     * `'*'`), `dataset`, `fresh` and `children` — the terms its route declares as the entry route
+     * does, sent the same way. The route lists one level and takes no depth (REL-2195); a tree nested
+     * under each child is the `children` option.
+     *
+     * @param id - Parent entry ID
+     */
+    children<const P extends readonly string[] = [], const L extends LocaleOption<ReadLocale<R>> | undefined = undefined>(id: string, options?: GetOptions<R, P, L>): Promise<Array<ReadAs<R, P, undefined, L>>>;
+}
+
+/**
+ * Upload/processing error taxonomy (plan 17, 00b Step 4).
+ *
+ * A **thin customer-side mirror** of the live-contracts `FileErrorCode`
+ * (correction C6 — the SDK must not import the server/Studio contracts package).
+ * Keep the members in sync with `@relyio/live-contracts`.
+ *
+ * Written once, as values, because a processing failure's code arrives as a string the service
+ * stored and has to be recognised at runtime; `FileErrorCode` is read off this list. The module is
+ * internal — `errors/index.ts` does not re-export it — so the list is not a second public name for
+ * the type.
+ */
+declare const FILE_ERROR_CODES: readonly ["UPLOAD_TOO_LARGE", "UNSUPPORTED_MIME", "DIMENSION_OUT_OF_RANGE", "ASPECT_RATIO", "CORRUPT_FILE", "UNSUPPORTED_CODEC", "IMAGES_LIMIT_EXCEEDED", "STREAM_ENCODE_FAILED", "SCAN_INFECTED", "INTERNAL"];
+
+/**
+ * Upload/processing error taxonomy (plan 17, 00b Step 4): a customer-side mirror of the
+ * live-contracts `FileErrorCode`, read off the list in `./file-error-codes`.
+ */
+type FileErrorCode = (typeof FILE_ERROR_CODES)[number];
+/**
+ * The code a {@link FileUploadError} carries: a {@link FileErrorCode}, or `PROCESSING_FAILED` for a
+ * processing failure this SDK cannot name — the service stored no code, as an image or file
+ * processing failure is stored today, or one this version of the SDK predates. What the service
+ * stored is in the error's `context.processingError` either way.
+ */
+type FileUploadErrorCode = FileErrorCode | 'PROCESSING_FAILED';
+/**
+ * A failure during the upload protocol (presign / PUT / multipart / confirm) or
+ * surfaced by the server's processing pipeline. Carries a typed {@link FileUploadErrorCode}
+ * and a `retriable` hint so callers (and `upload()`'s bounded auto-retry) can
+ * decide whether to retry on the same entry.
+ */
+declare class FileUploadError extends SDKError {
+    readonly code: FileUploadErrorCode;
+    readonly retryable: boolean;
+    constructor(code: FileUploadErrorCode, message: string, options?: {
+        retriable?: boolean;
+        statusCode?: number;
+        cause?: Error;
+        context?: Record<string, unknown>;
+    });
+    getUserMessage(): string;
+}
+/**
+ * Client-side file validation failure (MIME/size/etc.) raised **before** any
+ * bytes leave the machine (UX only — the server presign stays authoritative).
+ */
+declare class FileValidationError extends BaseValidationError {
+    readonly code = "FILE_VALIDATION_ERROR";
+    constructor(message: string, violations?: ValidationViolation[], cause?: Error);
+    getUserMessage(): string;
+}
+/** Constraints `validateFile` checks a file against (subset of the schema upload gate). */
+interface FileValidationConstraints {
+    /** Allowed MIME types (exact match). */
+    allowedMimeTypes?: string[];
+    /** Max size in bytes. */
+    maxSizeBytes?: number;
+}
+/**
+ * Validate a file against explicit constraints, returning typed violations.
+ *
+ * The customer SDK does not carry a `SchemaReader` (that lives in the Studio
+ * layer), so callers pass the constraints they want enforced client-side; the
+ * server presign remains the authority. Returns an empty array when valid.
+ */
+declare function validateFile(file: {
+    type?: string;
+    size?: number;
+}, constraints?: FileValidationConstraints): ValidationViolation[];
+
+/** Delivery visibility for a file binding (gateway-enforced, no byte relocation). */
+type AssetVisibility = 'public' | 'protected' | 'private';
+/** Binary lifecycle status — independent of the entry's publishing status. */
+type FileStatus = 'pending_upload' | 'uploading' | 'processing' | 'ready' | 'failed';
+/** Storage backend: `r2` = image + file kinds, `stream` = video kind. */
+type FileBackend = 'r2' | 'stream';
+/** Extracted media metadata (Phase 1 basics + Phase 2 enrichment, plans 15–19); open-ended. */
+type AssetFileExtracted = NonNullable<AssetFileBlock['extracted']>;
+/**
+ * Where one file binding's upload got to, as {@link AssetFileBuilder.status} reads it
+ * (`GET /v1/{assetType}/{id}/file`): the document's `FileStatus` — the binding's lifecycle and
+ * nothing of the entry's content. `processing.error` is present exactly while `status` is `failed`.
+ */
+type FileStatusResult = components['schemas']['FileStatus'];
+
+/**
+ * An asset entry response: schema fields at the top level plus the reserved
+ * `file` + `urls` blocks and `_metadata`. `T` carries the inferred field shape — for a typed client
+ * `InferAssetType`, so this is `InferAssetEntry`, the shape an expanded asset reads as too.
+ */
+type AssetEntryResponse<T extends BaseContent = BaseContent> = T & AssetServedBlocks;
+/** Request a single upload target for the binding. */
+interface PresignInput {
+    /** Original file name (required). */
+    fileName: string;
+    /** MIME type the client will upload with. */
+    contentType?: string;
+    /** File size in bytes (early upload-gate validation). */
+    size?: number;
+    /** Locale to target for file-localized asset types. */
+    locale?: string;
+    /** Advisory client-computed SHA-256 (duplicate detection). */
+    hash?: string;
+}
+/** Single upload target returned by `presign`. */
+interface PresignResult {
+    backend: FileBackend;
+    /** `put` = single PUT / Stream POST; `multipart` = resumable R2 session (plan 17). */
+    mode?: 'put' | 'multipart';
+    /** R2 presigned PUT (image/file) or Stream direct-creator URL (video). */
+    uploadUrl?: string;
+    method: 'PUT' | 'POST';
+    headers?: Record<string, string>;
+    /** Object key for the binding — present for R2 (needed to drive multipart). */
+    objectKey?: string;
+    storageVersion?: number;
+    /** Multipart upload id — present only for `mode: 'multipart'`. */
+    uploadId?: string;
+    /** Multipart part size in bytes — present only for `mode: 'multipart'`. */
+    partSize?: number;
+    expiresAt: string;
+    locale?: string;
+}
+/** Result of opening a multipart session (`file(uid).createMultipart()`). */
+interface MultipartCreateResult {
+    uploadId: string;
+    objectKey: string;
+    partSize: number;
+    storageVersion: number;
+    locale?: string;
+}
+/** A single uploaded part (`{ PartNumber, ETag }` ordering for `complete`). */
+interface MultipartPart {
+    partNumber: number;
+    etag: string;
+    size?: number;
+}
+/** Target a multipart session in subsequent ops. */
+interface MultipartTarget {
+    uploadId: string;
+    objectKey: string;
+    locale?: string;
+}
+/** Upload progress tick handed to `.onProgress()`. */
+interface UploadProgress {
+    /** `upload` for client → storage bytes. */
+    phase: 'upload';
+    /** Bytes transferred so far. */
+    loaded: number;
+    /** Total bytes (when known). */
+    total: number;
+    /** 0–100 integer. */
+    progress: number;
+}
+/** Acknowledge a completed client upload. */
+interface ConfirmInput {
+    locale?: string;
+    hash?: string;
+}
+/** Result of `confirm`. */
+interface ConfirmResult {
+    accepted: boolean;
+}
+/** Resolve a single gateway delivery URL. */
+interface ResolveUrlInput {
+    locale?: string;
+    /** Named image variant id. */
+    variantId?: string;
+    /** Video delivery target. */
+    purpose?: 'playback' | 'poster' | 'download';
+}
+/** Result of `url`. `expiresAt` is omitted for `public` bindings. */
+interface ResolveUrlResult {
+    url: string;
+    expiresAt?: string;
+}
+/** Options when creating an asset entry. */
+interface CreateAssetOptions {
+    slug?: string;
+    locale?: string;
+    /** Original file name (also settable at presign). */
+    fileName?: string;
+    /** Initial delivery visibility (default `public`). */
+    visibility?: AssetVisibility;
+    /** Auto-publish the entry when the file becomes ready (default `true`). */
+    publish?: boolean;
+}
+/**
+ * What an asset's write places beside its data: its `slug` alone, the one the asset branch of
+ * `PATCH /{assetType}/{id}` reads (`EntriesController.updateEntry`) — a `parentId` or `sortOrder`
+ * would be dropped there, so neither is offered.
+ */
+interface AssetPlacement {
+    slug?: string;
+}
+/** Options for {@link AssetClient.update} by id: its placement, its locale and a retry key. */
+type UpdateAssetOptions = AssetPlacement & {
+    locale?: string;
+} & RetryableWriteOptions;
+/** Options for {@link AssetFileBuilder.waitUntilReady}. */
+interface WaitUntilReadyOptions {
+    /** Locale of the binding to watch. */
+    locale?: string;
+    /**
+     * Total time to wait before giving up (ms), from 0 to 2147483647. Default 60000. `0` reads the
+     * file once and rejects with a `TimeoutError` if it is not ready.
+     */
+    timeoutMs?: number;
+    /** Delay between polls (ms), from 1 to 2147483647. Default 1500. */
+    pollIntervalMs?: number;
+}
+/**
+ * Operations on a single asset entry's file binding, backed by the
+ * `/{assetType}/{entryUid}/file/*` routes (plan 06 §2).
+ */
+declare class AssetFileBuilder<T extends BaseContent = BaseContent> {
+    private readonly httpClient;
+    private readonly assetType;
+    private readonly entryUid;
+    /** The client's locale, asked on every call rather than copied when this builder was taken. */
+    private readonly clientLocale;
+    /**
+     * @param locale - The client's locale, sent when a call names none: the function
+     *   `TypedRelyIOClient` hands over, or a locale fixed for this builder
+     */
+    constructor(httpClient: HttpClient, assetType: string, entryUid: string, locale?: ClientLocale);
+    /**
+     * The path parameters every `/file/*` route on this builder takes.
+     *
+     * The path *template* is the document's; only these two values are the
+     * builder's, so a route that gains or loses a segment is a compile error here
+     * rather than a hand-built string that silently misses.
+     */
+    private get target();
+    private localeOf;
+    /**
+     * The `locale` body field of a multipart call: the session's, else the client's. The API finds
+     * the binding by it, so a session a `with({ locale })` client opened must name the same locale on
+     * every later call or its `objectKey` is refused as another binding's.
+     */
+    private localeField;
+    /**
+     * Issue a single upload target — an R2 presigned PUT (image/file) or a
+     * Cloudflare Stream direct-creator URL (video). Resumable multipart is plan 17.
+     */
+    presign(input: PresignInput): Promise<PresignResult>;
+    /**
+     * Acknowledge a completed client upload (kicks off the fast-path intake for
+     * R2; a no-op for Stream, whose readiness is webhook-driven).
+     */
+    confirm(input?: ConfirmInput): Promise<ConfirmResult>;
+    /** Open an R2 multipart session for a large file (standalone of `presign`). */
+    createMultipart(input: PresignInput): Promise<MultipartCreateResult>;
+    /** Presign a single part PUT (1-based `partNumber`). */
+    signPart(target: MultipartTarget & {
+        partNumber: number;
+    }): Promise<{
+        url: string;
+    }>;
+    /** List parts already uploaded (cross-session resume). */
+    listParts(target: MultipartTarget): Promise<MultipartPart[]>;
+    /** Finalize a multipart session. */
+    completeMultipart(target: MultipartTarget & {
+        parts: MultipartPart[];
+    }): Promise<{
+        ok: boolean;
+        etag?: string;
+    }>;
+    /** Abort a multipart session, freeing staged parts. */
+    abortMultipart(target: MultipartTarget): Promise<{
+        aborted: boolean;
+    }>;
+    /**
+     * Resolve a single gateway delivery URL for the requested locale/variant/purpose.
+     * Throws if the binding is not `ready`.
+     */
+    url(input?: ResolveUrlInput): Promise<ResolveUrlResult>;
+    /**
+     * Read where this file's upload got to — `status`, and the processing stage, progress and error
+     * the pipeline recorded — whatever the asset entry is published in.
+     *
+     * An asset is a draft until its file is ready, and stays one when its file fails, so a key that
+     * reads published content finds no entry for an upload in flight or one that failed. This read
+     * answers for the binding itself. It takes the capability the upload calls take, so a read-only
+     * key is refused with `ReadOnlyKeyError`, and it never returns the entry's fields.
+     */
+    status(options?: {
+        locale?: string;
+    }): Promise<FileStatusResult>;
+    /**
+     * Update the binding's delivery visibility (token-based; no byte relocation —
+     * a downgrade purges the gateway cache). Returns the refreshed asset entry.
+     */
+    updateVisibility(visibility: AssetVisibility, options?: {
+        locale?: string;
+    }): Promise<AssetEntryResponse<T>>;
+    /**
+     * Set the binding's normalized (0..1, origin top-left) smart-crop focal point
+     * (plan 18) so `cover`/`crop` variants frame the subject. Per locale for
+     * file-localized asset types; token-based (no byte change). Returns the
+     * refreshed asset entry.
+     */
+    setFocalPoint(focalPoint: {
+        x: number;
+        y: number;
+    }, options?: {
+        locale?: string;
+    }): Promise<AssetEntryResponse<T>>;
+    /**
+     * Remove the file binding, clean up the underlying bytes, and purge the
+     * gateway cache. The asset entry itself is preserved.
+     */
+    delete(options?: {
+        locale?: string;
+    }): Promise<void>;
+    /**
+     * Poll the asset entry until its file binding reaches `ready`, and resolve with the ready entry.
+     *
+     * Each poll reads the entry through the key's lens. When that finds nothing — a key that reads
+     * published content, and an asset that is a draft until its file is ready and stays one when it
+     * fails — the poll reads the binding itself ({@link status}), so a failed upload rejects as one
+     * rather than running out the limit (REL-1481).
+     *
+     * @throws {FileUploadError} When processing failed. `code` is the processing code the service
+     *   stored — `UNSUPPORTED_CODEC`, `CORRUPT_FILE` and so on — or `PROCESSING_FAILED` where it
+     *   stored none this SDK knows; `context.processingError` holds what it stored, and `retryable`
+     *   is its `retriable` hint.
+     * @throws {TimeoutError} When `timeoutMs` passes first. The file may still become ready; the
+     *   error's `context.timeout` is the limit and `context.fileStatus` the status last seen. A file
+     *   that is `ready` in an asset the key's lens never shows — created with `publish: false`, or
+     *   awaiting a workflow — ends here too, and the message says so.
+     * @throws {ReadOnlyKeyError} When the key's lens does not show the asset and the key may not read
+     *   its binding either: nothing it can read would ever report the file.
+     */
+    /** The asset entry through the key's lens, or `null` where that lens finds none. */
+    private readEntry;
+    waitUntilReady(options?: WaitUntilReadyOptions): Promise<AssetEntryResponse<T>>;
+}
+/**
+ * High-level one-shot upload: create draft entry → presign → PUT bytes →
+ * confirm → (optionally) wait for `ready`. Handles the common image/file flow
+ * (single R2 PUT). For advanced/resumable flows (large files, video tus,
+ * progress) use the lower-level `file(uid)` builder — full upload resilience is
+ * plan 17.
+ */
+declare class AssetUploadBuilder<T extends BaseContent = BaseContent> {
+    private readonly httpClient;
+    private readonly assetType;
+    private readonly file;
+    private _fileName?;
+    private _visibility?;
+    private _locale?;
+    private _publish?;
+    private _content;
+    private _slug?;
+    private _waitForReady;
+    private _waitOptions;
+    private _onProgress?;
+    private _validate?;
+    private _maxPartRetries;
+    /** The client's locale, read once when the upload starts. */
+    private readonly clientLocale;
+    /**
+     * @param locale - The client's locale, the upload's when `.locale()` names none: the function
+     *   `TypedRelyIOClient` hands over, or a locale fixed for this upload
+     */
+    constructor(httpClient: HttpClient, assetType: string, file: Blob, locale?: ClientLocale);
+    /** Subscribe to client → storage upload progress (single PUT + multipart). */
+    onProgress(callback: (_progress: UploadProgress) => void): this;
+    /**
+     * Validate the file client-side (UX only) against explicit constraints before
+     * any bytes leave the machine. Rejects instantly with a {@link FileValidationError}.
+     */
+    validate(constraints: FileValidationConstraints): this;
+    /** Bounded per-part retry attempts for multipart (default 3). */
+    maxPartRetries(attempts: number): this;
+    /** Set the original file name (defaults to `file.name` for `File` inputs). */
+    filename(name: string): this;
+    /** Set the initial delivery visibility (default `public`). */
+    visibility(visibility: AssetVisibility): this;
+    /** Target locale for file-localized asset types. */
+    locale(locale: string): this;
+    /** Suppress (or enable) auto-publish on ready. */
+    publish(publish: boolean): this;
+    /** Set the asset's metadata field values (e.g. `{ alt: '...' }`). */
+    content(content: Record<string, unknown>): this;
+    /** Set an explicit slug for the new entry. */
+    slug(slug: string): this;
+    /**
+     * Wait until the file binding becomes `ready` before resolving.
+     *
+     * @throws {Error} When `timeoutMs` or `pollIntervalMs` is one the wait cannot honour — refused
+     *   here, before anything is uploaded, rather than after the bytes are in.
+     */
+    waitForReady(options?: boolean | Omit<WaitUntilReadyOptions, 'locale'>): this;
+    /** Execute the full upload flow and resolve with the asset entry. */
+    execute(): Promise<AssetEntryResponse<T>>;
+    /** Single presigned PUT (≤ 50 MB / Stream POST). */
+    private uploadSingle;
+    /**
+     * Resumable R2 multipart: slice into `partSize` chunks, skip already-uploaded
+     * parts (resume via `list-parts`), PUT each remaining part with bounded retry,
+     * then `complete`. Aborts the session on unrecoverable failure.
+     */
+    private uploadMultipart;
+    /** PUT a single part, retrying transient failures up to `_maxPartRetries`. */
+    private putPartWithRetry;
+    private emitProgress;
+}
+/**
+ * An asset read typed by the asset type's reading `R`: what the type's include paths make of its
+ * fields, beside the `file` and `urls` blocks every asset read carries (REL-1801).
+ */
+interface AssetResponseReading<R extends Reading, T extends BaseContent = BaseContent> extends Reading {
+    readonly read: AssetEntryResponse<Extract<ReadWith<R, this['include']>, BaseContent>>;
+    readonly checked: CheckedInclude<R, this['path']>;
+    /**
+     * The asset type's own `where` — every path the API filters its fields by, never the `file` and
+     * `urls` blocks — or, where no schema types it, the conditions `T`'s keys take (REL-2195).
+     */
+    readonly where: ReadWhere<WhereClause<T>, R>;
+    /** The locale codes its `locale` may name: the asset type's reading's. */
+    readonly locale: ReadLocale<R>;
+}
+/**
+ * One asset type's entries: `list`, `listAll`, `get`, `update` and `delete` as a content type's
+ * handle has them (assets are `entryType: 'asset'` entries on the same `/{assetType}` routes), plus
+ * `create`, the `file(uid)` sub-resource builder and an `upload()` helper.
+ */
+declare class AssetClient<T extends BaseContent = BaseContent, R extends Reading = UntypedReading<T>> extends EntryHandle<T, AssetResponseReading<R, T>, AssetEntryResponse<T>, AssetPlacement> {
+    /**
+     * Create a new asset entry as a draft. The binary is uploaded separately via
+     * `file(uid)` (or use the high-level `upload()` helper), and the entry
+     * auto-publishes when its file becomes ready (unless `publish: false`).
+     * `locale` defaults to the client's own.
+     */
+    create(data: CreateInput<T>, options?: CreateAssetOptions & RetryableWriteOptions): Promise<AssetEntryResponse<T>>;
+    /** Get the file sub-resource builder for a specific asset entry. */
+    file(entryUid: string): AssetFileBuilder<T>;
+    /** Start a high-level upload (create → presign → PUT → confirm). */
+    upload(file: Blob): AssetUploadBuilder<T>;
+}
+/**
+ * Narrow an entry (e.g. a populated reference from `include`) to an asset entry.
+ * Relies on the `_metadata.entryType` discriminator the API emits (plan 06).
+ *
+ * @example
+ * ```typescript
+ * const article = await relyio.content('article').get(id, { include: ['hero'] })
+ * if (isAssetEntry(article?.hero)) {
+ *   console.log(article.hero.urls?.original)
+ * }
+ * ```
+ */
+declare function isAssetEntry<T extends BaseContent = BaseContent>(entry: unknown): entry is AssetEntryResponse<T>;
+/**
+ * A reference field populated (via `include`) with a full asset entry. Identical
+ * to {@link AssetEntryResponse}; named for readability at reference call sites.
+ */
+type PopulatedAssetReference<T extends BaseContent = BaseContent> = AssetEntryResponse<T>;
+
+/**
+ * What a one-document write sends: the data, the locale it writes (absent: the API's default) and
+ * the `If-Match` check of a read, when it is one.
+ */
+interface DocumentWrite<T> {
+    readonly content: DocumentFields<T>;
+    readonly locale: string | undefined;
+    readonly ifMatch: string | undefined;
+}
+/**
+ * A document's fields as a write sends them: any of them, and no `_metadata` — the read that
+ * carries one is the checked form's first argument, never the data.
+ */
+type DocumentFields<T> = Partial<Omit<T, '_metadata'>> & {
+    readonly _metadata?: never;
+};
+/** What an unchecked one-document write takes beside its data: the locale it writes, and its key. */
+interface DocumentWriteOptions extends RetryableWriteOptions {
+    /** The locale to write; the client's own when left out. */
+    readonly locale?: string;
+}
+/** What `versions(options)` takes on a one-document handle. */
+interface DocumentVersionsOptions {
+    /** How many versions to list, newest first; 10 when left out. */
+    readonly limit?: number;
+    /** The locale whose timeline it is; the client's own, then the schema default, when left out. */
+    readonly locale?: string;
+}
+/** One row of a one-document handle's history: the document as it was, in the locale it names. */
+type DocumentVersion<T> = T & {
+    versionNumber: number;
+    locale: string;
+};
+/**
+ * The verbs a singleton's and a settings group's handle share (REL-2419, REL-2409 decision Q18):
+ * `update`, `versions` and `version`, written once, as {@link EntryHandle} writes the entry routes'
+ * once for a content type and an asset type. The two were near-clones that had already drifted —
+ * in which locale they treated as none, and in what `version()` answered for a missing document.
+ *
+ * What differs per handle is its route, so each names its own four requests; every rule about
+ * them — which locale a call sends, which form of a write is checked, what a missing version is —
+ * is here.
+ *
+ * Every call is in the locale it names, and otherwise in the client's own as it is when the call is
+ * made; a write of a document you read writes the locale it was read in.
+ */
+declare abstract class DocumentHandle<T> {
+    protected readonly httpClient: HttpClient;
+    protected readonly name: string;
+    /** The client's locale, asked on every call rather than copied when this handle was taken. */
+    protected readonly clientLocale: () => string | undefined;
+    /**
+     * @param name - The singleton key or settings group id the routes are addressed by
+     * @param locale - The client's locale: the function `TypedRelyIOClient` hands over, asked on
+     *   every call
+     */
+    constructor(httpClient: HttpClient, name: string, locale?: ClientLocale);
+    /**
+     * Write the document you read, checked against the version it was read at (REL-2419), in the
+     * locale it was read in — as a content entry's `update(entry, data)` is. If it changed since the
+     * read, the write is refused with `ResourceConflictError` naming both versions: re-read it with
+     * `fresh: true` and retry.
+     */
+    update(read: ReadEntry, data: DocumentFields<T>, options?: RetryableWriteOptions): Promise<T>;
+    /**
+     * Write the document with no version check, on purpose, in `options.locale` or the client's own —
+     * creating it, when nobody has yet.
+     */
+    update(data: DocumentFields<T>, options?: DocumentWriteOptions): Promise<T>;
+    /**
+     * Version history for one locale of the document.
+     *
+     * Versions are numbered per locale, so this is one locale's timeline: `locale` defaults to the
+     * client's own, then the schema default; no fallback is applied, and a locale with no history
+     * returns an empty array rather than another locale's rows. Every row names the locale it belongs
+     * to.
+     */
+    versions(options?: DocumentVersionsOptions): Promise<Array<DocumentVersion<T>>>;
+    /**
+     * One version of the document: `version({ version, locale })`. `locale` defaults to the client's
+     * own, then the schema default; version numbers are per locale, so version 2 is different content
+     * in each one.
+     *
+     * There is no `null`: a version the locale does not have, a document nobody has written, one the
+     * schema does not declare and a dataset with no schema all throw `ResourceNotFoundError`, its
+     * `context.resourceType` naming which (REL-2409 Q12).
+     */
+    version(options: VersionOptions): Promise<T>;
+    /** `PATCH` the document's route with this write. */
+    protected abstract patch(write: DocumentWrite<T>, options?: RetryableWriteOptions): Promise<T>;
+    /** `GET` the document's version history route. */
+    protected abstract readVersions(query: {
+        limit: number;
+        locale?: string;
+    }): Promise<{
+        versions: Array<DocumentVersion<T>>;
+    }>;
+    /** `GET` one version of the document. */
+    protected abstract readVersion(versionNumber: string, query: {
+        locale?: string;
+    }): Promise<T>;
+    /** The locale a write or a history read sends: the call's, else the client's. */
+    protected localeOf(named: string | undefined): string | undefined;
+    /** The write's body: its data, and the locale it names when it names one. */
+    protected static bodyOf<T>(write: DocumentWrite<T>): {
+        content: DocumentFields<T>;
+        locale?: string;
+    };
+    /** The two headers a write sends: its check, when it has one, and its `Idempotency-Key`. */
+    protected static headersOf(write: Pick<DocumentWrite<unknown>, 'ifMatch'>, options?: RetryableWriteOptions): Record<string, string> | undefined;
+}
+
+/**
+ * One singleton: read with `get(options)`, written with `update`, and its history beside — the
+ * verbs a content type's handle has, for one document (REL-2419, REL-2409 Q18). `update`,
+ * `versions` and `version` are the ones every one-document handle shares ({@link DocumentHandle}).
+ *
+ * Every call is in the locale it names — the argument (`get({ locale })`, `versions({ locale })`,
+ * `update(data, { locale })`) — and otherwise in the client's own (`client.with({ locale })`,
+ * `updateConfig({ locale })`) as it is when the call is made, as `content()`'s are: reads, the write,
+ * and version history alike. An update of a singleton you read writes the locale it was read in.
+ *
+ * @example
+ * ```typescript
+ * const homepage = await client.singleton('homepage').get({
+ *   include: ['featuredProducts', 'heroImage'],
+ *   locale: 'en',
+ * })
+ * if (homepage) await client.singleton('homepage').update(homepage, { title: 'Welcome' })
+ * ```
+ */
+declare class SingletonClient<T = BaseSingleton, R extends Reading = UntypedReading<T>> extends DocumentHandle<T> {
+    /**
+     * The singleton, or `null` when nobody has written it yet (REL-2419, REL-2409 Q18).
+     *
+     * `null` only for a singleton with no content: one the schema does not declare, or a dataset with
+     * no schema deployed, throws `ResourceNotFoundError` naming which (`context.resourceType`
+     * `'singleton'` or `'schema'`), as a content type's `get` does.
+     *
+     * It takes a content read's options where the route declares them — `include`, `locale` (one
+     * code), `dataset` and `fresh` (`DocumentReadOptions`).
+     *
+     * @example
+     * ```typescript
+     * const home = await relyio.singleton('homepage').get({ include: ['hero'], locale: 'fr-FR' })
+     * if (home) await relyio.singleton('homepage').update(home, { headline: 'Bonjour' })
+     * ```
+     */
+    get<const P extends readonly string[] = []>(options?: DocumentReadOptions<R, P>): Promise<ReadWith<R, P[number]> | null>;
+    /** The API publishes on PATCH: there is no separate publish route. */
+    protected patch(write: DocumentWrite<T>, options?: RetryableWriteOptions): Promise<T>;
+    protected readVersions(query: {
+        limit: number;
+        locale?: string;
+    }): Promise<{
+        versions: Array<DocumentVersion<T>>;
+    }>;
+    protected readVersion(versionNumber: string, query: {
+        locale?: string;
+    }): Promise<T>;
+}
+
+/**
+ * One settings group: read with `get(options)`, written with `update` and `reset`, and its history
+ * beside — the verbs a content type's handle has, for one document (REL-2419, REL-2409 Q18).
+ * `update`, `versions` and `version` are the ones every one-document handle shares
+ * ({@link DocumentHandle}).
+ *
+ * Every call is in the locale it names — the argument (`get({ locale })`, `versions({ locale })`,
+ * `update(data, { locale })`, `reset({ locale })`) — and otherwise in the client's own
+ * (`client.with({ locale })`, `updateConfig({ locale })`) as it is when the call is made, as
+ * `content()`'s are: reads, writes and version history alike. An update or reset of a group you
+ * read writes the locale it was read in.
+ *
+ * The fields of a write travel as `content` beside an optional `locale`, the body the route
+ * validates (`UpdateSettingsDto`); any other top-level key is refused `REQUEST_INVALID`.
+ *
+ * @example
+ * ```typescript
+ * const emailConfig = await client.settings('email-config').get({
+ *   include: ['defaultTemplate'],
+ *   locale: 'en',
+ * })
+ * await client.settings('email-config').update(emailConfig, { fromName: 'RelyIO' })
+ * ```
+ */
+declare class SettingsClient<T = BaseSettingsGroup, R extends Reading = UntypedReading<T>> extends DocumentHandle<T> {
+    /**
+     * The settings group (REL-2419, REL-2409 Q18).
+     *
+     * Never `null`: the API answers a declared group that nobody has written yet with its declared
+     * defaults (it initializes the group on that first read), so there is no missing group to report.
+     * A group the schema does not declare, or a dataset with no schema deployed, throws
+     * `ResourceNotFoundError` naming which (`context.resourceType` `'settingsGroup'` or `'schema'`) —
+     * the not-found rule every handle's `get` follows.
+     *
+     * It takes a content read's options where the route declares them — `include`, `locale` (one
+     * code), `dataset` and `fresh` (`DocumentReadOptions`).
+     *
+     * @example
+     * ```typescript
+     * const site = await relyio.settings('site').get({ include: ['logo'] })
+     * await relyio.settings('site').update(site, { title: 'New title' })
+     * ```
+     */
+    get<const P extends readonly string[] = []>(options?: DocumentReadOptions<R, P>): Promise<ReadWith<R, P[number]>>;
+    /**
+     * Reset the group you read to its default values, checked against the version it was read at,
+     * in the locale it was read in (REL-2419) — refused with `ResourceConflictError` if it changed
+     * since the read.
+     */
+    reset(read: ReadEntry, options?: RetryableWriteOptions): Promise<T>;
+    /**
+     * Reset the group to its default values with no version check, in `options.locale` or the
+     * client's own. The route reads its locale from `?locale=` and takes no body, so that is where it
+     * is sent.
+     */
+    reset(options?: DocumentWriteOptions): Promise<T>;
+    /** The group's default values, as the schema declares them. */
+    getDefaults(): Promise<T>;
+    protected patch(write: DocumentWrite<T>, options?: RetryableWriteOptions): Promise<T>;
+    protected readVersions(query: {
+        limit: number;
+        locale?: string;
+    }): Promise<{
+        versions: Array<DocumentVersion<T>>;
+    }>;
+    protected readVersion(versionNumber: string, query: {
+        locale?: string;
+    }): Promise<T>;
+}
+
+/**
+ * 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;
+
+/**
+ * What the search family's routes answer, read from the committed document, and what a search over
+ * a client's content types returns (`search-options.ts` takes the options).
+ */
+
+/**
+ * What a search or similar hit reports beside its fields: the committed document's
+ * `SearchHitMetadata`, read through `http/api-schema.ts`.
+ *
+ * Narrower than an entry read's `EntryMetadata`, because a hit is not built by the entry read: it
+ * carries no `entryType`, `defaultLocale`, `availableLocales`, `refs`, `firstPublishedAt` or
+ * version history. Until REL-1413 a hit was typed as an entry and so promised all five — the
+ * locale helpers kept an optional chain after `availableLocales` for the hits that lacked it. Read
+ * the entry (`content(type).get(hit._metadata.id)`) for those.
+ */
+type SearchHitMetadata = components['schemas']['SearchHitMetadata'];
+/** What a hit carries beside the entry's fields, as the document declares it. */
+type SearchHitSystemFields = Pick<components['schemas']['SearchHit'], '_metadata' | '_score' | '_scoreBreakdown' | '_highlights'>;
+/**
+ * One search hit as the route emits it — the document's `SearchHit`: the fields `T` declares at the
+ * top level (at `_metadata.locale`, or only the aliases a `fields` projection names), the hit's own
+ * `_metadata`, and the score annotations the request asked for. There is no per-item `data` wrapper.
+ *
+ * `T`'s `_metadata` is replaced, not kept: `T` is an entry type, and a hit is not an entry read.
+ * Every field is optional, a required one too: a `fields` projection names only some of them, and a
+ * hit is built from the search row, not by the read that fills a required field a draft holds empty
+ * (REL-1795). Distributes over a union of entry types, so a search across two types keeps each
+ * one's fields.
+ */
+type SearchResultItem<T = unknown> = T extends unknown ? Partial<Omit<T, '_metadata'>> & SearchHitSystemFields : never;
+/**
+ * What `POST /v1/search` serves, **read from the committed document**.
+ *
+ * `{ data, page: { number, limit, total, pageCount }, meta }` — search is the page dialect
+ * (Decision 5, amended for REL-2420): `total` counts every entry the search matched. The facets,
+ * the strategy the engine chose and its warnings ride the declared `meta` sibling because none of
+ * them is an item or a page fact.
+ *
+ * The hand-written `{ items, total?, metadata? }` this replaced named three keys the route does not
+ * send.
+ */
+type SearchResponse<T = unknown> = Wire<'/v1/search', 'post', SearchResultItem<T>>;
+/**
+ * One autocomplete suggestion — the document's `AutocompleteSuggestion`: the value, its best score,
+ * an entry holding it (`id`), and the value with its match wrapped in `<em>` when Atlas highlighted
+ * it. The hand-written type this replaces named `highlighted`, `entryId` and `contentType`, none of
+ * which the route sends, and made `score` optional where it is always sent.
+ */
+type AutocompleteSuggestion = components['schemas']['AutocompleteSuggestion'];
+/**
+ * What `POST /v1/search/autocomplete` serves. The suggestions are the
+ * collection's `data`; the query it completed and the field it matched on ride
+ * `meta`. Autocomplete is unpaginated, so its page reports `offset: 0` and a
+ * `total` equal to what it returned — the dialect is declared rather than
+ * omitted so one collection shape covers every list.
+ */
+type AutocompleteResponse = Wire<'/v1/search/autocomplete', 'post', AutocompleteSuggestion>;
+/**
+ * One similar-content hit as the route emits it: the same `SearchHit` a search serves, built by
+ * the same transform, with `_score` on every hit.
+ */
+type SimilarResult<T = unknown> = SearchResultItem<T>;
+/** What `POST /v1/search/similar` serves. */
+type SimilarResponse<T = unknown> = Wire<'/v1/search/similar', 'post', SimilarResult<T>>;
+/**
+ * The content type names a search may be scoped to: the schema's where one types the client, any
+ * name where none does.
+ */
+type SearchTypeName<S extends AnySchemaDefinition | undefined> = S extends AnySchemaDefinition ? SchemaContentTypeNames<S> : string;
+/**
+ * What a search over the content types `K` returns: their entries, typed by the schema
+ * (`INV-SS-TYPES-INFERRED`) — or `T` unchanged where no schema types the client.
+ */
+type SearchEntry<S extends AnySchemaDefinition | undefined, K extends SearchTypeName<S> = SearchTypeName<S>, T extends BaseContent = BaseContent> = S extends AnySchemaDefinition ? SchemaEntryOf<S, K & SchemaContentTypeNames<S>> : T;
+
+/**
+ * The search family in one options object each (REL-2420; REL-2409 decisions Q3 and Q19).
+ *
+ * `search(q, options)` pages by number — `page` and `limit`, as an archive page does — and answers
+ * the API's page dialect, `{ number, limit, total, pageCount }`, so "page 2 of 3" needs no
+ * arithmetic. It takes the read options that apply to a search, under the names every read uses:
+ * `select`, `locale` (one code: a search composes its hits in one locale), `dataset` and `fresh`.
+ * `autocomplete(q, options)` and `similar(id, options)` take one options object too.
+ *
+ * The routes declare no request body in the committed document, so each body is written here by
+ * hand, in the route's own words: `select` is the route's `fields` alias map with each Field under
+ * its own name, and `sort` an array in the object's key order. `dataset` and `fresh` are the same
+ * header and query term every read sends ({@link readHeaders}).
+ *
+ */
+
+/**
+ * The Fields an entry of `E` declares, by key — of each type, where `E` is a union of the types a
+ * search spans. Any name where `E` declares none: a client no schema types.
+ */
+type SearchFieldKey<E> = [E] extends [never] ? string : E extends unknown ? [Exclude<keyof E, '_metadata'>] extends [never] ? string : Exclude<keyof E, '_metadata'> & string : never;
+/**
+ * Which content types a search spans: one name, or a list of them. Left out, every content type
+ * the key can see.
+ */
+type SearchScope<K extends string> = K | readonly [K, ...K[]];
+/**
+ * How hits are ordered: a direction per key, the **key order** the priority (Q14). `_score` is
+ * relevance itself; any other key is a Field of the types searched. Left out, by relevance.
+ */
+type SearchSortOption<E> = {
+    readonly [K in SearchFieldKey<E> | '_score']?: 'asc' | 'desc';
+};
+/**
+ * What a search's `where` takes over the content types `K`: the `where` `list` takes on each of them,
+ * typed as `list` types it (REL-2427; one dialect, D11) — Field names checked, `$`-prefixed
+ * operators, each value of its Field's type. Over several types, a `where` one of them takes. A
+ * client no schema types takes the untyped list's `where`.
+ */
+type SearchWhere<S extends AnySchemaDefinition | undefined, K extends string> = S extends AnySchemaDefinition ? K extends SchemaContentTypeNames<S> ? NonNullable<ListReadOptions<InferContentType<S['contentTypes'][K], S>, ContentReading<S['contentTypes'][K], S>, [
+]>['where']> : never : NonNullable<ListReadOptions<BaseContent, UntypedReading<BaseContent>, []>['where']>;
+/** How a matching term is highlighted: `true` for the route's defaults, or where and how much. */
+interface SearchHighlight {
+    readonly field?: string;
+    readonly maxWords?: number;
+    readonly minWords?: number;
+}
+/** One facet a search counts beside its hits, answered under `meta.facets` by its name. */
+interface SearchFacet {
+    readonly type: 'string' | 'number' | 'date' | 'reference';
+    /** The Field counted; a nested path such as `pricing.basePrice` is allowed. */
+    readonly field: string;
+    /** The most buckets a `string` or `reference` facet answers. */
+    readonly limit?: number;
+    /** A `number` or `date` facet's bucket edges. */
+    readonly boundaries?: readonly number[];
+    /** A `reference` facet's Field of the referenced entry to label each bucket with. */
+    readonly displayField?: string;
+}
+/** The options every read of the search family takes: where, and how fresh. */
+interface SearchReadOptions<C extends string> {
+    /** The locale the hits are composed in, over the client's: one code the schema declares. */
+    readonly locale?: C;
+    /** The dataset to search, by id or name, over the client's (Q9). */
+    readonly dataset?: string;
+    /** How fresh the answer must be: a feed position, or `true` for past every cache. */
+    readonly fresh?: FreshOption;
+}
+/**
+ * What `search(q, options)` takes.
+ *
+ * - `contentType` — {@link SearchScope}; every content type when left out.
+ * - `page` and `limit` — which page, counted from 1, and how many hits a page holds (the route's
+ *   default 20, at most 100).
+ * - `select` — the Fields each hit carries, beside `_metadata` and the scores asked for.
+ * - `where`, `searchFields`, `sort`, `includeScore`, `explain`, `highlight`, `facets` — the search's
+ *   own, as the route documents them.
+ */
+interface SearchOptions<K extends string, E, C extends string, W, S extends readonly SearchFieldKey<E>[] | undefined = undefined> extends SearchReadOptions<C> {
+    readonly contentType?: SearchScope<K>;
+    /**
+     * The conditions a hit must meet: {@link SearchWhere}, the `where` `list` takes. A condition on
+     * `_metadata` is refused before anything is sent.
+     */
+    readonly where?: W;
+    /** The Fields the text is matched in; every text Field when left out. */
+    readonly searchFields?: readonly SearchFieldKey<E>[];
+    /** The Fields each hit carries (Q15). */
+    readonly select?: S;
+    readonly sort?: SearchSortOption<E>;
+    /** Which page, counted from 1. */
+    readonly page?: number;
+    /** How many hits a page holds. */
+    readonly limit?: number;
+    /** Each hit's relevance as `_score`. */
+    readonly includeScore?: boolean;
+    /** Each hit's score broken down, for debugging relevance. */
+    readonly explain?: boolean;
+    readonly highlight?: boolean | SearchHighlight;
+    /** Counts to answer beside the hits, under `meta.facets`, each by its name. */
+    readonly facets?: Readonly<Record<string, SearchFacet>>;
+}
+/** What `autocomplete(q, options)` takes: the type and the Field to complete are required. */
+interface AutocompleteOptions<K extends string, E, C extends string, W> extends SearchReadOptions<C> {
+    readonly contentType: K;
+    /** The Field to complete, or a nested path under one (`category.name`). */
+    readonly field: SearchFieldKey<E> | `${SearchFieldKey<E>}.${string}`;
+    /** Tolerate typos, on a Field that is not localized. */
+    readonly fuzzy?: boolean;
+    /**
+     * The conditions an entry must meet to be suggested from, on Fields that are not localized:
+     * {@link SearchWhere}, the `where` `list` takes.
+     */
+    readonly where?: W;
+    /** How many suggestions to answer. */
+    readonly limit?: number;
+}
+/** What `similar(id, options)` takes. */
+interface SimilarOptions<K extends string, E, C extends string, S extends readonly SearchFieldKey<E>[] | undefined = undefined> extends SearchReadOptions<C> {
+    /** Which content types to find neighbours in; every content type when left out. */
+    readonly contentType?: SearchScope<K>;
+    /** The Fields each hit carries. */
+    readonly select?: S;
+    /** How many neighbours to answer. */
+    readonly limit?: number;
+}
+/** `E` with only the Fields `select` named, and `_metadata`; `E` when nothing is selected. */
+type SearchSelected<E, S> = S extends readonly [] | undefined ? E : S extends readonly string[] ? E extends unknown ? Pick<E, Extract<keyof E, S[number] | '_metadata'>> : never : E;
+/**
+ * What `search(q, options)` answers: the API's own `{ data, page, meta }`, the page in the page
+ * dialect — `{ number, limit, total, pageCount }`, `total` counting every entry the search matched.
+ */
+type SearchPage<E> = Wire<'/v1/search', 'post', SearchResultItem<E>>;
+
+/**
+ * A batch as one call: `client.batch(operations, options)` (REL-2421; REL-2409 decision Q22).
+ *
+ * Each operation reads like the single write it batches:
+ *
+ * - `{ create: 'post', data, slug?, locale?, parentId?, sortOrder? }` — `content('post').create`;
+ * - `{ update: 'post', entry, data }` — `update(entry, data)`: checked against the version the entry
+ *   you read carries, in the locale it was read in (REL-2418);
+ * - `{ update: 'post', id, data, locale? }` — `update(id, data)`: unchecked, on purpose;
+ * - `{ replace: 'post', entry | id, data }` — the same, replacing the entry's content in that locale.
+ *   The Content API has no single-entry replace route, so a batch is where a replace is written;
+ * - `{ delete: 'post', entry | id }` — checked in the locale the entry was read in, or unchecked;
+ * - `{ singleton: 'homepage', data, locale? }` — a singleton write, which creates it the first time.
+ *
+ * A check travels as the operation's `ifMatch`, the tag `If-Match` takes on the single-entry routes:
+ * one header cannot guard many writes. A stale one fails that operation with `RESOURCE_CONFLICT`
+ * naming the versions that disagreed; under `atomic: true` nothing in the batch is written.
+ *
+ * The call answers the API's own body, `{ data: { results, summary } }`: a batch is answered `200`
+ * whatever its operations did, and each result says what happened to its operation — an `outcome`,
+ * or an `error` naming the refusal. Nothing is thrown for an operation that failed.
+ */
+
+/** The content types an operation may name: the schema's, or any where no schema types the client. */
+type ContentTypeName<S> = S extends AnySchemaDefinition ? SchemaContentTypeNames<S> : string;
+/** The singletons a write may name: the schema's, or any where no schema types the client. */
+type SingletonName<S> = S extends AnySchemaDefinition ? SchemaSingletonNames<S> : string;
+/** The locale codes an operation may name: the schema's, or any. */
+type LocaleName<S> = S extends AnySchemaDefinition ? SchemaLocaleCodes<S> : string;
+/** An entry of content type `K`, as the schema declares it. */
+type EntryOf$1<S, K> = S extends AnySchemaDefinition ? InferContentType<S['contentTypes'][K & keyof S['contentTypes']], S> : BaseContent;
+/** The fields a singleton write sends: some of what the singleton declares, or any. */
+type SingletonData<S, K> = S extends AnySchemaDefinition ? Partial<Omit<InferSingleton<S['singletonContentTypes'][K & keyof S['singletonContentTypes']], S>, '_metadata'>> : {
+    readonly [field: string]: unknown;
+};
+/** Where a written entry sits: every write may move it, as the single writes do. */
+interface Placement {
+    readonly slug?: string;
+    readonly parentId?: string;
+    readonly sortOrder?: number;
+}
+/**
+ * Which entry an update or replace writes: the entry you read — checked, in the locale it was read
+ * in, so it takes no `locale` — or an id, unchecked, in the locale it names or the client's.
+ */
+type BatchTarget<L extends string> = {
+    readonly entry: ReadEntry;
+    readonly id?: never;
+    readonly locale?: never;
+} | {
+    readonly id: string;
+    readonly entry?: never;
+    readonly locale?: L;
+};
+/** Which entry a delete removes: the entry you read, checked, or an id, unchecked. */
+type BatchDeleteTarget = {
+    readonly entry: ReadEntry;
+    readonly id?: never;
+} | {
+    readonly id: string;
+    readonly entry?: never;
+};
+/** The verbs an operation is named by, exactly one per operation. */
+declare const VERBS: readonly ["create", "update", "replace", "delete", "singleton"];
+type Verb = (typeof VERBS)[number];
+/**
+ * Every verb but `V`, absent. Each operation then names all five, so the one present is the union's
+ * discriminant and a mistake is reported against the operation it was meant as.
+ */
+type Only<V extends Verb> = {
+    readonly [Other in Exclude<Verb, V>]?: never;
+};
+/** A create of content type `K`. */
+type BatchCreate<K extends string, T extends BaseContent, L extends string> = Placement & Only<'create'> & {
+    readonly create: K;
+    readonly data: CreateInput<T>;
+    readonly locale?: L;
+};
+/** An update of an entry of content type `K`: its fields merged into the entry. */
+type BatchUpdate<K extends string, T extends BaseContent, L extends string> = Placement & BatchTarget<L> & Only<'update'> & {
+    readonly update: K;
+    readonly data: UpdateInput<T>;
+};
+/** A replace of an entry of content type `K`: fields left out are cleared in that locale. */
+type BatchReplace<K extends string, T extends BaseContent, L extends string> = Placement & BatchTarget<L> & Only<'replace'> & {
+    readonly replace: K;
+    readonly data: CreateInput<T>;
+};
+/** A delete of an entry of content type `K`. */
+type BatchDelete<K extends string> = BatchDeleteTarget & Only<'delete'> & {
+    readonly delete: K;
+};
+/** A write to singleton `K`, which creates it the first time. */
+type BatchSingletonWrite<K extends string, D, L extends string> = Only<'singleton'> & {
+    readonly singleton: K;
+    readonly data: D;
+    readonly locale?: L;
+};
+/**
+ * One operation of `client.batch(operations)`, each content type's `data` typed by what it declares
+ * where a schema types the client.
+ */
+type BatchWrite<S extends AnySchemaDefinition | undefined = undefined> = {
+    [K in ContentTypeName<S>]: BatchCreate<K, EntryOf$1<S, K>, LocaleName<S>> | BatchUpdate<K, EntryOf$1<S, K>, LocaleName<S>> | BatchReplace<K, EntryOf$1<S, K>, LocaleName<S>> | BatchDelete<K>;
+}[ContentTypeName<S>] | {
+    [K in SingletonName<S>]: BatchSingletonWrite<K, SingletonData<S, K>, LocaleName<S>>;
+}[SingletonName<S>];
+/** How a batch runs. Each is the API's default when left out. */
+interface BatchWriteOptions {
+    /**
+     * One transaction: every operation lands or none does. The API takes it only when every operation
+     * is the same kind of write and none creates a singleton (`REQUEST_INVALID` otherwise).
+     */
+    readonly atomic?: boolean;
+    /** Run every check a real write runs, and write nothing. */
+    readonly dryRun?: boolean;
+    /** Stop at the first operation that fails; the rest are answered `skipped`. Not with `atomic`. */
+    readonly stopOnError?: boolean;
+    /** `false` answers each written entry by id alone instead of reading it back. */
+    readonly returnData?: boolean;
+    /** The dataset to write, by id or name, over the client's. */
+    readonly dataset?: string;
+}
+/**
+ * One batch item, as the committed document describes the `multi` kind: an `outcome` —
+ * `created`, `updated`, `unchanged`, `duplicate` or `skipped` — or an `error` naming the refusal.
+ */
+type BatchOperationResult = components['schemas']['MultiPayload']['results'][number];
+/** A batch's counts, from the contract. */
+type BatchSummary = components['schemas']['MultiSummary'];
+/** The batch payload: `{ results, summary }`. */
+type BatchResponse = components['schemas']['MultiPayload'];
+/** What `client.batch(operations)` answers: the API's body, `{ data: { results, summary } }`. */
+type BatchBody = Wire<'/v1/batch', 'post', BatchResponse>;
+
+/**
+ * Ad-hoc and named queries as single calls: `client.query(…)` (REL-2421; REL-2409 decision Q22).
+ *
+ * - `client.query({ from, … })` runs a query inline. It takes `list`'s option names, typed from the
+ *   same option types — `include`, `select`, `sort`, `limit`, `page`, `locale`, `dataset`, `fresh` —
+ *   plus its own: `aggregate`, `params` and `fullText`. `where` is `list`'s, typed as `list` types
+ *   it (`{ views: { $gte: 10 } }`): the query route reads the `where` a list takes (REL-2439,
+ *   REL-2409 decision D11), and refuses the bare form a saved query used to declare.
+ * - `client.query(name, { params, … })` runs the saved query the schema declares under `name`, by
+ *   that name alone (`POST /v1/queries/{name}`, D9). Its parameters are typed from the declaration
+ *   ({@link InferQueryParams}): a name it does not declare does not compile, and the API refuses it
+ *   too, naming it.
+ *
+ * Both answer the API's body, `{ data: { result, metadata } }`.
+ *
+ * The query route pages by `limit` and `offset` and answers no cursor, so a query pages by number:
+ * `page` with `limit`, sent as the offset that page starts at. There is no `cursor`.
+ *
+ */
+
+/** The content types a query reads: the schema's, or any where no schema types the client. */
+type QueryTypeName<S> = S extends AnySchemaDefinition ? SchemaContentTypeNames<S> : string;
+/** An entry of content type `K`, as the schema declares it. */
+type EntryOf<S, K> = S extends AnySchemaDefinition ? InferContentType<S['contentTypes'][K & keyof S['contentTypes']], S> : BaseContent;
+/** A read of content type `K`, which checks its include paths and names its locales. */
+type ReadingOf<S, K> = S extends AnySchemaDefinition ? ContentReading<S['contentTypes'][K & keyof S['contentTypes']], S> : UntypedReading<BaseContent>;
+/** The locale codes a query may name: the schema's, or any. */
+type QueryLocale<S> = S extends AnySchemaDefinition ? SchemaLocaleCodes<S> : string;
+/** The saved queries a client may run by name: the schema's, or any. */
+type QueryName<S> = S extends AnySchemaDefinition ? SchemaQueryNames<S> : string;
+/** The parameters saved query `N` declares; any, where no schema types the client. */
+type NamedQueryParams<S, N> = S extends AnySchemaDefinition ? InferQueryParams<S['queries'][N & keyof S['queries']]> : AnyQueryParameters;
+/**
+ * What an ad-hoc query computes over the entries it fetched: the groups and metrics of the query
+ * route's `aggregate` block. Its source is `from`.
+ */
+type QueryAggregate = Omit<AggregateBlock, 'source'>;
+/** How a query pages: by number, with `limit` its size — or not at all. */
+type QueryPaging<T extends BaseContent, R extends Reading> = {
+    readonly page?: never;
+} | {
+    /** Which page, from 1: sent as the offset it starts at, `(page - 1) * limit`. */
+    readonly page: number;
+    readonly limit: NonNullable<ListReadOptions<T, R, []>['limit']>;
+};
+/** `select` or `include`: the route refuses an include path beside a selection. */
+type SelectOrInclude<R extends Reading, P extends readonly string[], Sel> = {
+    readonly select?: Sel;
+    readonly include?: undefined;
+} | {
+    readonly select?: undefined;
+    readonly include?: CheckedIncludes<R, P>;
+};
+/**
+ * What `client.query({ from, … })` takes: `list`'s options, typed as `list` types them, and the
+ * query's own.
+ */
+type AdhocQuery<K extends string, T extends BaseContent, R extends Reading, P extends readonly string[], Sel extends readonly FieldKey<T>[] | undefined, A extends QueryAggregate | undefined> = {
+    /** The content type the query reads. */
+    readonly from: K;
+    /**
+     * The conditions an entry must meet: the `where` `list` takes, typed as `list` types it — a value,
+     * a list, or `$`-prefixed operators (`{ views: { $gte: 10 } }`). A condition on `_metadata` is
+     * refused before anything is sent.
+     */
+    readonly where?: ListReadOptions<T, R, P>['where'];
+    /** The order, by Field or system date, the key order the priority. */
+    readonly sort?: SortOption<T>;
+    /** How many entries the query answers — a page's size where `page` names one. */
+    readonly limit?: ListReadOptions<T, R, P>['limit'];
+    /** The one locale the entries are composed in, over the client's. */
+    readonly locale?: ReadLocale<R>;
+    /** The dataset to read, by id or name, over the client's. */
+    readonly dataset?: string;
+    /** How fresh the answer must be: a feed position, or `true` for past every cache. */
+    readonly fresh?: FreshOption;
+    /** Groups and metrics computed over the entries fetched; the answer is then their rows. */
+    readonly aggregate?: A;
+    /** Values for the `${param}` expressions the query writes. */
+    readonly params?: {
+        readonly [name: string]: QueryParameterValue;
+    };
+    /** A text search over the Fields it names, beside the fetch. */
+    readonly fullText?: FullTextSearch;
+} & QueryPaging<T, R> & SelectOrInclude<R, P, Sel>;
+/** What `client.query(name, options)` takes beside the parameters. */
+interface NamedQueryReadOptions<L extends string> {
+    /** The one locale the query composes in, over the client's. */
+    readonly locale?: L;
+    /** The dataset to read, by id or name, over the client's. */
+    readonly dataset?: string;
+    /**
+     * `true` reads past every cache. The route is not edge-kept, so a feed position has no cached
+     * answer to be fresher than and is not offered.
+     */
+    readonly fresh?: true;
+}
+/** What `client.query(name, options)` takes: `params` required where the query requires one. */
+type NamedQueryOptions<Params, L extends string> = NamedQueryReadOptions<L> & (Record<never, never> extends Params ? {
+    readonly params?: Params;
+} : {
+    readonly params: Params;
+});
+/** The options argument, which may be left out only where no parameter is required. */
+type NamedQueryArgs<Params, L extends string> = Record<never, never> extends Params ? [options?: NamedQueryOptions<Params, L>] : [options: NamedQueryOptions<Params, L>];
+/**
+ * One metric, as the Query DSL writes it: `<field>.<fn>`, where `fn` is `count`, `sum`, `avg`,
+ * `min`, `max`, `first` or `last` — `'id.count'`, `'pricing.basePrice.avg'`. The service validates
+ * every metric against that form (`INVALID_AGGREGATION_EXPRESSION`); `count` ignores the field it
+ * names (REL-1470).
+ */
+type AggregateMetric = `${string}.${'count' | 'sum' | 'avg' | 'min' | 'max' | 'first' | 'last'}`;
+/** How a query ran, as the query routes report it beside the records. */
+interface QueryMetadata {
+    /** Query identifier */
+    queryId: string;
+    /** Execution time in milliseconds */
+    executionTimeMs: number;
+    /** Number of results */
+    resultCount: number;
+    /** ISO timestamp */
+    timestamp: string;
+    /** Whether result was from cache */
+    cacheHit?: boolean;
+    /** Generated pipeline (if debug enabled) */
+    pipeline?: unknown[];
+    /** Resolved parameters (if debug enabled) */
+    parameters?: Record<string, unknown>;
+    /** Validation warnings */
+    warnings?: string[];
+}
+/** The API's body for a query: the records it produced and how it ran. */
+interface QueryAnswer<T> {
+    readonly data: {
+        /** The records the query produced. */
+        readonly result: T;
+        readonly metadata: QueryMetadata;
+    };
+}
+/**
+ * One record of an ad-hoc query: an aggregate's row, the selected Fields of an entry, or the entry
+ * as its include paths read it.
+ */
+type AdhocRecord<R extends Reading, P extends readonly string[], Sel, A> = A extends QueryAggregate ? Readonly<Record<string, unknown>> : Sel extends readonly string[] ? Pick<ReadWith<R, P[number]>, Extract<keyof ReadWith<R, P[number]>, Sel[number]>> : ReadWith<R, P[number]>;
+/**
+ * `client.query`: callable two ways, beside the chained client it was before.
+ *
+ * Each way is read off a method (`['run']`), so its parameters compare as a method's do: a client
+ * typed by one schema stays assignable to one typed by a wider one, as its other methods let it be.
+ */
+type QueryCall<S extends AnySchemaDefinition | undefined> = AdhocQueryCall<S> & NamedQueryCall<S>;
+/** `client.query({ from, … })`. */
+type AdhocQueryCall<S extends AnySchemaDefinition | undefined> = {
+    /**
+     * Run a query inline: `list`'s options plus `aggregate`, `params` and `fullText`. Answers the
+     * API's body, its `result` the entries — or the aggregate's rows.
+     *
+     * @example
+     * ```typescript
+     * const { data } = await relyio.query({
+     *   from: 'post',
+     *   where: { views: { $gte: 100 } },
+     *   select: ['title', 'views'],
+     *   sort: { views: 'desc' },
+     *   limit: 10,
+     *   page: 2,
+     * })
+     * ```
+     */
+    run<K extends QueryTypeName<S>, const P extends readonly string[] = [], const Sel extends readonly FieldKey<EntryOf<S, K>>[] | undefined = undefined, const A extends QueryAggregate | undefined = undefined>(query: AdhocQuery<K, EntryOf<S, K>, ReadingOf<S, K>, P, Sel, A>): Promise<QueryAnswer<AdhocRecord<ReadingOf<S, K>, P, Sel, A>[]>>;
+}['run'];
+/** `client.query(name, { params, … })`. */
+type NamedQueryCall<S extends AnySchemaDefinition | undefined> = {
+    /**
+     * Run the saved query the deployed schema declares under `name`, with the parameters it declares
+     * (`POST /v1/queries/{name}`, D9). Answers the API's body.
+     *
+     * It needs only the name: a client created without a schema runs it too, its parameters untyped.
+     * A schema the client is typed by (`createClient({ schema })`, or `Register`) types the name and
+     * the parameters. The API refuses a parameter the query does not declare, naming it.
+     *
+     * @example
+     * ```typescript
+     * const { data } = await relyio.query('postsByTag', { params: { tag: 'birds' } })
+     * ```
+     */
+    run<N extends QueryName<S>>(name: N, ...options: NamedQueryArgs<NamedQueryParams<S, N>, QueryLocale<S>>): Promise<QueryAnswer<unknown>>;
+}['run'];
+
+/**
+ * Content and resource errors.
+ *
+ * `ContentTypeNotFoundError` and `ContentNotFoundError` were deleted at API5.
+ * The mapper reached them by sniffing `CONTENT_TYPE_NOT_FOUND` and
+ * `CONTENT_NOT_FOUND`, neither of which is in the closed vocabulary, so neither
+ * class was reachable. Both cases are `RESOURCE_NOT_FOUND`, whose declared
+ * `details` are `{ kind, id? }` — the same two facts, from the one code a route
+ * can actually declare.
+ */
+declare class ResourceNotFoundError extends SDKError {
+    readonly code = "RESOURCE_NOT_FOUND";
+    readonly retryable = false;
+    constructor(message?: string, statusCode?: number, cause?: Error, context?: Record<string, unknown>);
+    getUserMessage(): string;
+}
+declare class ResourceConflictError extends SDKError {
+    readonly code = "RESOURCE_CONFLICT";
+    readonly retryable = false;
+    constructor(message?: string, statusCode?: number, cause?: Error, context?: Record<string, unknown>);
+    getUserMessage(): string;
+}
+declare class ResourceExpiredError extends SDKError {
+    readonly code = "RESOURCE_EXPIRED";
+    readonly retryable = false;
+    constructor(message?: string, statusCode?: number, cause?: Error, context?: Record<string, unknown>);
+    getUserMessage(): string;
+}
+/**
+ * "Did the service say this resource does not exist?"
+ *
+ * Reads the **code**, not the status. Four contract codes are 4xx on a read and
+ * only one of them means "not there"; the incumbent checked `statusCode === 404`
+ * on the thrown value, and a second arm duck-typed a plain object for the same
+ * number so a hand-written test double would pass. Both are the branch
+ * `INV-API-CLIENT-IS-DERIVED` forbids where a code exists — and the second one
+ * only existed because the tests faked the boundary (rule 20). They now stub
+ * `fetch`, so the double is gone with the branch.
+ */
+declare function isResourceNotFound(error: unknown): boolean;
+/**
+ * "Did the service say the **entry** does not exist?" — and not its content type, its schema or its
+ * dataset (REL-2415, REL-2409 decision Q12).
+ *
+ * `RESOURCE_NOT_FOUND` carries `details.kind`, which the mapper keeps as `context.resourceType`. A
+ * read that answered `null` for every kind made a content type nobody deployed look like a missing
+ * page, so `get` answers `null` only for this one and throws the rest as they arrived.
+ */
+declare function isMissingEntry(error: unknown): boolean;
+
+/**
+ * `relyio.changes()` — the changes feed as a typed long-poll iterator
+ * (`sdk-surfaces-spec.md` decisions 16–18).
+ *
+ * Long-poll only, on purpose. `GET /v1/changes` is an ordinary cursor-paged
+ * collection the committed document declares, so each poll is one `send` over
+ * the one HTTP client (`INV-SS-ONE-CORE`, `INV-API-CLIENT-IS-DERIVED`). The SSE
+ * branch the route also serves would be a second transport path inside that
+ * client, and `parseResponse` buffers a whole body; it stays for `EventSource`
+ * and curl consumers.
+ */
+
+type PollChanges = paths['/v1/changes']['get'];
+/**
+ * The 200 body the document declares, read from its `application/json` content
+ * **by name**. The route also negotiates `text/event-stream`; naming the JSON
+ * content is what keeps that alternate from changing this type when the
+ * document gains it.
+ */
+type ChangesPageBody = PollChanges['responses'][200]['content']['application/json'];
+/**
+ * One change, as the committed document describes an item of the feed's `data`
+ * (`INV-SS-CHANGE-IS-IDS`: ids, content type, locale, kind and cursor — never a
+ * document).
+ *
+ * Read from the document, never written here: the api's route row names the
+ * `Change` component schema, and a change to it reaches this type when the
+ * document is regenerated. `changes.types.ts` holds it equal to the document's
+ * item, and fails if it is ever `unknown` again.
+ */
+type Change = ChangesPageBody['data'][number];
+/**
+ * A change as `relyio.changes()` and `relyio.liveChanges()` deliver it: the document's
+ * {@link Change}, and `fresh`.
+ *
+ * `fresh` is the feed position a refetch for this change names, as the one query term the API
+ * declares on every read its edge may keep (`?_fresh`, `sdk-surfaces-spec.md` decision 32): hand it
+ * to the read as its `fresh` option — `get(id, { fresh: change.fresh })`, `list({ fresh })`,
+ * `search(q, { fresh })`, a singleton's `get({ fresh })`. A position no request named before the change is a key no cache holds a
+ * body under, so the read is answered after the change — at the edge and in the browser, whether
+ * or not the change's purge has reached them — and every later read naming it shares that answer.
+ *
+ * It is at or after the change, never before: on `/v1/changes` the change's own cursor, the ledger
+ * row it came from; at the live edge the cursor of the batch it arrived in. It is not always
+ * `cursor`: at the edge an earlier change of a batch carries the position **before** the batch as
+ * its `cursor`, so a failure part-way through replays the batch, and a refetch naming that position
+ * would be answered from before the change.
+ */
+type FeedChange = Change & {
+    /** The feed position a refetch for this change names (`?_fresh`); at or after the change. */
+    readonly fresh: string;
+};
+/**
+ * Why a cursor could no longer be replayed, or why everything must be refetched. `/v1/changes`
+ * names `retention` and `dataset-replaced`; the live edge's `feed.resync` may name any reason its
+ * wire declares (`VisitorResyncReason` in `@relyio/api-contract`, read from there rather than
+ * restated). `unknown` when the message named none.
+ */
+type ChangesExpiredReason = VisitorResyncReason | 'unknown';
+/**
+ * `RESOURCE_EXPIRED` from the changes feed: the cursor names a position the
+ * ledger can no longer replay from (`INV-SS-CURSOR-REPLAYS`). The consumer
+ * resyncs from the read path and starts again without a cursor.
+ *
+ * A `ResourceExpiredError`, so code that already catches that still does. The
+ * refusal declares no details, so `reason` is read from the message the api
+ * writes (`apps/services/api/src/changes/changes-request.ts` `refusalOf`).
+ *
+ * The live edge's `feed.resync` — a socket's frame or a poll's answer — is the
+ * same instruction and arrives as the same error ({@link ChangesExpiredError.resync}),
+ * so `onExpired` means one thing on both transports.
+ */
+declare class ChangesExpiredError extends ResourceExpiredError {
+    readonly reason: ChangesExpiredReason;
+    /**
+     * The position the feed resynced to, which a refetch of everything names as `?_fresh`, as a
+     * change's {@link FeedChange.fresh} is named: the head a `/v1/changes` resync took, or the cursor
+     * the edge's `feed.resync` sent. `undefined` when there was no resync to take one — the error was
+     * thrown (`onExpired: 'throw'`) — and on an error a caller built itself.
+     */
+    readonly fresh: string | undefined;
+    /** The base class's signature, so `withContext` can rebuild one; then the position resynced to. */
+    constructor(message: string, statusCode?: number, cause?: Error, context?: Record<string, unknown>, fresh?: string);
+    /** The base class rebuilds from its four arguments, which would drop the position resynced to. */
+    withContext(context: Record<string, unknown>): this;
+    /** `/v1/changes`' refusal, with the head the feed resynced to when it did. */
+    static of(expired: ResourceExpiredError, fresh?: string): ChangesExpiredError;
+    /** The live edge's `feed.resync`: refetch everything, then continue from the cursor it sent. */
+    static resync(reason: VisitorResyncReason, cursor: string): ChangesExpiredError;
+}
+interface ChangesOptions {
+    /**
+     * A `page.nextCursor` — or a change's `cursor` — from an earlier poll. Omitted,
+     * the first poll answers the dataset's current position and no changes, at
+     * once, and the feed starts from there.
+     */
+    since?: string;
+    /** Content types to keep. Omitted keeps every type; an empty list is refused (400). */
+    types?: readonly string[];
+    /**
+     * Entry ids to keep. Omitted keeps every entry. The api refuses more than it
+     * allows (100 today) as `REQUEST_INVALID`, thrown from the iterator as an
+     * `InvalidPayloadError` on the first poll; the SDK does not restate the
+     * cap, so it cannot drift from the service's.
+     */
+    ids?: readonly string[];
+    /** Ledger rows one poll scans, 1 to 500; the api defaults to 100. */
+    limit?: number;
+    /**
+     * Ends the iteration. An abort — in flight, between polls, or while waiting
+     * out a `Retry-After` — makes the `for await` **complete**, with no further
+     * request and no `AbortError` thrown into the loop.
+     */
+    signal?: AbortSignal;
+    /**
+     * What to do when the cursor has expired.
+     *
+     * - `'throw'` (default) — the iterator throws {@link ChangesExpiredError}.
+     * - `'resync'` — restart from the dataset's current position and keep going.
+     * - a function — resync, and call it with the error once the new position is
+     *   taken and before any change after it is yielded. This is the observable
+     *   form: whatever the consumer derived from the feed may be stale, so the
+     *   function is where it invalidates everything — naming the error's `fresh`,
+     *   the new position, on every refetch. The iterator waits for it.
+     */
+    onExpired?: 'throw' | 'resync' | ((expired: ChangesExpiredError) => void | Promise<void>);
+    /**
+     * Called once, when the feed was opened without `since`, with the position it starts from: the
+     * first poll's answer, the dataset's head — before the next poll is sent. Read what you show
+     * **after** it and a write your read did not see is after the position, so this feed delivers it,
+     * with no second request to take the position first (`changesHead()` is that request) (REL-1513).
+     *
+     * `followChanges()` passes it (`ChangeSourceOptions.reached`), so a feed that drops before its first
+     * change reopens from there rather than re-reading everything. Never called with a later empty
+     * page's cursor: filtered, that cursor is past rows the filter hid, and a caller that widens the
+     * filter must not reopen from it.
+     */
+    reached?: (cursor: string) => void;
+}
+interface ChangesHeadOptions {
+    /** Cancels the request; the promise then rejects. */
+    signal?: AbortSignal;
+}
+
+/**
+ * `relyio.liveChanges()` — a dataset's published changes at RelyIO's live edge, for a publishable key
+ * (`live-layer-spec.md` decision 20; LV5.2, REL-1158).
+ *
+ * The wire is `@relyio/api-contract`'s `live-visitor.ts`, read from there and never restated: the
+ * path and query names, the frames and their reader, the keepalive, the poll's answer and its reader,
+ * the poll interval, and what each close code and each refused poll means a client does next.
+ *
+ * **One open, two ways in.** A subscription opens a WebSocket to the edge. Where it cannot — the
+ * runtime has no `WebSocket` (Node 18 and 20), constructing one throws, the socket fails before it
+ * opens (a network that blocks sockets), or it has not opened and been caught up within
+ * {@link LIVE_SOCKET_OPEN_TIMEOUT_MS} (a network that holds it) — it polls the edge instead, from the
+ * same cursor, about every {@link VISITOR_POLL_INTERVAL_MS}, and tries a socket again about once a
+ * minute. Both carry one cursor space, so a switch either way loses nothing.
+ *
+ * **Where it starts.** Without `since`, the edge answers the dataset's current position before
+ * anything else — the socket's `feed.opened`, or the first poll's answer — and the subscription hands
+ * it to `reached`. That call is the position, with no request of its own for it: a read sent after it
+ * is answered at or after the position, and every change after it is delivered here, so a publish the
+ * read did not see is announced (REL-1513). The edge counts the subscription as one live connection,
+ * whichever way in it took (`INV-LV-LIVE-IS-METERED`).
+ *
+ * **It ends only when its signal aborts, and throws every other end** — a socket closed by a refusal
+ * or a deploy, a refused poll, a keepalive nobody answered — as a `LiveEdgeError` saying what to do
+ * next, so `followChanges()` reconnects, backs off or stops by the edge's own tables. That loop is
+ * the one reconnect policy (`INV-SS-ONE-CORE`, REL-1215); this module keeps no back-off of its own.
+ *
+ * **Cursors.** The edge sends one cursor after a batch of changes. The last change of a batch carries
+ * it; each earlier one carries the position before the batch, so a failure part-way through a batch
+ * replays the whole batch rather than skipping its rest. Delivery is at-least-once: a replay and the
+ * live frames after it may name one change twice, and a refetch makes a repeat cost a read, never a
+ * wrong view (`INV-SS-CHANGE-IS-IDS`).
+ *
+ * **What a refetch names.** Every change of a batch carries the batch's own cursor as `fresh`
+ * (`FeedChange`), the position its refetch names as `?_fresh` — not `cursor`, which for an earlier
+ * change is the position before the batch: the previous batch's refetches were answered under that
+ * one, before this batch, and a cache would hand the same answer back. A `feed.resync`'s error
+ * carries the cursor it sent the same way.
+ */
+
+/**
+ * How often an open socket sends the keepalive, which the edge's runtime answers without waking the
+ * feed — the Studio's dataset room sends its own on the same interval. A socket that has heard
+ * nothing by the next one, not even the answer, is presumed dead and reconnected: a client that only
+ * receives never learns otherwise that a network change dropped its connection.
+ */
+declare const LIVE_KEEPALIVE_INTERVAL_MS = 30000;
+/**
+ * How long a socket has to open and be caught up — the feed's `feed.opened` — before the subscription
+ * stops waiting on it, closes it and polls instead, as it does for a socket that fails before it opens
+ * (REL-1513).
+ *
+ * The poll interval, because that is what a socket is for: telling the page sooner than a poll would.
+ * A poll is answered at once and polled again within this interval, so a socket that has not caught
+ * up by then has already served the page worse than polling would have. It is well past a healthy
+ * open — the door's checks and one ledger read at the edge — and half the keepalive's verdict on an
+ * open socket that has gone quiet ({@link LIVE_KEEPALIVE_INTERVAL_MS}, twice). It bounds how long
+ * `<RelyIOProvider live>`'s first reads wait for a position on a network that neither opens a socket
+ * nor refuses one — a proxy that holds the upgrade — which without it they would wait on for as long
+ * as the page is open.
+ */
+declare const LIVE_SOCKET_OPEN_TIMEOUT_MS = 15000;
+interface LiveChangesOptions {
+    /**
+     * A change's cursor from an earlier subscription. Omitted, the edge answers the dataset's current
+     * position first and replays nothing, and the subscription hands that position to `reached` before
+     * anything after it. Read what you show **after** that first call — a read sent before it, from a
+     * subscription opened afterwards without `since`, leaves a publish between the two that neither
+     * sees (REL-1513). With `followChanges()`, which hands the source its own `reached`, call both —
+     * and let the read go if the loop fails first, so content never waits on a feed that is down:
+     *
+     * ```ts
+     * let positioned!: () => void
+     * const position = new Promise<void>(resolve => (positioned = resolve))
+     * const following = followChanges(
+     *   from =>
+     *     relyio.liveChanges({
+     *       ...from,
+     *       ids: [id],
+     *       reached: cursor => {
+     *         from.reached(cursor)
+     *         positioned()
+     *       },
+     *     }),
+     *   { signal, onChange, onResync, onState: state => state.kind !== 'following' && positioned() },
+     * )
+     * await position
+     * const post = await relyio.content('post').get(id)
+     * ```
+     *
+     * The wait is bounded: a socket that has not opened and been told its position within
+     * {@link LIVE_SOCKET_OPEN_TIMEOUT_MS} is given up for a poll, answered at once.
+     */
+    since?: string;
+    /** Content types to keep. Omitted keeps every type; an empty list is refused. At most 50. */
+    types?: readonly string[];
+    /** Entry ids to keep. Omitted keeps every entry; an empty list is refused. At most 100. */
+    ids?: readonly string[];
+    /**
+     * Ends the subscription. An abort — while connected, while polling, or between polls — makes the
+     * `for await` **complete**, with the socket closed, no further request and nothing thrown.
+     */
+    signal?: AbortSignal;
+    /**
+     * What to do when the edge says to refetch everything (`feed.resync`: the cursor is too old, was
+     * never this dataset's, or the dataset was replaced) — as `relyio.changes()` takes it: `'throw'`
+     * (default) throws a `ChangesExpiredError`, `'resync'` carries on from the edge's position, and a
+     * function is awaited with the error before any change after that position is yielded.
+     */
+    onExpired?: ChangesOptions['onExpired'];
+    /**
+     * Called when the edge has the subscription in hand — its `feed.opened` frame, or an answered
+     * poll. `followChanges()` passes it to reset its back-off; see `ChangeSourceOptions.opened`.
+     */
+    opened?: () => void;
+    /**
+     * Called with a position reached without a change to carry it. `followChanges()` passes it so a
+     * connection dropped before its first change reconnects from there; see
+     * `ChangeSourceOptions.reached`. Without `since`, its first call is the position the subscription
+     * starts from (see `since`).
+     */
+    reached?: (cursor: string) => void;
+}
+
+/**
+ * The key's project, as `GET /v1/project` describes it: organization, project, dataset and branch,
+ * each by id and name, and `studioUrl` — the Studio root the preview toolbar deep-links from
+ * (`sdk-surfaces-spec.md` decision 24), or `null` when the service has no Dashboard address.
+ *
+ * Read from the committed document's `application/json` content by name, never written here
+ * (`INV-API-CLIENT-IS-DERIVED`); `derived-transport.types.ts` holds the two equal.
+ */
+type Project = paths['/v1/project']['get']['responses'][200]['content']['application/json']['data'];
+/** What `health()` resolves: the API answered and reaches every store it reads. */
+interface Health {
+    readonly status: 'ok';
+    /** When the API answered, as an ISO 8601 string. */
+    readonly timestamp: string;
+}
+/** One locale `locales()` reports, as the deployed schema declares it. */
+interface DeployedLocale {
+    /** BCP 47 code, as a read's `locale` takes it. */
+    readonly code: string;
+    readonly displayName: string;
+    /** Whether this is the default locale. Exactly one locale is. */
+    readonly default: boolean;
+    /** The locales a read in this one falls back to, in order. */
+    readonly fallback?: string[];
+    readonly direction?: 'ltr' | 'rtl';
+    /** `false` when the locale is declared and switched off. */
+    readonly active?: boolean;
+}
+/** One type `contentTypes()` reports. */
+interface DeployedContentType {
+    /** What `content()` or `singleton()` takes. */
+    readonly id: string;
+    /** The type's `displayName`. */
+    readonly name: string;
+    readonly type: 'content' | 'singleton';
+}
+/**
+ * The defaults `client.with()` gives the client it makes (REL-2417, Q9): the locale and the dataset
+ * its reads and writes are in unless a call names its own. A locale is one the schema declares.
+ */
+interface ClientDefaults<TSchema extends AnySchemaDefinition | undefined = undefined> {
+    readonly locale?: LocaleCodeOf<TSchema>;
+    readonly dataset?: string;
+}
+/** The locale codes a client's reads may name: the schema's, or any where no schema types it. */
+type LocaleCodeOf<TSchema extends AnySchemaDefinition | undefined> = TSchema extends AnySchemaDefinition ? SchemaLocaleCodes<TSchema> : string;
+/**
+ * Client configuration with optional schema
+ */
+interface TypedClientConfig<TSchema extends AnySchemaDefinition | undefined = undefined> extends RelyIOConfig {
+    /** Schema definition for type inference (optional - omit for dynamic/untyped usage) */
+    schema?: TSchema;
+}
+/**
+ * Typed RelyIO client with full schema awareness
+ *
+ * @example
+ * ```typescript
+ * import { createClient } from '@relyio/sdk'
+ * import { schema } from './schema'
+ *
+ * const relyio = createClient({
+ *   apiKey: process.env.RELYIO_API_KEY!,
+ *   schema,
+ * })
+ *
+ * // Content operations
+ * const { data: products } = await relyio.content('product').list({ limit: 20 })
+ *
+ * // Search
+ * const results = await relyio.search('wireless', { contentType: 'product' })
+ *
+ * // Batch operations
+ * const batch = await relyio.batch([{ create: 'product', data: { title: 'New' } }])
+ * ```
+ */
+declare class TypedRelyIOClient<TSchema extends AnySchemaDefinition | undefined = undefined> {
+    /**
+     * The one HTTP client every sub-client sends through. `updateConfig()` and `setApiKey()` change it
+     * in place rather than replacing it, so a sub-client taken before either sends through the change.
+     */
+    private httpClient;
+    private config;
+    /**
+     * The configuration as `createClient()`, `setApiKey()` and `updateConfig()` gave it, before the
+     * `relyio dev` handshake: what the next update is laid over, and what `with()` starts from.
+     */
+    private configured;
+    private _sandbox;
+    private _schema;
+    /**
+     * The client's locale as it is when a call is made. Every sub-client and builder is handed this
+     * rather than a copy of the locale, so one taken before `updateConfig({ locale })` sends the new
+     * locale, or none after `locale: null` (REL-1453).
+     */
+    private readonly currentLocale;
+    /**
+     * The client `with()` was called on, for a client it made: whose key, base URL and configuration
+     * this one reads with as they are when each request is sent. `undefined` for a client
+     * `createClient()` made, which reads its own.
+     */
+    private parent;
+    /** What `with()` gave this client over its parent's: the locale and dataset it names, and no other. */
+    private defaults;
+    /** The live edge's poll client id: chosen once, when first needed, and kept for this client's life. */
+    private _liveClientId;
+    constructor(config: TypedClientConfig<TSchema>);
+    /**
+     * The `relyio dev` sandbox this client resolved at construction, as the preview toolbar displays
+     * it (`sdk-surfaces-spec.md` decision 22).
+     *
+     * Plain, JSON-serializable data and no key, so a server component can hand it to a client
+     * component as a prop — the browser cannot read the handshake itself, so a client created there
+     * reports `absent`. See {@link SandboxState} for what each state means.
+     *
+     * @example
+     * ```tsx
+     * // app/layout.tsx — a server component handing the state to a client component
+     * <SandboxBadge sandbox={relyio.sandbox} />
+     * ```
+     */
+    get sandbox(): SandboxState;
+    /**
+     * Run a query in one call (REL-2421, REL-2409 Q22):
+     *
+     * - `query({ from, … })` runs one inline, with `list`'s option names — `where` (the query
+     *   route's dialect), `include`, `select`, `sort`, `limit`, `page`, `locale`, `dataset`, `fresh` —
+     *   plus `aggregate`, `params` and `fullText`;
+     * - `query(name, { params, … })` runs the saved query the schema declares under `name`, its
+     *   `params` typed from that declaration.
+     *
+     * Both answer the API's body, `{ data: { result, metadata } }`. See {@link QueryCall}. Every query
+     * is sent in the client's locale as it is then, unless it names its own.
+     */
+    get query(): QueryCall<TSchema>;
+    /**
+     * Get a content client for a specific content type
+     * Type-safe when schema is provided: autocompletes content type names AND field names
+     *
+     * @example
+     * ```typescript
+     * const { data: products } = await relyio.content('product').list({
+     *   where: { status: 'active' }, // ← Field names autocomplete with schema!
+     *   locale: 'en-US',
+     *   limit: 20,
+     * })
+     * ```
+     */
+    content<K extends TSchema extends AnySchemaDefinition ? SchemaContentTypeNames<TSchema> : string>(contentType: K): TSchema extends AnySchemaDefinition ? ContentClient<InferContentType<TSchema['contentTypes'][K & keyof TSchema['contentTypes']], TSchema>, ContentReading<TSchema['contentTypes'][K & keyof TSchema['contentTypes']], TSchema>> : ContentClient<BaseContent>;
+    /**
+     * Get an asset client for a specific asset type.
+     *
+     * Reads and writes as `content()` does — `list`, `get`, `listAll`, `update`, `delete` — over
+     * `entryType: 'asset'` entries on the same dynamic `/{assetTypeId}` routes, and adds `create`,
+     * the `file(entryUid)` sub-resource builder and a high-level `upload()` helper. Type-safe when a schema is
+     * provided: autocompletes asset type names AND metadata field names.
+     *
+     * @example
+     * ```typescript
+     * const photo = await relyio.asset('productPhoto').upload(file)
+     *   .filename('shoe.jpg')
+     *   .visibility('public')
+     *   .execute()
+     *
+     * const heroUrl = await relyio.asset('productPhoto').file(photo._metadata.id).url({ variantId: 'hero' })
+     * ```
+     */
+    asset<K extends TSchema extends AnySchemaDefinition ? SchemaAssetTypeNames<TSchema> : string>(assetType: K): TSchema extends AnySchemaDefinition ? AssetClient<InferAssetType<NonNullable<TSchema['assetTypes']>[K & keyof NonNullable<TSchema['assetTypes']>], TSchema>, AssetReading<NonNullable<TSchema['assetTypes']>[K & keyof NonNullable<TSchema['assetTypes']>], TSchema>> : AssetClient<BaseContent>;
+    /**
+     * Get a singleton client for a specific singleton key
+     * Type-safe when schema is provided: autocompletes singleton names AND field names
+     *
+     * @example
+     * ```typescript
+     * const homepage = await relyio.singleton('homepage').get({
+     *   include: ['featuredProducts'],
+     *   locale: 'en',
+     * })
+     * ```
+     */
+    singleton<K extends TSchema extends AnySchemaDefinition ? SchemaSingletonNames<TSchema> : string>(key: K): TSchema extends AnySchemaDefinition ? SingletonClient<InferSingleton<TSchema['singletonContentTypes'][K & keyof TSchema['singletonContentTypes']], TSchema>, SingletonReading<TSchema['singletonContentTypes'][K & keyof TSchema['singletonContentTypes']], TSchema>> : SingletonClient<BaseSingleton>;
+    /**
+     * Get a settings client for a specific settings group
+     * Type-safe when schema is provided: autocompletes settings group names AND field names
+     *
+     * @example
+     * ```typescript
+     * const emailConfig = await relyio.settings('email-config').get({
+     *   include: ['defaultTemplate'],
+     * })
+     * ```
+     */
+    settings<K extends TSchema extends AnySchemaDefinition ? SchemaSettingsGroupNames<TSchema> : string>(groupId: K): TSchema extends AnySchemaDefinition ? SettingsClient<InferSettingsGroup<NonNullable<TSchema['settingsGroups']>[K & keyof NonNullable<TSchema['settingsGroups']>], TSchema>, SettingsReading<NonNullable<TSchema['settingsGroups']>[K & keyof NonNullable<TSchema['settingsGroups']>], TSchema>> : SettingsClient<BaseSettingsGroup>;
+    /**
+     * Search, one page at a time: `search(q, options)` (REL-2420, REL-2409 Q19).
+     *
+     * Pages by number — `page` and `limit` — and answers the API's `{ data, page, meta }`, the page
+     * `{ number, limit, total, pageCount }`: `total` counts every entry the search matched, so "page 2
+     * of 3" needs no arithmetic. Where a schema types the client, `contentType`, `select`,
+     * `searchFields`, `sort` and `locale` are checked against it and the hits are its entries — every
+     * content type's when `contentType` is left out (`INV-SS-TYPES-INFERRED`).
+     *
+     * @example
+     * ```typescript
+     * const { data, page } = await relyio.search('wireless headphones', {
+     *   contentType: 'product',
+     *   where: { status: 'active' },
+     *   page: 2,
+     *   limit: 20,
+     * })
+     * console.log(`page ${page.number} of ${page.pageCount}`)
+     * ```
+     */
+    search<K extends SearchTypeName<TSchema> = SearchTypeName<TSchema>, const S extends readonly SearchFieldKey<SearchEntry<TSchema, K>>[] | undefined = undefined>(query: string, options: SearchOptions<K, SearchEntry<TSchema, K>, LocaleCodeOf<TSchema>, SearchWhere<TSchema, K>, S>): Promise<SearchPage<SearchSelected<SearchEntry<TSchema, K>, S>>>;
+    /**
+     * Suggestions completing `query` in one Field: `autocomplete(q, options)` (REL-2420).
+     *
+     * @example
+     * ```typescript
+     * const { data } = await relyio.autocomplete('wire', { contentType: 'product', field: 'title' })
+     * ```
+     */
+    autocomplete<K extends SearchTypeName<TSchema>>(query: string, options: AutocompleteOptions<K, SearchEntry<TSchema, K>, LocaleCodeOf<TSchema>, SearchWhere<TSchema, K>>): Promise<AutocompleteResponse>;
+    /**
+     * The entries most like the entry `sourceId`, by its stored vector: `similar(id, options)`
+     * (REL-2420). Every content type's neighbours unless `contentType` names some.
+     *
+     * @example
+     * ```typescript
+     * const { data } = await relyio.similar('entry_abc123', { contentType: 'product', limit: 5 })
+     * ```
+     */
+    similar<K extends SearchTypeName<TSchema> = SearchTypeName<TSchema>, const S extends readonly SearchFieldKey<SearchEntry<TSchema, K>>[] | undefined = undefined>(sourceId: string, options: SimilarOptions<K, SearchEntry<TSchema, K>, LocaleCodeOf<TSchema>, S>): Promise<SimilarResponse<SearchSelected<SearchEntry<TSchema, K>, S>>>;
+    /**
+     * Write a list of operations in one request (REL-2421, REL-2409 Q22): each a create, update,
+     * replace or delete of an entry, or a singleton write.
+     *
+     * An update, replace or delete takes the **entry you read** — checked against the version it
+     * carries, in the locale it was read in, as `update(entry, data)` is — or an **id**, which writes
+     * unchecked, on purpose. A stale entry fails its operation with `RESOURCE_CONFLICT` naming the
+     * versions that disagreed: re-read it with `fresh: true` and retry. With `atomic: true` nothing
+     * in the batch is written then — and the API takes an atomic batch only when every operation is
+     * the same kind of write.
+     *
+     * Answers the API's body, `{ data: { results, summary } }`: one result per operation, in order,
+     * each an `outcome` or an `error`. An operation that failed is not thrown.
+     *
+     * @example
+     * ```typescript
+     * const post = await relyio.content('post').get('hello-world')
+     * const { data } = await relyio.batch([
+     *   { create: 'post', data: { title: 'New' } },
+     *   ...(post ? [{ update: 'post' as const, entry: post, data: { title: 'Changed' } }] : []),
+     *   { delete: 'post', id: 'entry_xyz' },
+     *   { singleton: 'homepage', data: { hero: 'Welcome!' } },
+     * ])
+     * console.log(data.summary.succeeded)
+     * ```
+     */
+    batch(operations: readonly BatchWrite<TSchema>[], options?: BatchWriteOptions): Promise<BatchBody>;
+    /**
+     * Follow the dataset's changes feed: each write this key can see, as ids, in
+     * order, long-polled from `GET /v1/changes`.
+     *
+     * Lazy — nothing is requested until the first `next()`. It runs until
+     * `signal` aborts, which ends the `for await` cleanly rather than throwing.
+     * A change names what changed; refetch it through the ordinary read path
+     * (`INV-SS-CHANGE-IS-IDS`), naming its `fresh` so no cache answers with the
+     * body from before it (`FeedChange`).
+     *
+     * @example
+     * ```typescript
+     * const controller = new AbortController()
+     * for await (const change of relyio.changes({ since: cursor, types: ['post'], signal: controller.signal })) {
+     *   // { entryId, contentType, locale, kind, cursor, fresh }
+     *   await relyio.content(change.contentType).get(change.entryId, { fresh: change.fresh })
+     * }
+     * ```
+     *
+     * @example Resync when the cursor has expired
+     * ```typescript
+     * for await (const change of relyio.changes({
+     *   since: cursor,
+     *   onExpired: async expired => refetchEverything(expired.fresh),
+     * })) { … }
+     * ```
+     */
+    changes(options?: ChangesOptions): AsyncIterable<FeedChange>;
+    /**
+     * Follow the dataset's **published** changes at RelyIO's live edge, with a publishable key
+     * (`rly_pub_…`): each change as ids, in order — the transport a browser follows changes with.
+     *
+     * A WebSocket to the edge, from `since` or the dataset's current position; where a socket cannot
+     * open — the runtime has none, the network refuses it, or it has not opened and been told its
+     * position within `LIVE_SOCKET_OPEN_TIMEOUT_MS` — it polls the edge instead, about every fifteen
+     * seconds, from the same cursor. The edge is `liveUrl`, or derived from the default `baseUrl`
+     * (see `RelyIOConfig.liveUrl`).
+     *
+     * Without `since` it starts at the dataset's current position, which it hands `reached` before
+     * anything after it: read what you show after that call, and a publish your read did not see is
+     * one this subscription announces (see `LiveChangesOptions.since`).
+     *
+     * One subscription ends only when `signal` aborts, which ends the `for await` cleanly; every other
+     * end — a socket a deploy dropped, a refusal, a refused poll — is thrown as a `LiveEdgeError`
+     * that says whether to stop, retry or back off. Hand it to `followChanges()`, the one loop that
+     * reconnects from the last cursor with jittered back-off and honours those answers:
+     *
+     * @example
+     * ```typescript
+     * const relyio = createClient({ apiKey: 'rly_pub_…' })
+     * const controller = new AbortController()
+     * await followChanges(from => relyio.liveChanges({ ...from, types: ['post'] }), {
+     *   signal: controller.signal,
+     *   // `fresh` names a position no cache holds a body for from before the change.
+     *   onChange: change =>
+     *     relyio.content(change.contentType).get(change.entryId, { fresh: change.fresh }),
+     *   onResync: resync => refetchEverything(resync.cause === 'expired' ? resync.expired.fresh : undefined),
+     * })
+     * ```
+     *
+     * A client without a publishable key sends nothing: a secret or preview key is never put in the
+     * edge's URL. On a server, follow `changes()` with it instead.
+     */
+    liveChanges(options?: LiveChangesOptions): AsyncIterable<FeedChange>;
+    /**
+     * The dataset's current position in the changes feed, as a cursor to start
+     * `changes({ since })` or `followChanges(…, { since })` from. One
+     * `GET /v1/changes` without a cursor: answered at once, holding nothing.
+     *
+     * Take it **before** you read what you will follow. A write your read did not
+     * see is then after the position and replayed; opening the feed afterwards
+     * without a `since` starts after it and misses it.
+     *
+     * @example
+     * ```typescript
+     * const since = await relyio.changesHead()
+     * const post = await relyio.content('post').get(id)
+     * for await (const change of relyio.changes({ since, ids: [id] })) { … }
+     * ```
+     */
+    changesHead(options?: ChangesHeadOptions): Promise<string>;
+    /**
+     * Describe the project this key resolves to — `GET /v1/project`.
+     *
+     * `dataset` is the one this client's requests select (`dataset`, a sandbox from the `relyio dev`
+     * handshake, or the key's default), which is not always the project's default, so a Studio link
+     * built from `studioUrl` should carry it as `?dataset=`. `studioUrl` is `null` — a value, not an
+     * error — when the service has no Dashboard address configured.
+     *
+     * @example
+     * ```typescript
+     * const { studioUrl, dataset } = await relyio.project()
+     * if (studioUrl !== null) window.open(`${studioUrl}?dataset=${dataset.id}`)
+     * ```
+     */
+    project(): Promise<Project>;
+    /**
+     * The schema definition the key's branch has deployed, as stored — `GET /v1/meta/schema` — or,
+     * given a content type or singleton id, that one type's definition — `GET /v1/meta/schema/{id}`.
+     *
+     * It answers what the deployed schema declares; `project()` answers where the key points
+     * (organization, project, dataset, branch, Studio link). The two share no field.
+     *
+     * @example
+     * ```typescript
+     * const definition = await relyio.schema('post')
+     * ```
+     */
+    schema(contentType?: string): Promise<unknown>;
+    /**
+     * The content types and singletons the key's branch has deployed — `GET /v1/meta/content-types`.
+     *
+     * Each is named by its `id` (what `content()` and `singleton()` take), its `name` (the schema's
+     * `displayName`) and its `type`, content types first, each group in the order the schema declares it.
+     *
+     * @example
+     * ```typescript
+     * const types = await relyio.contentTypes()
+     * const singletons = types.filter(type => type.type === 'singleton').map(type => type.id)
+     * ```
+     */
+    contentTypes(): Promise<DeployedContentType[]>;
+    /**
+     * Whether the API can serve requests now — `GET /health/ready`.
+     *
+     * Resolves `{ status: 'ok', timestamp }` when the API answers and reaches every store it reads.
+     * Rejects otherwise, with the error the request met: a `503` naming the store that did not answer,
+     * or a network error when the API could not be reached at all. So there is no `status` to check:
+     * a call that resolves is the healthy answer.
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await relyio.health()
+     * } catch (error) {
+     *   console.error('RelyIO cannot serve now', error)
+     * }
+     * ```
+     */
+    health(): Promise<Health>;
+    /**
+     * Change some of the client's options and keep the rest.
+     *
+     * What you pass is laid over the configuration the client holds, field by field:
+     *
+     * - an option you name replaces the value the client holds;
+     * - an option left out, or given as `undefined`, keeps the value the client holds;
+     * - an option with no default given as `null` is cleared — `locale`, `dataset`, `apiKey`, `dev`,
+     *   `fetch`, `browser.onCorsError`, `realtime.wsUrl`, `debug.logger` — so the client runs as though
+     *   it had never been given one. An option with a default takes no `null`;
+     * - a bag of options you name — `browser`, `cache`, `realtime`, `debug` — keeps every field of it
+     *   you do not name, so `updateConfig({ browser: { includeCredentials: true } })` keeps a
+     *   configured `onCorsError`;
+     * - `headers` is laid over the headers the client sends, a name matched without regard to case: a
+     *   header you name is added or replaces every spelling of it, every other one is still sent, and a
+     *   header given as `null` is no longer sent;
+     * - naming `apiKey` — a key, or `null` — replaces every key the client holds, one given in
+     *   `headers` included.
+     *
+     * The configuration it is laid over is what `createClient()`, `setApiKey()` and earlier updates
+     * gave the client. The `relyio dev` handshake is read again, as `createClient()` reads it: while a
+     * sandbox is active its key and dataset are sent over the configured ones, and once it has gone
+     * the configured ones are.
+     *
+     * The client's one HTTP client is changed in place, so every request from now on is sent as the
+     * update says — including one from a `content()`, `asset()`, `singleton()` or `settings()`
+     * sub-client taken before the call. The locale reaches them too: each reads the client's locale
+     * when it sends, so a new `locale` is the default of its next request and `locale: null` leaves
+     * that request with none. A locale the call names still wins over it, and so does the locale of a
+     * client `with({ locale })` made from this one.
+     *
+     * @example
+     * ```typescript
+     * const relyio = createClient({ apiKey, headers: { 'X-Tenant': 'acme' }, browser: { onCorsError } })
+     *
+     * relyio.updateConfig({ headers: { 'X-Trace': traceId } }) // X-Tenant is still sent
+     * relyio.updateConfig({ browser: { includeCredentials: true } }) // onCorsError is kept
+     * relyio.updateConfig({ headers: { 'X-Tenant': null } }) // X-Tenant is no longer sent
+     * relyio.updateConfig({ locale: null }) // reads name no locale of the client's
+     * ```
+     */
+    updateConfig(update: RelyIOConfigUpdate): void;
+    /**
+     * Get the current configuration
+     */
+    getConfig(): Readonly<MergedRelyIOConfig>;
+    /**
+     * Replace the API key every later request sends as `X-API-Key`.
+     *
+     * It reaches every request this client makes from now on, including those of a `content()`,
+     * `asset()` or other sub-client taken before the call, and `getConfig().apiKey` reports it. A key
+     * given in `headers`, under any spelling, is replaced with it and does not come back on a later
+     * `updateConfig()`. A client `with()` made from this one sends the new key too: the two share one
+     * connection.
+     *
+     * An empty or blank key is no key, as it is when passed to `createClient`: the next request
+     * rejects with `MissingApiKeyError` and nothing is sent.
+     *
+     * Under an active `relyio dev` sandbox the sandbox's scoped key stands, as it does over the key
+     * passed to `createClient` — replacing the configured key does not retarget the client at the
+     * sandbox's dataset with a key the sandbox did not issue.
+     *
+     * @example
+     * ```typescript
+     * const relyio = createClient({ apiKey: process.env.RELYIO_API_KEY! })
+     * relyio.setApiKey(rotatedKey) // the next read sends `X-API-Key: <rotatedKey>`
+     * ```
+     */
+    setApiKey(apiKey: string): void;
+    /**
+     * Get the HTTP client instance (for advanced usage)
+     */
+    getHttpClient(): HttpClient;
+    /**
+     * Get the current default locale
+     */
+    getLocale(): string | undefined;
+    /**
+     * A client whose reads and writes are in `locale` and `dataset` unless a call names its own, and
+     * which otherwise **follows this one** (REL-2417, Q9): it sends this client's key, to this
+     * client's base URL, under this client's configuration as it is when each request is sent — so a
+     * later `setApiKey()` or `updateConfig()` here reaches it. A default it does not name is this
+     * client's, as this client changes it.
+     *
+     * The two share one connection, so a `setApiKey()` or `updateConfig()` called on the client made
+     * here changes this one too. A call's own `locale` or `dataset` wins over the defaults.
+     *
+     * @example
+     * ```typescript
+     * const staging = relyio.with({ dataset: 'staging' })
+     * const { data } = await staging.content('post').list({ limit: 10 })
+     *
+     * const french = relyio.with({ locale: 'fr-FR' }) // ← autocompletes the schema's locales
+     * ```
+     */
+    with(defaults: ClientDefaults<TSchema>): TypedRelyIOClient<TSchema>;
+    /** Make this client one `with()` made from `parent`: see {@link with}. */
+    private follow;
+    /**
+     * The configuration as given, before the `relyio dev` handshake — this client's own, or for a
+     * client `with()` made, its parent's with its defaults laid over it.
+     */
+    private configuredNow;
+    /**
+     * Every locale the key's branch has deployed, the default marked — `GET /v1/meta/locales`.
+     *
+     * In the order the schema declares them. Exactly one has `default: true`, the locale a read or
+     * write that names none is in; every other has `default: false`. `fallback`, `direction` and
+     * `active` are as the schema declares them, absent where it does not.
+     *
+     * @example
+     * ```typescript
+     * const locales = await relyio.locales()
+     * const defaultLocale = locales.find(locale => locale.default)?.code
+     *
+     * // Build a language switcher
+     * const options = locales.map(locale => ({ code: locale.code, label: locale.displayName }))
+     * ```
+     */
+    locales(): Promise<DeployedLocale[]>;
+}
+/**
+ * Create a RelyIO client
+ *
+ * @example Without schema (dynamic usage)
+ * ```typescript
+ * import { createClient } from '@relyio/sdk'
+ *
+ * const relyio = createClient({
+ *   apiKey: process.env.RELYIO_API_KEY!,
+ * })
+ *
+ * // Works but no autocomplete for content types
+ * const { data: products } = await relyio.content('product').list()
+ * ```
+ *
+ * @example With schema (fully typed)
+ * ```typescript
+ * import { createClient } from '@relyio/sdk'
+ * import { schema } from './schema'
+ *
+ * const relyio = createClient({
+ *   apiKey: process.env.RELYIO_API_KEY!,
+ *   schema,
+ * })
+ *
+ * // Content type names autocomplete!
+ * const { data: products } = await relyio.content('product').list()
+ * ```
+ *
+ * @example After `relyio generate-types` (inferred, `INV-SS-TYPES-INFERRED`)
+ * ```typescript
+ * import { createClient } from '@relyio/sdk'
+ *
+ * // The generated `schema.ts` augments `Register`, so no generic and no `schema:` are needed
+ * const relyio = createClient({ apiKey: process.env.RELYIO_API_KEY! })
+ * ```
+ *
+ * The overload without a schema comes first on purpose. Behind the generic one it was never
+ * chosen: with no `schema` to infer from, `TSchema` fell back to its constraint and the call
+ * resolved to `TypedRelyIOClient<AnySchemaDefinition>`. First, it takes every call that passes no
+ * schema, and returns the registered schema's client — or the untyped one when nothing registered.
+ * A `schema:` value fails its `schema?: undefined`, and an explicit generic skips it because it has
+ * no type parameter, so both reach the generic overload unchanged.
+ */
+declare function createClient(config: RelyIOConfig & {
+    schema?: undefined;
+}): TypedRelyIOClient<RegisteredSchema>;
+declare function createClient<TSchema extends AnySchemaDefinition>(config: TypedClientConfig<TSchema>): TypedRelyIOClient<TSchema>;
+/**
+ * Helper type to extract schema from client
+ */
+type ClientSchema<T extends TypedRelyIOClient<AnySchemaDefinition>> = T extends TypedRelyIOClient<infer TSchema> ? TSchema : never;
+
+export { type ListOptions as $, type AnySchemaDefinition as A, type EntryWriteOptions as B, type Change as C, type DeployedLocale as D, type EntryPlacement as E, type FeedChange as F, SingletonClient as G, type Health as H, SettingsClient as I, type DocumentFields as J, type DocumentVersion as K, type LocaleCodeOf as L, type MatchRouteOptions as M, type DocumentVersionsOptions as N, type DocumentWriteOptions as O, type Project as P, type ChildrenOptions as Q, type Register as R, type SandboxState as S, TypedRelyIOClient as T, type DocumentReadOptions as U, type EntryList as V, type Wire as W, type FieldKey as X, type FreshOption as Y, type GetOptions as Z, type ListAllOptions as _, ChangesExpiredError as a, type PresignInput as a$, type LocaleOption as a0, type Paging as a1, type ReadAs as a2, type ReadLocale as a3, type SortOption as a4, type VersionOptions as a5, type WrittenReadScope as a6, type WrittenSort as a7, type SearchResultItem as a8, type SearchHitMetadata as a9, type BatchReplace as aA, type BatchDelete as aB, type BatchSingletonWrite as aC, type BatchTarget as aD, type BatchDeleteTarget as aE, type AggregateMetric as aF, type QueryMetadata as aG, type AdhocQuery as aH, type AdhocRecord as aI, type NamedQueryOptions as aJ, type NamedQueryParams as aK, type QueryAggregate as aL, type QueryAnswer as aM, type QueryCall as aN, type QueryName as aO, type QueryTypeName as aP, AssetClient as aQ, AssetFileBuilder as aR, AssetUploadBuilder as aS, isAssetEntry as aT, type AssetVisibility as aU, type FileStatus as aV, type FileBackend as aW, type AssetFileExtracted as aX, type FileStatusResult as aY, type AssetEntryResponse as aZ, type PopulatedAssetReference as a_, type SearchResponse as aa, type AutocompleteSuggestion as ab, type AutocompleteResponse as ac, type SimilarResult as ad, type SimilarResponse as ae, type SearchTypeName as af, type SearchEntry as ag, type AutocompleteOptions as ah, type SearchFacet as ai, type SearchFieldKey as aj, type SearchHighlight as ak, type SearchOptions as al, type SearchPage as am, type SearchScope as an, type SearchSelected as ao, type SearchSortOption as ap, type SearchWhere as aq, type SimilarOptions as ar, type BatchOperationResult as as, type BatchSummary as at, type BatchResponse as au, type BatchWrite as av, type BatchWriteOptions as aw, type BatchBody as ax, type BatchCreate as ay, type BatchUpdate as az, type ChangesExpiredReason as b, type PresignResult as b0, type ConfirmInput as b1, type ConfirmResult as b2, type ResolveUrlInput as b3, type ResolveUrlResult as b4, type CreateAssetOptions as b5, type AssetPlacement as b6, type UpdateAssetOptions as b7, type WaitUntilReadyOptions as b8, type MultipartCreateResult as b9, type MultipartPart as ba, type MultipartTarget as bb, type UploadProgress as bc, ResourceNotFoundError as bd, ResourceConflictError as be, ResourceExpiredError as bf, isResourceNotFound as bg, isMissingEntry as bh, type FileErrorCode as bi, type FileUploadErrorCode as bj, FileUploadError as bk, FileValidationError as bl, type FileValidationConstraints as bm, validateFile as bn, createClient as c, type TypedClientConfig as d, type ClientDefaults as e, type ClientSchema as f, type DeployedContentType as g, type RegisteredSchema as h, type ActiveSandbox as i, HttpClient as j, type SendOptions as k, type ApiPath as l, type ApiMethod as m, type ApiSuccessBody as n, matchRoute as o, type RouteMatch as p, type ReadEntry as q, type RetryableWriteOptions as r, type ChangesHeadOptions as s, type ChangesOptions as t, LIVE_KEEPALIVE_INTERVAL_MS as u, versionCheckOf as v, LIVE_SOCKET_OPEN_TIMEOUT_MS as w, type LiveChangesOptions as x, ContentClient as y, type CreateEntryOptions as z };