@relyio/sdk 0.13.0 → 0.15.0

package/dist/index-BT0L8xJj.d.cts

@@ -1,3717 +0,0 @@
-import { cj as MergedRelyIOConfig, bC as ApiPath, bD as ApiMethod, ck as PathParamsOf, ca as ApiResponse, bF as Wire, c9 as RequestConfig, bL as BaseContent, ae as Reading, ai as UntypedReading, cl as ReadWhere, bO as WhereClause, bS as QueryOptions, aa as CheckedIncludes, af as ReadWith, bR as SortOptions, bX as ContentQueryResult, bT as CreateInput, bW as UpdateInput, bU as RevisedContent, bV as RestoredContent, bx as SDKError, cg as BaseValidationError, cf as ValidationViolation, aJ as AssetServedBlocks, cm as CheckedInclude, cn as components, bJ as AssetFileBlock, co as paths, by as RelyIOConfig, aq as InferContentType, ac as ContentReading, aH as InferAssetType, a9 as AssetReading, ay as InferSingleton, ah as SingletonReading, aD as InferSettingsGroup, ag as SettingsReading, bz as RelyIOConfigUpdate } from './include-paths-Bs5FhNw2.cjs';
-import { a as SchemaDefinition, b as SchemaContentTypeNames, j as SchemaEntryOf, a8 as FilterOperator, h as SchemaAssetTypeNames, c as SchemaSingletonNames, g as SchemaSettingsGroupNames, e as SchemaQueryNames, f as SchemaLocaleCodes } from './define-schema-sWJ8Zn7C.cjs';
-import { VisitorResyncReason } from './live-visitor.js';
-import { DevUnreadableReason } from './dev-handshake/index.cjs';
-
-/**
- * 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. The document declares none, so this stays untyped — see `api-routes.ts`. */
-    query?: Record<string, unknown>;
-    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;
-    constructor(config: MergedRelyIOConfig);
-    /**
-     * 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;
-}
-
-/**
- * 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 sub-client's own `withLocale()`, or one built directly — and stays what it
- * was.
- */
-type ClientLocale = string | (() => string | undefined);
-
-/**
- * Children population options
- */
-interface ChildrenOptions {
-    /** Content types of children to include */
-    contentTypes?: string[];
-    /** Maximum children per entry */
-    limit?: number;
-    /** Recursion depth */
-    depth?: number;
-}
-/**
- * Retained as an alias of {@link ContentQueryResult}.
- *
- * It used to add an optional `pagination: { page, pageSize, pageCount, total }`
- * that the list route emitted only when `withCount` arrived — "a shape no
- * generated type can describe", as that controller's own comment now puts it.
- * API2 made the customer list the **cursor** dialect unconditionally
- * (`INV-API-ONE-CUSTOMER-PAGE-DIALECT`), so no total reaches this surface and
- * the extra member described a body the service cannot send.
- */
-type ExtendedQueryResult<T extends BaseContent = BaseContent> = ContentQueryResult<T>;
-/**
- * Fluent query builder for content operations
- * Provides a chainable API for building complex content queries
- *
- * @example
- * ```typescript
- * const products = await client.content('product')
- *   .query()
- *   .where({ status: 'active' })
- *   .locale('en')
- *   .fields(['id', 'title', 'price'])
- *   .include(['brand', 'categories'])
- *   .sort({ title: 'asc' })
- *   .limit(20)
- *   .execute()
- * ```
- */
-declare class ContentQueryBuilder<T extends BaseContent = BaseContent, F extends BaseContent = T, R extends Reading = UntypedReading<T>, I extends string = never> {
-    private readonly httpClient;
-    private readonly contentType;
-    private queryOptions;
-    private localeValue?;
-    private localesArray?;
-    private fetchAllLocales;
-    private fieldsProjection?;
-    private childrenOptions?;
-    private pageNumber?;
-    private pageSizeValue?;
-    private requestHeaders?;
-    /** The client's locale, asked when the query is sent rather than copied when it was built. */
-    private readonly clientLocale;
-    private freshValue?;
-    /**
-     * @param locale - The client's locale (`withLocale()`, `updateConfig({ locale })`), sent when the
-     *   query names none: the function `TypedRelyIOClient` hands over, or a locale fixed for it
-     */
-    constructor(httpClient: HttpClient, contentType: string, locale?: ClientLocale);
-    /**
-     * The feed position this read follows — a change's `fresh` (`FeedChange`), or a resync's. Sent as
-     * `?_fresh`, the one term the API declares for it: no cache — the Content API's edge or the
-     * browser's own — holds an answer for that position from before it, so the read is answered after
-     * the change, and every read naming the same position shares that answer. The answer is the
-     * read's own; omit it for a read no change prompted.
-     */
-    fresh(position: string): this;
-    /**
-     * Headers this query adds to the client's own, e.g. `X-RelyIO-Dataset` to list another dataset
-     * the key can see. A name the client already sends is replaced for this query only; the client
-     * is not changed.
-     */
-    headers(headers: Record<string, string>): this;
-    /**
-     * Add where conditions to the query, each naming a value by its path: a field the content type
-     * declares, a field inside an object (`'pricing.basePrice'`), a reference inside its blocks —
-     * `{ 'sections.features': featureId }` keeps the entries some block of which holds that feature
-     * (REL-1810) — and rich text that can point at an entry, by the entries it points at. A typed read
-     * takes exactly the paths the API filters by (`FilterPaths`, REL-2136). A condition on `_metadata`
-     * is refused here, before anything is sent (`refuseMetadataConditions`).
-     */
-    where(conditions: ReadWhere<WhereClause<F>, R>): this;
-    /**
-     * Select specific fields to return
-     */
-    select(fields: NonNullable<QueryOptions<T, F>['select']>): this;
-    /**
-     * Expand references into the entries they point at: one include path per element (REL-1801).
-     * A path names fields through lists, page builders, objects and references —
-     * `'sections.features'`, `'sections.customers.logo'` — and may pick the fields each entry returns,
-     * `'sections.features(name,slug)'`. Each is checked against the schema: a path that holds no
-     * reference does not compile, and the read's type follows the paths — an expanded reference is the
-     * entry, every other one its id.
-     */
-    include<const P extends readonly string[]>(paths: CheckedIncludes<R, P>): ContentQueryBuilder<Extract<ReadWith<R, I | P[number]>, BaseContent>, F, R, I | P[number]>;
-    /**
-     * Add sorting to the query
-     *
-     * @example
-     * ```typescript
-     * // Object format
-     * .sort({ createdAt: 'desc', title: 'asc' })
-     *
-     * // Field and direction format
-     * .sort('createdAt', 'desc')
-     * ```
-     */
-    sort(field: string, direction: 'asc' | 'desc'): this;
-    sort(sortOptions: SortOptions<F>): this;
-    /**
-     * Sort by a specific field in ascending order
-     */
-    sortAsc(field: keyof T | string): this;
-    /**
-     * Sort by a specific field in descending order
-     */
-    sortDesc(field: keyof T | string): this;
-    /**
-     * Limit the number of results
-     */
-    limit(count: number): this;
-    /**
-     * Set offset for pagination
-     */
-    offset(count: number): this;
-    /**
-     * Set cursor for cursor-based pagination
-     */
-    cursor(cursor: string): this;
-    /**
-     * Set locale for localized content
-     * @param locale - Locale code (e.g., 'en-US', 'de-DE', 'fr-FR')
-     *
-     * @example
-     * ```typescript
-     * // Fetch in Spanish
-     * .locale('es-ES')
-     * ```
-     */
-    locale(locale: string): this;
-    /**
-     * Fetch content in multiple specific locales
-     * Returns primary locale at top level, others in _metadata.localizations
-     *
-     * @param localeCodes - Array of locale codes to fetch
-     *
-     * @example
-     * ```typescript
-     * const product = await client.content('product')
-     *   .findById('prod_123')
-     *   .locales(['en-US', 'es-ES', 'de-DE'])
-     *   .execute()
-     *
-     * // Access: product.title (first locale)
-     * // Access: product._metadata.localizations['es-ES'].title
-     * ```
-     */
-    locales(localeCodes: string[]): this;
-    /**
-     * Fetch content in all available locales
-     * Returns default locale at top level, others in _metadata.localizations
-     *
-     * @example
-     * ```typescript
-     * const product = await client.content('product')
-     *   .findById('prod_123')
-     *   .allLocales()
-     *   .execute()
-     *
-     * // Access: product.title (default locale)
-     * // Access: product._metadata.localizations['es-ES'].title
-     * // Access: product._metadata.availableLocales
-     * ```
-     */
-    allLocales(): this;
-    /**
-     * Select specific fields to return (projection)
-     * @param fieldNames - Array of field names to include
-     *
-     * @example
-     * ```typescript
-     * .fields(['id', 'title', 'price', 'brand.name'])
-     * ```
-     */
-    fields(fieldNames: string[]): this;
-    /**
-     * Include children in results (for hierarchical content)
-     * @param options - Children options or boolean to enable with defaults
-     *
-     * @example
-     * ```typescript
-     * // Include all children
-     * .children(true)
-     *
-     * // Include with options
-     * .children({ contentTypes: ['variant'], limit: 10 })
-     * ```
-     */
-    children(options: ChildrenOptions | boolean): this;
-    /**
-     * Set page number for page-based pagination
-     * @param pageNum - Page number (1-based)
-     */
-    page(pageNum: number): this;
-    /**
-     * Set page size for page-based pagination
-     * @param size - Items per page
-     */
-    pageSize(size: number): this;
-    /**
-     * Execute the query and return all matching results
-     */
-    execute(): Promise<T[]>;
-    /**
-     * Execute the query and return the whole body — the items under `data`, the
-     * cursor facts under `page`.
-     */
-    executeWithMeta(): Promise<ContentQueryResult<T>>;
-    /**
-     * Execute the query and return a single result (first match)
-     */
-    first(): Promise<T | null>;
-    /**
-     * Get paginated results
-     */
-    paginate(limit?: number): Promise<ContentQueryResult<T>>;
-    /**
-     * Create an async iterator for streaming results
-     */
-    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
-    /**
-     * Execute the query and return all results as an array (for large datasets)
-     */
-    all(): Promise<T[]>;
-    /**
-     * Clone the query builder
-     */
-    clone(): ContentQueryBuilder<T, F, R, I>;
-    /**
-     * Get the current query options
-     */
-    getQueryOptions(): QueryOptions<T, F>;
-    /**
-     * Execute the query and return the whole body.
-     *
-     * Identical to {@link executeWithMeta} now that the list serves one shape;
-     * kept as the name callers already import.
-     */
-    executeWithMetaExtended(): Promise<ExtendedQueryResult<T>>;
-    /**
-     * `count()` and `exists()` are gone, and their absence is the honest answer
-     * rather than an omission (`INV-RD-CAPABILITY-IS-HONEST`).
-     *
-     * `count()` sent `withCount` and read `pagination.total`; API2 moved the
-     * customer list onto the **cursor** dialect, whose page facts are
-     * `{ nextCursor, hasMore }` and nothing else, so no total reaches this
-     * surface at all. Keeping the method would have meant either a request that
-     * always throws or a number assembled from a page the caller happened to
-     * fetch — a count of what was returned, presented as a count of what matched
-     * (rule 6). The plan's §3.3 listed `count` among six methods a type would
-     * repair; what the type actually shows is that the capability is no longer
-     * there. A caller that wants "is there at least one" fetches one and looks at
-     * `data.length`; a caller that wants a true total uses `POST /v1/search`,
-     * which is the offset dialect precisely because a facet-bearing result wants
-     * one (Decision 5).
-     */
-    /**
-     * Build query parameters for the HTTP request
-     */
-    private buildQueryParams;
-}
-/**
- * Specialized query builder for finding by ID
- */
-declare class ContentByIdBuilder<T extends BaseContent = BaseContent, R extends Reading = UntypedReading<T>, I extends string = never> {
-    private readonly httpClient;
-    private readonly contentType;
-    private readonly id;
-    private includeRelations?;
-    private localeValue?;
-    private localesArray?;
-    private fetchAllLocales;
-    private childrenOptions?;
-    private requestHeaders?;
-    /** The client's locale, asked when the read is sent rather than copied when it was built. */
-    private readonly clientLocale;
-    private freshValue?;
-    /**
-     * @param locale - The client's locale (`withLocale()`, `updateConfig({ locale })`), sent when the
-     *   read names none: the function `TypedRelyIOClient` hands over, or a locale fixed for it
-     */
-    constructor(httpClient: HttpClient, contentType: string, id: string, locale?: ClientLocale);
-    /**
-     * The feed position this read follows — a change's `fresh` (`FeedChange`), or a resync's. Sent as
-     * `?_fresh`, the one term the API declares for it: no cache — the Content API's edge or the
-     * browser's own — holds an answer for that position from before it, so the read is answered after
-     * the change, and every read naming the same position shares that answer. The answer is the
-     * read's own; omit it for a read no change prompted.
-     */
-    fresh(position: string): this;
-    /**
-     * Expand references into the entries they point at: one include path per element (REL-1801).
-     * A path names fields through lists, page builders, objects and references —
-     * `'sections.features'`, `'sections.customers.logo'` — and may pick the fields each entry returns,
-     * `'sections.features(name,slug)'`. Each is checked against the schema: a path that holds no
-     * reference does not compile, and the read's type follows the paths — an expanded reference is the
-     * entry, every other one its id. A second call adds to the first.
-     */
-    include<const P extends readonly string[]>(paths: CheckedIncludes<R, P>): ContentByIdBuilder<Extract<ReadWith<R, I | P[number]>, BaseContent>, R, I | P[number]>;
-    /**
-     * Set locale for localized content
-     * @param locale - Locale code (e.g., 'en-US', 'de-DE', 'fr-FR')
-     */
-    locale(locale: string): this;
-    /**
-     * Fetch content in multiple specific locales
-     * Returns primary locale at top level, others in _metadata.localizations
-     *
-     * @param localeCodes - Array of locale codes to fetch
-     */
-    locales(localeCodes: string[]): this;
-    /**
-     * Headers this one read adds to the client's own, e.g. `X-RelyIO-Dataset` to read another dataset
-     * the key can see. A name the client already sends is replaced for this request only; the client
-     * is not changed.
-     */
-    headers(headers: Record<string, string>): this;
-    /**
-     * Fetch content in all available locales
-     * Returns default locale at top level, others in _metadata.localizations
-     */
-    allLocales(): this;
-    /**
-     * Include children in results (for hierarchical content)
-     * @param options - Children options or boolean to enable with defaults
-     */
-    children(options: ChildrenOptions | boolean): this;
-    /**
-     * Execute the query and return the content item
-     */
-    execute(): Promise<T | null>;
-}
-
-/**
- * API4's two request headers, exposed the way the SDK's ergonomics already
- * expose everything else: as options on the call, not as raw headers.
- *
- * `apps/services/api` declares them on exactly six and seven routes
- * respectively (`CONDITIONAL_WRITE_HEADERS` / `RETRYABLE_WRITE_HEADERS` in that
- * service's `contract/routes.ts`), and the API4 closeout is explicit that the
- * ten `/file/*` routes and `POST /batch` declare **neither**, because they
- * write through `@relyio/asset-files` and the batch planner and would silently
- * ignore the header. So these options are on the six and seven methods that
- * reach them and nowhere else: a client that could pass `ifMatch` to a route
- * that ignores it has been told a lie no gate can catch
- * (`INV-RD-CAPABILITY-IS-HONEST`).
- *
- * The tag itself comes from `X-Entity-Tag`, which the single-entity reads serve
- * and the list routes deliberately do not — one header cannot name every
- * member's per-locale version. `entityTagOf` reads it off the response the SDK
- * already returns, so the round trip is "read one, write it back" with no
- * assembly from `_metadata` in between
- * (`INV-API-CONDITIONAL-WRITE-IS-REACHABLE`).
- */
-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;
-}
-/**
- * The six routes that additionally take `If-Match`.
- *
- * A creation has no prior entity to precondition on, so `POST /v1/{contentType}`
- * takes `Idempotency-Key` and not this — which is why the two option types are
- * separate rather than one optional-everything bag.
- */
-interface ConditionalWriteOptions extends RetryableWriteOptions {
-    /**
-     * The `X-Entity-Tag` value a prior read served, sent back as `If-Match`.
-     *
-     * The write applies only if that locale of that entry is still at the version
-     * the tag names; otherwise the service refuses `RESOURCE_CONFLICT` and names
-     * both versions.
-     */
-    ifMatch?: string;
-}
-/**
- * The entity tag a single-entity read served, or `undefined` where the route
- * serves none — a list, or a cache HIT, which cannot know the current version
- * and honestly says nothing rather than serving a stale tag.
- */
-declare function entityTagOf(response: {
-    headers: Record<string, string>;
-}): string | undefined;
-
-/**
- * Content fetch options
- */
-interface ContentFetchOptions<T extends BaseContent = BaseContent, R extends Reading = UntypedReading<T>> {
-    /** Filter conditions: what `query().where()` takes (REL-2136) */
-    where?: ReadWhere<WhereClause<T>, R>;
-    /** Maximum entries to return */
-    limit?: number;
-    /** Entries to skip (offset pagination) */
-    offset?: number;
-    /** Sort configuration */
-    sort?: Record<string, 'asc' | 'desc'>;
-    /**
-     * Include paths: the references to expand (REL-1801) — see `ContentQueryBuilder.include`. Typed
-     * where `fetch` is called with them inline.
-     */
-    include?: readonly string[];
-    /** Locale for localized content */
-    locale?: string;
-    /** Fields to select (projection) */
-    fields?: string[];
-    /** Children population options */
-    children?: ChildrenOptions | boolean;
-}
-/**
- * Content client for managing content operations
- * Provides CRUD operations and query building for a specific content type
- *
- * @example
- * ```typescript
- * const products = client.content('product')
- *
- * // Query with fluent API
- * const active = await products.query()
- *   .where({ status: 'active' })
- *   .locale('en')
- *   .include(['brand'])
- *   .limit(20)
- *   .execute()
- *
- * // Quick fetch
- * const all = await products.fetchAll()
- * ```
- */
-declare class ContentClient<T extends BaseContent = BaseContent, R extends Reading = UntypedReading<T>> {
-    private readonly httpClient;
-    private readonly contentType;
-    /** The client's locale, asked on every call rather than copied when this client was taken. */
-    private readonly clientLocale;
-    /**
-     * @param locale - The client's locale: the function `TypedRelyIOClient` hands over, asked on
-     *   every call, or a locale fixed for this client
-     */
-    constructor(httpClient: HttpClient, contentType: string, locale?: ClientLocale);
-    /**
-     * Create a new query builder for this content type
-     */
-    query(): ContentQueryBuilder<T, T, R>;
-    /**
-     * Find content by ID with fluent options
-     */
-    findById(id: string): ContentByIdBuilder<T, R>;
-    /**
-     * Fetch all content items
-     * @param locale - Optional locale for localized content
-     */
-    fetchAll(locale?: string): Promise<T[]>;
-    /**
-     * Fetch content with query options
-     */
-    fetch<const P extends readonly string[]>(options: Omit<ContentFetchOptions<T, R>, 'include'> & {
-        include: CheckedIncludes<R, P>;
-    }): Promise<Array<ReadWith<R, P[number]>>>;
-    fetch(options?: Omit<ContentFetchOptions<T, R>, 'include'>): Promise<T[]>;
-    /**
-     * Fetch a single content item by ID
-     * @param id - Entry ID or slug
-     * @param options - Fetch options (include, locale, and `headers` this one request adds — e.g.
-     *   `{ 'X-RelyIO-Dataset': 'staging' }` to read a dataset other than the client's)
-     */
-    fetchOne<const P extends readonly string[]>(id: string, options: {
-        include: CheckedIncludes<R, P>;
-        locale?: string;
-        headers?: Record<string, string>;
-    }): Promise<ReadWith<R, P[number]> | null>;
-    fetchOne(id: string, options?: {
-        locale?: string;
-        headers?: Record<string, string>;
-    }): Promise<T | null>;
-    /**
-     * Fetch one entry **and the entity tag that read served**.
-     *
-     * This is the read half of a conditional write. `X-Entity-Tag` is minted from
-     * `(entryUid, locale, localeVersion)` and is exactly what `If-Match` takes,
-     * so a caller reads here, edits, and hands the same string back to `update`
-     * — with nothing to assemble in between
-     * (`INV-API-CONDITIONAL-WRITE-IS-REACHABLE`).
-     *
-     * `entityTag` is `undefined` when the response came from the cache: a cached
-     * body cannot know the current version, and an absent tag beats a stale one
-     * that would refuse the next write.
-     *
-     * Unlike {@link fetchOne}, a missing entry is not `null`: the service's
-     * `RESOURCE_NOT_FOUND` is thrown as it arrived, with the `kind` that says
-     * whether the entry, the content type or the schema was missing. `headers`
-     * are the ones this read adds, as for `fetchOne`.
-     */
-    fetchOneWithTag<const P extends readonly string[]>(id: string, options: {
-        include: CheckedIncludes<R, P>;
-        locale?: string;
-        headers?: Record<string, string>;
-    }): Promise<{
-        entry: ReadWith<R, P[number]>;
-        entityTag?: string;
-    }>;
-    fetchOneWithTag(id: string, options?: {
-        locale?: string;
-        headers?: Record<string, string>;
-    }): Promise<{
-        entry: T;
-        entityTag?: string;
-    }>;
-    /**
-     * Fetch the first content item matching the conditions
-     * @param where - Filter conditions
-     * @param locale - Optional locale
-     */
-    fetchFirst(where?: ReadWhere<WhereClause<T>, R>, locale?: string): Promise<T | null>;
-    /**
-     * Create a new content item
-     * @param data - Content data
-     * @param options - Create options (slug, locale, parentId, sortOrder), and `headers` this one
-     *   request adds — e.g. `{ 'X-RelyIO-Dataset': 'staging' }` to write a dataset other than the
-     *   client's. They are sent, never put in the body; `idempotencyKey` still wins over an
-     *   `Idempotency-Key` among them. `locale` defaults to the client's own (`withLocale()`).
-     */
-    create(data: CreateInput<T>, options?: {
-        slug?: string;
-        locale?: string;
-        parentId?: string;
-        sortOrder?: number;
-        headers?: Record<string, string>;
-    } & RetryableWriteOptions): Promise<T>;
-    /**
-     * Update a content item by ID (partial update)
-     * @param id - Entry ID
-     * @param data - Fields to update
-     * @param options - Update options (slug, locale, parentId, sortOrder), and `headers` this one
-     *   request adds, as for {@link create}. `ifMatch` and `idempotencyKey` win over the same
-     *   header among them. `locale` defaults to the client's own, the locale whose entity tag
-     *   {@link fetchOneWithTag} reads, so the tag it hands back is checked against the same locale.
-     * @returns The entry, its `_metadata.brokenLinks` naming each entry link another entry publishes
-     *   that this revision left pointing nowhere — empty when it took no heading away.
-     */
-    update(id: string, data: UpdateInput<T>, options?: {
-        slug?: string;
-        locale?: string;
-        parentId?: string;
-        sortOrder?: number;
-        headers?: Record<string, string>;
-    } & ConditionalWriteOptions): Promise<RevisedContent<T>>;
-    /**
-     * Delete a content item by ID
-     */
-    delete(id: string, options?: ConditionalWriteOptions): Promise<void>;
-    /**
-     * Check if content exists by ID
-     */
-    exists(id: string): Promise<boolean>;
-    /**
-     * 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 (`withLocale()`), 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;
-    }>>;
-    /**
-     * Get a specific version of an entry.
-     *
-     * `locale` defaults to the client's own (`withLocale()`), else the schema default. Version
-     * numbers are per locale, so version 2 is different content in each one.
-     */
-    version(id: string, versionNumber: number, options?: {
-        locale?: string;
-    }): Promise<T | null>;
-    /**
-     * Revert one locale of an entry to a previous version.
-     *
-     * `locale` is **required**, and that is not a convention: versions are numbered per locale, so
-     * `versionNumber` alone is ambiguous, and defaulting it would silently revert the wrong
-     * translation. 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(id: string, versionNumber: number, locale: string, options?: ConditionalWriteOptions): Promise<RestoredContent<T>>;
-    /**
-     * Get the direct children of a hierarchical entry. The route lists one level and takes no depth
-     * (REL-2195): `{ depth }` was sent as `?depth=`, which the API refused with `400`. A tree nested
-     * under each entry is a list or entry read's `query().children()`.
-     * @param id - Parent entry ID
-     * @param options - Include paths to expand on each child, and the locale to read
-     */
-    children(id: string, options?: {
-        include?: string[];
-        locale?: string;
-    }): Promise<T[]>;
-    /**
-     * Get the content type name
-     */
-    getContentType(): string;
-    /**
-     * Create a new ContentClient for a different content type
-     */
-    ofType<U extends BaseContent = BaseContent>(contentType: string): ContentClient<U>;
-    /**
-     * Create a new ContentClient with a different default locale, fixed: an update of the client's
-     * locale (`updateConfig({ locale })`) does not reach it
-     */
-    withLocale(locale: string): ContentClient<T, R>;
-    /**
-     * Get the default locale as it is now: the client's, or the one `withLocale()` fixed
-     */
-    getDefaultLocale(): string | undefined;
-}
-
-/**
- * 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;
-}
-/** Options for {@link AssetClient.update}: the entry route takes both API4 headers. */
-type UpdateAssetOptions = {
-    slug?: string;
-    locale?: string;
-} & ConditionalWriteOptions;
-/** 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 withLocale;
-    /**
-     * 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 `withLocale()` 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.
-     */
-    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;
-}
-/**
- * Client for a single asset type. Mirrors {@link ContentClient} (CRUD + query
- * over the same dynamic `/{assetType}` routes — assets are `entryType: 'asset'`
- * entries) and adds the `file(uid)` sub-resource builder + an `upload()` helper.
- */
-/**
- * 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>;
-}
-declare class AssetClient<T extends BaseContent = BaseContent, R extends Reading = UntypedReading<T>> {
-    private readonly httpClient;
-    private readonly assetType;
-    /** The client's locale, asked on every call rather than copied when this client was taken. */
-    private readonly clientLocale;
-    /**
-     * @param locale - The client's locale: the function `TypedRelyIOClient` hands over, asked on
-     *   every call, or a locale fixed for this client
-     */
-    constructor(httpClient: HttpClient, assetType: string, locale?: ClientLocale);
-    /**
-     * Create a query builder for this asset type. It resolves asset reads; its conditions name the
-     * asset type's fields, which the `file` and `urls` blocks are not.
-     */
-    query(): ContentQueryBuilder<AssetEntryResponse<T>, T, AssetResponseReading<R, T>>;
-    /** Find an asset entry by id (or slug) with fluent options. */
-    findById(id: string): ContentByIdBuilder<AssetEntryResponse<T>, AssetResponseReading<R, T>>;
-    /** Fetch a single asset entry by id (or slug), or `null` if not found. */
-    fetchOne<const P extends readonly string[]>(id: string, options: {
-        include: CheckedIncludes<R, P>;
-        locale?: string;
-    }): Promise<ReadWith<AssetResponseReading<R, T>, P[number]> | null>;
-    fetchOne(id: string, options?: {
-        locale?: string;
-    }): Promise<AssetEntryResponse<T> | null>;
-    /** Fetch the first asset entry matching the conditions, or `null`. */
-    fetchFirst(where?: ReadWhere<WhereClause<T>, R>, locale?: string): Promise<AssetEntryResponse<T> | null>;
-    /**
-     * 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 (`withLocale()`).
-     */
-    create(data: CreateInput<T>, options?: CreateAssetOptions & RetryableWriteOptions): Promise<AssetEntryResponse<T>>;
-    /**
-     * Update an asset entry's metadata fields (and/or slug). `locale` defaults to the client's own
-     * (`withLocale()`).
-     */
-    update(id: string, data: UpdateInput<T>, options?: UpdateAssetOptions): Promise<AssetEntryResponse<T>>;
-    /** Delete an asset entry (cascades file-byte cleanup + gateway purge). */
-    delete(id: string, options?: ConditionalWriteOptions): Promise<void>;
-    /** 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>;
-    /** Get the asset type id. */
-    getAssetType(): string;
-    /** Get the default locale as it is now: the client's, or the one `withLocale()` fixed. */
-    getDefaultLocale(): string | undefined;
-    /**
-     * Create a new AssetClient for this type with a different default locale, fixed: an update of the
-     * client's locale (`updateConfig({ locale })`) does not reach it.
-     */
-    withLocale(locale: string): AssetClient<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').fetchOne(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>;
-
-/**
- * Singleton fetch options
- */
-interface SingletonFetchOptions {
-    /** Locale for localized content */
-    locale?: string;
-    /**
-     * Include paths: the references to expand (REL-1801), added to the ones `include()` named — see
-     * `include()`. Typed where the call names them inline.
-     */
-    include?: readonly string[];
-    /**
-     * The feed position this read follows — a change's `fresh` (`FeedChange`), or a resync's. Sent as
-     * `?_fresh`: no cache holds an answer for it from before that position, so the read is answered
-     * after the change. The answer is the read's own; omit it for a read no change prompted.
-     */
-    fresh?: string;
-}
-/**
- * Singleton client for managing singleton content operations
- * Provides a fluent API for singleton operations following the same pattern as ContentClient
- *
- * Every call is in the locale it names — the argument (`fetch({ locale })`, `update(data, locale)`,
- * `versions({ locale })`), then `.locale()` — and otherwise in the client's own (`withLocale()`,
- * `updateConfig({ locale })`) as it is when the call is made, as `content()`'s are: reads, the write,
- * and version history alike.
- *
- * @example
- * ```typescript
- * const homepage = await client.singleton('homepage')
- *   .include(['featuredProducts', 'heroImage'])
- *   .locale('en')
- *   .fetch()
- * ```
- */
-declare class SingletonClient<T = unknown, R extends Reading = UntypedReading<T>, I extends string = never> {
-    private httpClient;
-    private singletonKey;
-    private includeFields?;
-    private localeValue?;
-    /** The client's locale, asked on every call rather than copied when this client was taken. */
-    private readonly clientLocale;
-    /**
-     * @param locale - The client's locale: the function `TypedRelyIOClient` hands over, asked on
-     *   every call, or a locale fixed for this client
-     */
-    constructor(httpClient: HttpClient, singletonKey: string, locale?: ClientLocale);
-    /**
-     * Expand references into the entries they point at: one include path per element (REL-1801).
-     * A path names fields through lists, objects and references — `'hero.media.image'`,
-     * `'featured.author'` — and may pick the fields each entry returns, `'featured(title,slug)'`.
-     * Each is checked against the schema: a path that holds no reference does not compile, and the
-     * read's type follows the paths — an expanded reference is the entry, every other one its id. A
-     * second call adds to the first.
-     */
-    include<const P extends readonly string[]>(paths: CheckedIncludes<R, P>): SingletonClient<ReadWith<R, I | P[number]>, R, I | P[number]>;
-    /**
-     * Set locale for localized content
-     * @param locale - Locale code (e.g., 'en', 'de', 'fr')
-     */
-    locale(locale: string): this;
-    /**
-     * Fetch the singleton content
-     * @param options - Optional fetch options (alternative to fluent methods)
-     */
-    fetch<const P extends readonly string[]>(options: Omit<SingletonFetchOptions, 'include'> & {
-        include: CheckedIncludes<R, P>;
-    }): Promise<ReadWith<R, I | P[number]> | null>;
-    fetch(options?: Omit<SingletonFetchOptions, 'include'>): Promise<T | null>;
-    /**
-     * Fetch the singleton **and the entity tag that read served**, which is what
-     * `update`'s `ifMatch` takes (`INV-API-CONDITIONAL-WRITE-IS-REACHABLE`).
-     *
-     * `entityTag` is absent on a cache HIT: a cached body cannot know the current
-     * version, and a stale tag would refuse the very next write.
-     */
-    fetchWithTag(options?: SingletonFetchOptions): Promise<{
-        content: T;
-        entityTag?: string;
-    }>;
-    /**
-     * Update singleton content. The API auto-publishes on PATCH — there is no
-     * separate publish route; calling `update()` writes and publishes.
-     * @param data - The content fields to update
-     * @param locale - Optional locale for localized content (overrides the fluent locale, which
-     *   overrides the client's own)
-     * @param options - `If-Match` / `Idempotency-Key`, both declared on this route
-     */
-    update(data: Partial<T>, locale?: string, options?: ConditionalWriteOptions): Promise<T>;
-    /**
-     * Check if singleton exists
-     */
-    exists(): Promise<boolean>;
-    /**
-     * Get version history for one locale of the singleton.
-     *
-     * Versions are numbered per locale, so this is one locale's timeline: `locale` defaults to the
-     * fluent `.locale()`, then the client's own (`withLocale()`), 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?: {
-        limit?: number;
-        locale?: string;
-    }): Promise<Array<T & {
-        versionNumber: number;
-        locale: string;
-    }>>;
-    /**
-     * Get a specific version of the singleton.
-     *
-     * `locale` defaults to the fluent `.locale()`, then the client's own (`withLocale()`), then the
-     * schema default. Version numbers are per locale, so version 2 is different content in each one.
-     */
-    version(versionNumber: number, options?: {
-        locale?: string;
-    }): Promise<T | null>;
-    /** The locale a write or history read sends: the call's, the fluent one, else the client's. */
-    private localeOf;
-    /**
-     * Get the singleton key
-     */
-    getSingletonKey(): string;
-    /**
-     * Reset fluent options for reuse
-     */
-    reset(): SingletonClient<ReadWith<R, never>, R>;
-}
-
-/**
- * Settings fetch options
- */
-interface SettingsFetchOptions {
-    /** Locale for localized settings */
-    locale?: string;
-    /**
-     * Include paths: the references to expand (REL-1801), added to the ones `include()` named — see
-     * `include()`. Typed where the call names them inline.
-     */
-    include?: readonly string[];
-}
-/**
- * Settings client for managing settings group operations
- * Provides a fluent API for settings operations following the same pattern as ContentClient
- *
- * Every call is in the locale it names — the argument (`fetch({ locale })`, `update(settings,
- * locale)`, `reset(locale)`, `versions({ locale })`), then `.locale()` — and otherwise in the
- * client's own (`withLocale()`, `updateConfig({ locale })`) as it is when the call is made, as
- * `content()`'s are: reads, writes and version history alike.
- *
- * @example
- * ```typescript
- * const emailConfig = await client.settings('email-config')
- *   .include(['defaultTemplate'])
- *   .locale('en')
- *   .fetch()
- * ```
- */
-declare class SettingsClient<T = unknown, R extends Reading = UntypedReading<T>, I extends string = never> {
-    private readonly httpClient;
-    private readonly groupId;
-    private includeFields?;
-    private localeValue?;
-    /** The client's locale, asked on every call rather than copied when this client was taken. */
-    private readonly clientLocale;
-    /**
-     * @param locale - The client's locale: the function `TypedRelyIOClient` hands over, asked on
-     *   every call, or a locale fixed for this client
-     */
-    constructor(httpClient: HttpClient, groupId: string, locale?: ClientLocale);
-    /**
-     * Expand references into the entries they point at: one include path per element (REL-1801).
-     * A path names fields through lists, objects and references — `'hero.media.image'`,
-     * `'featured.author'` — and may pick the fields each entry returns, `'featured(title,slug)'`.
-     * Each is checked against the schema: a path that holds no reference does not compile, and the
-     * read's type follows the paths — an expanded reference is the entry, every other one its id. A
-     * second call adds to the first.
-     */
-    include<const P extends readonly string[]>(paths: CheckedIncludes<R, P>): SettingsClient<ReadWith<R, I | P[number]>, R, I | P[number]>;
-    /**
-     * Set locale for localized settings
-     * @param locale - Locale code (e.g., 'en', 'de', 'fr')
-     */
-    locale(locale: string): this;
-    /**
-     * Fetch the settings group
-     * @param options - Optional fetch options (alternative to fluent methods)
-     */
-    fetch<const P extends readonly string[]>(options: Omit<SettingsFetchOptions, 'include'> & {
-        include: CheckedIncludes<R, P>;
-    }): Promise<ReadWith<R, I | P[number]> | null>;
-    fetch(options?: Omit<SettingsFetchOptions, 'include'>): Promise<T | null>;
-    /**
-     * Update settings group
-     *
-     * The fields travel as `content` beside an optional `locale`, the body the route validates
-     * (`UpdateSettingsDto`); any other top-level key is refused `REQUEST_INVALID`.
-     *
-     * @param settings - The settings fields to update
-     * @param locale - Optional locale for localized settings (overrides the fluent locale, which
-     *   overrides the client's own)
-     */
-    update(settings: Partial<T>, locale?: string, options?: ConditionalWriteOptions): Promise<T>;
-    /**
-     * Fetch the group **and the entity tag that read served**, which is what
-     * `update`'s and `reset`'s `ifMatch` take
-     * (`INV-API-CONDITIONAL-WRITE-IS-REACHABLE`).
-     */
-    fetchWithTag(options?: SettingsFetchOptions): Promise<{
-        settings: T;
-        entityTag?: string;
-    }>;
-    /**
-     * Reset settings to default values
-     *
-     * The route reads its locale from `?locale=` and takes no body, so that is where it is sent.
-     *
-     * @param locale - Optional locale for localized settings (overrides the fluent locale, which
-     *   overrides the client's own)
-     */
-    reset(locale?: string, options?: ConditionalWriteOptions): Promise<T>;
-    /**
-     * Get default settings for this group
-     */
-    getDefaults(): Promise<T>;
-    /**
-     * Check if settings group exists
-     */
-    exists(): Promise<boolean>;
-    /**
-     * Get version history for one locale of the settings group.
-     *
-     * Versions are numbered per locale, so this is one locale's timeline: `locale` defaults to the
-     * fluent `.locale()`, then the client's own (`withLocale()`), 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?: {
-        limit?: number;
-        locale?: string;
-    }): Promise<Array<T & {
-        versionNumber: number;
-        locale: string;
-    }>>;
-    /**
-     * Get a specific version of the settings.
-     *
-     * `locale` defaults to the fluent `.locale()`, then the client's own (`withLocale()`), then the
-     * schema default. Version numbers are per locale, so version 2 is different content in each one.
-     */
-    version(versionNumber: number, options?: {
-        locale?: string;
-    }): Promise<T | null>;
-    /** The locale a write or history read sends: the call's, the fluent one, else the client's. */
-    private localeOf;
-    /**
-     * Get the settings group ID
-     */
-    getGroupId(): string;
-    /**
-     * Reset fluent options for reuse
-     */
-    resetOptions(): SettingsClient<ReadWith<R, never>, R>;
-}
-
-/**
- * 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;
-
-/**
- * Search mode for content queries
- */
-type SearchMode = 'keyword' | 'semantic' | 'hybrid';
-/**
- * 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).findById(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;
-/**
- * Search response from API
- */
-/**
- * What `POST /v1/search` serves, **read from the committed document**.
- *
- * `{ data, page: { offset, limit, total }, meta }` — search is the offset
- * dialect precisely because a facet-bearing result wants a total and an offset
- * (Decision 5), and 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 replaces named three
- * keys the route does not send. `SearchBuilder.items()` returned `undefined`
- * and `.total` was always `undefined` — with nothing able to see either,
- * because the type asserted them.
- */
-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'];
-/**
- * Autocomplete response
- */
-/**
- * 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>;
-/**
- * Similar response
- */
-/** What `POST /v1/search/similar` serves. */
-type SimilarResponse<T = unknown> = Wire<'/v1/search/similar', 'post', SimilarResult<T>>;
-/**
- * Filter conditions for search
- */
-type SearchFilter = Record<string, unknown>;
-/**
- * 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;
-/**
- * Field projection for search results
- */
-type SearchFields<T> = {
-    [K: string]: keyof T | string;
-};
-/**
- * One ordering of `POST /v1/search`'s results, as the route's `sort` array takes it.
- */
-interface SearchSort {
-    /** Field path, or `_score` for relevance */
-    field: string;
-    /** Direction; the route's default is `desc` */
-    direction: 'asc' | 'desc';
-}
-/**
- * Fluent builder for search queries
- *
- * @example
- * ```typescript
- * const results = await relyio.search('wireless headphones')
- *   .in('product')
- *   .where({ status: 'active' })
- *   .searchFields(['title', 'description'])
- *   .limit(20)
- *   .includeScore()
- *   .execute()
- * ```
- */
-declare class SearchBuilder<T extends BaseContent = BaseContent, S extends AnySchemaDefinition | undefined = undefined> {
-    private readonly httpClient;
-    private query;
-    private searchOptions;
-    private requestHeaders?;
-    private freshValue?;
-    /** The client's locale, asked when the query is sent rather than copied when it was built. */
-    private readonly clientLocale;
-    /**
-     * @param locale - The client's locale (`withLocale()`, `updateConfig({ locale })`), sent when
-     *   `.locale()` names none: the function `TypedRelyIOClient` hands over, or a locale fixed for it
-     */
-    constructor(httpClient: HttpClient, query: string, locale?: ClientLocale);
-    /**
-     * Headers this search adds to the client's own, e.g. `X-RelyIO-Dataset` to search another
-     * dataset the key can see. A name the client already sends is replaced for this search only.
-     */
-    headers(headers: Record<string, string>): this;
-    /**
-     * The feed position this search follows — a change's `fresh` (`FeedChange`), or a resync's. Sent
-     * as `?_fresh` on the query string beside the body: the edge keys a search on both, so no answer
-     * it holds from before that position can answer it. The answer is the search's own.
-     */
-    fresh(position: string): this;
-    /**
-     * Search within a single content type. Where a schema types the client, the name is one of its
-     * content types and the results are that type's entries.
-     * @param contentType - Content type to search in
-     */
-    in<K extends SearchTypeName<S>>(contentType: K): SearchBuilder<SearchEntry<S, K, T>, S>;
-    /**
-     * Search across multiple content types. Where a schema types the client, the names are its content
-     * types and the results are a union of their entries — every type's, for `'*'`.
-     * @param contentTypes - Array of content types or '*' for all
-     */
-    across<K extends SearchTypeName<S>>(contentTypes: K[] | '*'): SearchBuilder<SearchEntry<S, K, T>, S>;
-    /**
-     * Add filter conditions, on the fields the content types declare. A condition on `_metadata` is
-     * refused here, before anything is sent.
-     * @param conditions - Filter conditions
-     */
-    where(conditions: SearchFilter): this;
-    /**
-     * Specify which fields to search in
-     * @param fields - Field names to search
-     */
-    searchFields(fields: string[]): this;
-    /**
-     * Project specific fields in results
-     * @param projection - Field mapping
-     */
-    fields(projection: Record<string, string>): this;
-    /**
-     * Order the results by a field instead of by relevance. Called again, it adds a tie-breaker.
-     * `_score` names relevance itself.
-     * @param field - Field path to sort by (e.g. `updatedAt`, `pricing.basePrice`)
-     * @param direction - `asc` or `desc` (the route's default is `desc`)
-     */
-    sort(field: string, direction?: 'asc' | 'desc'): this;
-    /**
-     * Limit number of results
-     * @param count - Maximum results
-     */
-    limit(count: number): this;
-    /**
-     * Skip results for pagination
-     * @param count - Number to skip
-     */
-    offset(count: number): this;
-    /**
-     * Include relevance scores in results
-     */
-    includeScore(): this;
-    /**
-     * Include score breakdown explanation
-     */
-    explain(): this;
-    /**
-     * Set locale for localized content
-     * @param locale - Locale code
-     */
-    locale(locale: string): this;
-    /**
-     * Execute the search query
-     */
-    execute(): Promise<SearchResponse<T>>;
-    /**
-     * Execute and return just the items (convenience method)
-     */
-    items(): Promise<Array<SearchResultItem<T>>>;
-    /**
-     * Get the first result
-     */
-    first(): Promise<SearchResultItem<T> | null>;
-}
-/**
- * Fluent builder for autocomplete queries
- *
- * @example
- * ```typescript
- * const suggestions = await relyio.autocomplete('wire')
- *   .in('product')
- *   .field('title')
- *   .fuzzy()
- *   .limit(10)
- *   .execute()
- * ```
- */
-declare class AutocompleteBuilder {
-    private readonly httpClient;
-    private query;
-    private autocompleteOptions;
-    /** The client's locale, asked when the query is sent rather than copied when it was built. */
-    private readonly clientLocale;
-    /**
-     * @param locale - The client's locale (`withLocale()`, `updateConfig({ locale })`), sent when
-     *   `.locale()` names none: the function `TypedRelyIOClient` hands over, or a locale fixed for it
-     */
-    constructor(httpClient: HttpClient, query: string, locale?: ClientLocale);
-    /**
-     * Autocomplete within a content type
-     * @param contentType - Content type to search
-     */
-    in(contentType: string): this;
-    /**
-     * Field to autocomplete on
-     * @param fieldName - Field name (supports nested like 'category.name')
-     */
-    field(fieldName: string): this;
-    /**
-     * Enable fuzzy matching for typo tolerance
-     */
-    fuzzy(): this;
-    /**
-     * Add filter conditions, on the fields the content types declare. A condition on `_metadata` is
-     * refused here, before anything is sent.
-     * @param conditions - Filter conditions
-     */
-    where(conditions: SearchFilter): this;
-    /**
-     * Limit number of suggestions
-     * @param count - Maximum suggestions
-     */
-    limit(count: number): this;
-    /**
-     * Set locale for localized content
-     * @param locale - Locale code
-     */
-    locale(locale: string): this;
-    /**
-     * Execute the autocomplete query
-     */
-    execute(): Promise<AutocompleteResponse>;
-    /**
-     * Get just the suggestion texts
-     */
-    texts(): Promise<string[]>;
-}
-/**
- * Fluent builder for finding similar content
- *
- * @example
- * ```typescript
- * const similar = await relyio.similar('entry_abc123')
- *   .in('product')
- *   .locale('fr-FR')
- *   .limit(5)
- *   .execute()
- * ```
- */
-declare class SimilarBuilder<T extends BaseContent = BaseContent> {
-    private readonly httpClient;
-    private sourceId;
-    private similarOptions;
-    private requestHeaders?;
-    /** The client's locale, asked when the read is sent rather than copied when it was built. */
-    private readonly clientLocale;
-    /**
-     * @param locale - The client's locale (`withLocale()`, `updateConfig({ locale })`), sent when
-     *   `.locale()` names none: the function `TypedRelyIOClient` hands over, or a locale fixed for it
-     */
-    constructor(httpClient: HttpClient, sourceId: string, locale?: ClientLocale);
-    /**
-     * Headers this read adds to the client's own, e.g. `X-RelyIO-Dataset` to read another dataset
-     * the key can see. A name the client already sends is replaced for this read only.
-     */
-    headers(headers: Record<string, string>): this;
-    /**
-     * Find similar content within a content type
-     * @param contentType - Content type to search
-     */
-    in(contentType: string): this;
-    /**
-     * Find similar content across several content types, or `'*'` for every type
-     * @param contentTypes - Array of content types or '*' for all
-     */
-    across(contentTypes: string[] | '*'): this;
-    /**
-     * Limit number of results
-     * @param count - Maximum results
-     */
-    limit(count: number): this;
-    /**
-     * Set locale for localized content
-     * @param locale - Locale code
-     */
-    locale(locale: string): this;
-    /**
-     * Execute the similar query
-     */
-    execute(): Promise<SimilarResponse<T>>;
-    /**
-     * Get just the similar items
-     */
-    items(): Promise<Array<SimilarResult<T>>>;
-    /**
-     * Get the most similar item
-     */
-    first(): Promise<SimilarResult<T> | null>;
-}
-/**
- * Search client providing fluent access to all search capabilities
- *
- * @example
- * ```typescript
- * const searchClient = new SearchClient(httpClient)
- *
- * // Full-text/hybrid search
- * const products = await searchClient.search('wireless')
- *   .in('product')
- *   .limit(20)
- *   .execute()
- *
- * // Autocomplete
- * const suggestions = await searchClient.autocomplete('wire')
- *   .in('product')
- *   .field('title')
- *   .execute()
- *
- * // Find similar
- * const similar = await searchClient.similar('entry_123')
- *   .in('product')
- *   .execute()
- * ```
- */
-declare class SearchClient {
-    private readonly httpClient;
-    /** The client's locale, handed to every builder here to ask when it sends. */
-    private readonly clientLocale;
-    /**
-     * @param locale - The client's locale (`withLocale()`, `updateConfig({ locale })`): every builder
-     *   here sends it when the query names none, as `content()`'s reads do — the function
-     *   `TypedRelyIOClient` hands over, or a locale fixed for this client
-     */
-    constructor(httpClient: HttpClient, locale?: ClientLocale);
-    /**
-     * Start a search query
-     * @param query - Search query string
-     */
-    search<T extends BaseContent = BaseContent, S extends AnySchemaDefinition | undefined = undefined>(query: string): SearchBuilder<T, S>;
-    /**
-     * Start an autocomplete query
-     * @param query - Partial query to autocomplete
-     */
-    autocomplete(query: string): AutocompleteBuilder;
-    /**
-     * Find content similar to a given entry
-     * @param sourceId - Entry ID to find similar content for
-     */
-    similar<T extends BaseContent = BaseContent>(sourceId: string): SimilarBuilder<T>;
-}
-
-/**
- * HTTP methods supported in batch operations
- */
-type BatchMethod = 'POST' | 'PATCH' | 'PUT' | 'DELETE';
-/**
- * A single batch operation
- */
-interface BatchOperation {
-    /** Optional operation ID for tracking */
-    id?: string;
-    /** HTTP method */
-    method: BatchMethod;
-    /** Path to resource (e.g., '/product' or '/product/entry_123') */
-    path: string;
-    /** Request body for create/update operations */
-    body?: Record<string, unknown>;
-}
-/**
- * Batch execution options
- */
-interface BatchOptions {
-    /**
-     * If true, the batch runs as one transaction: every operation lands or none does.
-     *
-     * Requires that all operations be the same kind of write — one transaction cannot span two
-     * calls — so a batch mixing creates and deletes, or `update` and `replace`, is rejected with
-     * a 400 before anything is attempted: `execute()` rejects with `InvalidPayloadError`. A
-     * singleton write is a create when the dataset has never written that singleton and an update
-     * after, and an atomic batch cannot create one — that operation reports `REQUEST_INVALID` and
-     * every other `TRANSACTION_ROLLED_BACK` — so create it in a request of its own first.
-     *
-     * @default false
-     */
-    atomic?: boolean;
-    /**
-     * If true, run the checks and write nothing.
-     *
-     * Every entry is resolved, authorized and validated against its schema, so what passes a dry
-     * run is what a real write accepts.
-     *
-     * @default false
-     */
-    dryRun?: boolean;
-    /**
-     * If true, include full data in response
-     * @default true
-     */
-    returnData?: boolean;
-    /**
-     * If true, continue executing after failures (non-atomic mode only)
-     * @default true
-     */
-    continueOnError?: boolean;
-}
-/**
- * Result of a single operation in the batch
- */
-/**
- * One batch item, **as the committed document describes the `multi` kind**.
- *
- * Read from `api-schema.ts` rather than imported from `@relyio/api-contract`
- * for the same reason every other response type here is: the document is the
- * one source, and a type this package publishes must resolve for a customer who
- * installs `@relyio/sdk` alone. The contract's runtime half is bundled; its
- * `.d.ts` is not something a consumer can reach.
- *
- * The hand-written version carried `success: boolean` and a per-item `status`
- * number. Both are gone from the wire and neither loss is a gap: the presence
- * of `error` already says whether the item succeeded (Decision 2, gap 16), and
- * a sub-response carrying its own HTTP status is exactly the duplication
- * `INV-API-NO-DUPLICATE-STATUS` removes. What replaced them says more, not
- * less — `outcome` distinguishes `created` from `updated` from `unchanged`
- * from `duplicate` from `skipped`, which one boolean never could.
- */
-type BatchOperationResult = components['schemas']['MultiPayload']['results'][number];
-/** Summary of batch execution, from the contract. */
-type BatchSummary = components['schemas']['MultiSummary'];
-/**
- * The full batch payload: `{ results, summary }`.
- *
- * `transactionId`, `executionTimeMs` and `dryRun` were named here and are not
- * on the wire; nothing produced them and nothing could read them.
- */
-type BatchResponse = components['schemas']['MultiPayload'];
-/**
- * Fluent builder for batch operations
- *
- * Every create, update, replace and singleton operation it builds is in the locale that operation
- * names, and otherwise in the client's own (`withLocale()`), sent as that operation's
- * `body.locale` — a batch is one request, but the API reads a locale per operation. A delete names
- * none (it removes the whole entry), and a `raw()` operation is sent exactly as written.
- *
- * An atomic batch — `.atomic()` or `execute({ atomic: true })` — is one transaction: every
- * operation lands or none does. The API accepts one only when every operation is the same kind of
- * write and none writes a singleton that does not exist yet (see {@link BatchOptions.atomic}).
- *
- * @example
- * ```typescript
- * // Each operation lands or fails on its own
- * const result = await relyio.batch()
- *   .create('product', { content: { title: 'iPhone', price: 999 } })
- *   .update('product', 'entry_abc', { content: { price: 899 } })
- *   .delete('product', 'entry_xyz')
- *   .upsertSingleton('homepage', { content: { hero: 'Welcome!' } })
- *   .execute()
- *
- * console.log(result.summary.succeeded)
- *
- * // All or nothing: one kind of write
- * await relyio.batch()
- *   .create('product', { content: { title: 'iPhone', price: 999 } })
- *   .create('product', { content: { title: 'iPad', price: 799 } })
- *   .atomic()
- *   .execute()
- * ```
- */
-declare class BatchBuilder<TSchema = unknown> {
-    private readonly httpClient;
-    private operations;
-    private defaultOptions;
-    private requestHeaders;
-    /** The client's locale, asked as each operation is added rather than copied when this was built. */
-    private readonly clientLocale;
-    /**
-     * @param locale - The client's locale (`withLocale()`, `updateConfig({ locale })`), each
-     *   operation's when it names none: the function `TypedRelyIOClient` hands over, or a locale fixed
-     *   for this batch
-     */
-    constructor(httpClient: HttpClient, locale?: ClientLocale);
-    /**
-     * An operation's body with its locale: the one it names, else the client's as it is when the
-     * operation is added.
-     */
-    private localized;
-    /**
-     * Add a create operation
-     * @param contentType - Content type to create
-     * @param data - Entry data with content field
-     * @param id - Optional operation ID for tracking
-     */
-    create<T extends BaseContent = BaseContent>(contentType: string, data: {
-        content: CreateInput<T>;
-        slug?: string;
-        locale?: string;
-        parentId?: string;
-        sortOrder?: number;
-    }, id?: string): this;
-    /**
-     * Add an update operation (partial update).
-     *
-     * The submitted fields are merged into the entry and the rest are left as they are. The merge is
-     * field-level rather than deep: sending an object-typed field replaces that field's whole value.
-     *
-     * @param contentType - Content type
-     * @param entryId - Entry ID to update
-     * @param data - Fields to update
-     * @param id - Optional operation ID for tracking
-     */
-    update<T extends BaseContent = BaseContent>(contentType: string, entryId: string, data: {
-        content?: UpdateInput<T>;
-        slug?: string;
-        locale?: string;
-        parentId?: string;
-        sortOrder?: number;
-    }, id?: string): this;
-    /**
-     * Add a replace operation (full replacement).
-     *
-     * The payload becomes the entry's content for the addressed locale: fields you do not send are
-     * cleared. Send the whole entry, or use {@link BatchClient.update} to change part of one.
-     *
-     * @param contentType - Content type
-     * @param entryId - Entry ID to replace
-     * @param data - Complete entry data
-     * @param id - Optional operation ID for tracking
-     */
-    replace<T extends BaseContent = BaseContent>(contentType: string, entryId: string, data: {
-        content: CreateInput<T>;
-        slug?: string;
-        locale?: string;
-        parentId?: string;
-        sortOrder?: number;
-    }, id?: string): this;
-    /**
-     * Add a delete operation
-     * @param contentType - Content type
-     * @param entryId - Entry ID to delete
-     * @param id - Optional operation ID for tracking
-     */
-    delete(contentType: string, entryId: string, id?: string): this;
-    /**
-     * Add a singleton upsert operation
-     * @param singletonKey - Singleton key
-     * @param data - Singleton content
-     * @param id - Optional operation ID for tracking
-     */
-    upsertSingleton(singletonKey: string, data: {
-        content: Record<string, unknown>;
-        locale?: string;
-    }, id?: string): this;
-    /**
-     * Add a singleton create operation (alias for upsert with POST)
-     * @param singletonKey - Singleton key
-     * @param data - Singleton content
-     * @param id - Optional operation ID for tracking
-     */
-    createSingleton(singletonKey: string, data: {
-        content: Record<string, unknown>;
-        locale?: string;
-    }, id?: string): this;
-    /**
-     * Add a raw operation (for advanced use cases). It is sent exactly as written: the client's
-     * locale is not added to it.
-     * @param operation - The operation to add
-     */
-    raw(operation: BatchOperation): this;
-    /**
-     * Add multiple raw operations
-     * @param operations - Operations to add
-     */
-    rawMany(operations: BatchOperation[]): this;
-    /**
-     * Bulk create multiple entries of the same content type
-     * @param contentType - Content type
-     * @param items - Array of entry data
-     */
-    bulkCreate<T extends BaseContent = BaseContent>(contentType: string, items: Array<{
-        content: CreateInput<T>;
-        slug?: string;
-        locale?: string;
-        id?: string;
-    }>): this;
-    /**
-     * Bulk update multiple entries
-     * @param contentType - Content type
-     * @param updates - Array of { entryId, data } pairs
-     */
-    bulkUpdate<T extends BaseContent = BaseContent>(contentType: string, updates: Array<{
-        entryId: string;
-        data: {
-            content?: UpdateInput<T>;
-        };
-        id?: string;
-    }>): this;
-    /**
-     * Bulk delete multiple entries
-     * @param contentType - Content type
-     * @param entryIds - Entry IDs to delete
-     */
-    bulkDelete(contentType: string, entryIds: string[]): this;
-    /**
-     * Configure default options for execution
-     * @param options - Batch options
-     */
-    configure(options: BatchOptions): this;
-    /**
-     * Enable atomic mode (all-or-nothing)
-     */
-    atomic(): this;
-    /**
-     * Enable dry-run mode (validate without executing)
-     */
-    dryRun(): this;
-    /**
-     * Disable returning full data in response
-     */
-    noData(): this;
-    /**
-     * Stop on first error (non-atomic mode)
-     */
-    stopOnError(): this;
-    /**
-     * Headers the batch request adds — e.g. `{ 'X-RelyIO-Dataset': 'staging' }` to write a dataset
-     * other than the client's. They replace the client's own header of the same name for this
-     * request alone, and apply to every operation in it: a batch is one request.
-     */
-    headers(headers: Record<string, string>): this;
-    /**
-     * Get the current list of operations
-     */
-    getOperations(): BatchOperation[];
-    /**
-     * Get the number of operations
-     */
-    size(): number;
-    /**
-     * Clear all operations
-     */
-    clear(): this;
-    /**
-     * Clone the builder
-     */
-    clone(): BatchBuilder<TSchema>;
-    /**
-     * Execute the batch operations
-     * @param options - Override default options
-     */
-    execute(options?: BatchOptions): Promise<BatchResponse>;
-    /**
-     * Validate operations without executing (convenience for dry-run)
-     */
-    validate(): Promise<BatchResponse>;
-    /**
-     * Execute and throw if any operation failed
-     */
-    executeOrThrow(options?: BatchOptions): Promise<BatchResponse>;
-}
-/**
- * Batch client for bulk operations
- *
- * @example
- * ```typescript
- * const batchClient = new BatchClient(httpClient)
- *
- * // Create a batch with fluent API
- * const result = await batchClient.create()
- *   .create('product', { content: { title: 'New Product' } })
- *   .update('product', 'entry_123', { content: { price: 99 } })
- *   .execute()
- *
- * // Quick bulk create
- * const products = await batchClient.bulkCreate('product', [
- *   { content: { title: 'Product 1' } },
- *   { content: { title: 'Product 2' } },
- * ])
- * ```
- */
-declare class BatchClient<TSchema = unknown> {
-    private readonly httpClient;
-    /** The client's locale, handed to every batch this builds to ask as operations are added. */
-    private readonly clientLocale;
-    /**
-     * @param locale - The client's locale: the function `TypedRelyIOClient` hands over, or a locale
-     *   fixed for this client
-     */
-    constructor(httpClient: HttpClient, locale?: ClientLocale);
-    /**
-     * Create a new batch builder, whose operations default to this client's locale
-     */
-    create(): BatchBuilder<TSchema>;
-    /**
-     * Quick bulk create entries
-     * @param contentType - Content type
-     * @param items - Array of entry data
-     * @param options - Batch options
-     */
-    bulkCreate<T extends BaseContent = BaseContent>(contentType: string, items: Array<{
-        content: CreateInput<T>;
-        slug?: string;
-        locale?: string;
-    }>, options?: BatchOptions): Promise<BatchResponse>;
-    /**
-     * Quick bulk update entries
-     * @param contentType - Content type
-     * @param updates - Array of updates
-     * @param options - Batch options
-     */
-    bulkUpdate<T extends BaseContent = BaseContent>(contentType: string, updates: Array<{
-        entryId: string;
-        data: {
-            content?: UpdateInput<T>;
-        };
-    }>, options?: BatchOptions): Promise<BatchResponse>;
-    /**
-     * Quick bulk delete entries
-     * @param contentType - Content type
-     * @param entryIds - Entry IDs to delete
-     * @param options - Batch options
-     */
-    bulkDelete(contentType: string, entryIds: string[], options?: BatchOptions): Promise<BatchResponse>;
-    /**
-     * Execute raw batch operations
-     * @param operations - Array of operations
-     * @param options - Batch options
-     */
-    execute(operations: BatchOperation[], options?: BatchOptions): Promise<BatchResponse>;
-}
-
-/**
- * Fetch block for retrieving content
- */
-interface FetchBlock {
-    /** Content type to fetch (mutually exclusive with singleton) */
-    contentType?: string;
-    /** Singleton key to fetch (mutually exclusive with contentType) */
-    singleton?: string;
-    /** Filter conditions */
-    where?: Record<string, unknown>;
-    /** Reference fields to populate */
-    include?: string | string[];
-    /** Sort specification */
-    sort?: Record<string, 'asc' | 'desc'>;
-    /** Maximum entries to return */
-    limit?: number;
-    /** Entries to skip */
-    offset?: number;
-}
-/**
- * Aggregate block for computing metrics
- */
-interface AggregateBlock {
-    /** Source content type or query reference */
-    source: string;
-    /**
-     * Filter conditions applied before grouping, in the Query DSL's spelling — bare operator names
-     * (`{ price: { gte: 10 } }`), not the list route's `$gte`. A `$`-prefixed key is not an operator
-     * in this dialect: the service reads the object as a nested field and drops it.
-     */
-    where?: Record<string, unknown>;
-    /** Field to group by */
-    by?: string | string[];
-    /** Metrics to compute, keyed by the name each one answers under */
-    metrics: Record<string, AggregateMetric>;
-}
-/**
- * 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. `first` and `last` were missing here while the service ran them (REL-1470).
- *
- * It used to be `{ fn, field? }`, a shape the service refuses on every request: the validator
- * tests the metric as a string, so an object arrives as `[object Object]`.
- */
-type AggregateMetric = `${string}.${'count' | 'sum' | 'avg' | 'min' | 'max' | 'first' | 'last'}`;
-/**
- * Search block for full-text/semantic search
- */
-interface SearchBlock {
-    /** Content type to search */
-    contentType: string;
-    /** Search query (can use ${param} syntax) */
-    query: string;
-    /** Search mode */
-    mode?: 'keyword' | 'semantic' | 'hybrid';
-    /** Fields to search */
-    searchFields?: string[];
-    /** Additional filters */
-    where?: Record<string, unknown>;
-    /** Maximum results */
-    limit?: number;
-}
-/**
- * One post-fetch filter: a parameter expression, or the operators every query clause compares with
- * (`FilterOperator`, REL-1479). This kept a copy of eleven, without `exists` or `notExists`; and a
- * bare number or boolean, which it took, the service does not read as a filter.
- */
-type FilterValue = string | FilterOperator;
-/**
- * Full-text search configuration
- */
-interface FullTextConfig {
-    /** Search query (can use ${param} syntax) */
-    query: string;
-    /** Fields to search */
-    fields?: string[];
-    /** Minimum score threshold */
-    minScore?: number;
-}
-/**
- * Ad-hoc query definition
- */
-interface AdhocQueryDefinition {
-    /** Fetch block - retrieve content */
-    fetch?: FetchBlock;
-    /** Aggregate block - compute metrics */
-    aggregate?: AggregateBlock;
-    /** Search block - full-text/semantic search */
-    search?: SearchBlock;
-    /** Field selection/transformation */
-    select?: Record<string, string>;
-    /** Post-fetch filters with parameter support */
-    filters?: Record<string, FilterValue>;
-    /** Full-text search configuration */
-    fullText?: FullTextConfig;
-    /** Cache policy */
-    cache?: {
-        ttl?: number;
-        strategy?: 'stale-while-revalidate' | 'cache-first' | 'network-first';
-    };
-}
-/**
- * Ad-hoc query execution options
- */
-interface AdhocQueryOptions {
-    /** Include debug information in response */
-    debug?: boolean;
-    /** Bypass cache for this request */
-    skipCache?: boolean;
-    /** Custom timeout in milliseconds (1000-60000) */
-    timeout?: number;
-}
-/**
- * Query execution metadata
- */
-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 payload `POST /v1/query` serves: `{ result, metadata }`.
- *
- * The route is an `object` kind, so there is one payload key whether the query
- * fetched a list or a singleton — `result` is the records either way. Three
- * members of the hand-written type are gone and each for a stated reason:
- * `success` because the status line says it, `items` because no contract shape
- * introduces that key (`INV-API-SUCCESS-HAS-ONE-SHAPE`), and `errors` because a
- * failed query is a **refusal**, which arrives as `{ error: { code, messages } }`
- * and is thrown as a typed SDK error rather than returned as a 200 with a flag.
- */
-interface AdhocQueryResult<T = unknown> {
-    /** The records the query produced — an array for a list, one item for a singleton. */
-    result?: T | T[];
-    /** Execution metadata */
-    metadata?: QueryMetadata;
-}
-/**
- * Fluent builder for ad-hoc queries
- *
- * @example
- * ```typescript
- * const result = await relyio.query.adhoc()
- *   .fetch({
- *     contentType: 'product',
- *     where: { status: 'active' },
- *     include: ['brand', 'categories'],
- *     limit: 20
- *   })
- *   .select({
- *     id: 'id',
- *     title: 'title',
- *     price: 'pricing.basePrice',
- *     brandName: 'brand.name'
- *   })
- *   .filter('pricing.basePrice', { gte: '${minPrice}', lte: '${maxPrice}' })
- *   .params({ minPrice: 100, maxPrice: 500 })
- *   .debug()
- *   .execute()
- * ```
- */
-declare class AdhocQueryBuilder<T = unknown> {
-    private readonly httpClient;
-    private queryDef;
-    private parameters;
-    private options;
-    /** The client's locale, asked when the query is sent rather than copied when it was built. */
-    private readonly clientLocale;
-    /**
-     * @param locale - The client's locale (`withLocale()`, `updateConfig({ locale })`), sent as the
-     *   `locale` parameter when `.param('locale', …)` binds none: the function `TypedRelyIOClient`
-     *   hands over, or a locale fixed for this builder
-     */
-    constructor(httpClient: HttpClient, locale?: ClientLocale);
-    /**
-     * Add a fetch block to retrieve content
-     * @param config - Fetch configuration
-     */
-    fetch(config: FetchBlock): this;
-    /**
-     * Fetch from a content type
-     * @param contentType - Content type to fetch
-     */
-    from(contentType: string): this;
-    /**
-     * Fetch a singleton
-     * @param singletonKey - Singleton key
-     */
-    singleton(singletonKey: string): this;
-    /**
-     * Add aggregate block
-     * @param config - Aggregate configuration
-     */
-    aggregate(config: AggregateBlock): this;
-    /**
-     * Add search block
-     * @param config - Search configuration
-     */
-    search(config: SearchBlock): this;
-    /**
-     * Add where conditions to fetch
-     * @param conditions - Filter conditions
-     */
-    where(conditions: Record<string, unknown>): this;
-    /**
-     * Add include for reference population
-     * @param fields - Reference fields to include
-     */
-    include(fields: string | string[]): this;
-    /**
-     * Add sort specification
-     * @param sort - Sort configuration
-     */
-    sort(sort: Record<string, 'asc' | 'desc'>): this;
-    /**
-     * Sort by field ascending
-     * @param field - Field to sort by
-     */
-    sortAsc(field: string): this;
-    /**
-     * Sort by field descending
-     * @param field - Field to sort by
-     */
-    sortDesc(field: string): this;
-    /**
-     * Limit results
-     * @param count - Maximum results
-     */
-    limit(count: number): this;
-    /**
-     * Skip results
-     * @param count - Number to skip
-     */
-    offset(count: number): this;
-    /**
-     * Select and transform fields in output
-     * @param projection - Field mapping (outputField: sourceField)
-     */
-    select(projection: Record<string, string>): this;
-    /**
-     * Add a post-fetch filter (supports ${param} syntax)
-     * @param field - Field path to filter
-     * @param condition - Filter condition
-     */
-    filter(field: string, condition: FilterValue): this;
-    /**
-     * Add full-text search
-     * @param config - Full-text configuration
-     */
-    fullText(config: FullTextConfig): this;
-    /**
-     * Set query parameters
-     * @param params - Parameter values
-     */
-    params(params: Record<string, unknown>): this;
-    /**
-     * Set a single parameter
-     * @param name - Parameter name
-     * @param value - Parameter value
-     */
-    param(name: string, value: unknown): this;
-    /**
-     * Enable debug mode
-     */
-    debug(): this;
-    /**
-     * Skip cache for this request
-     */
-    skipCache(): this;
-    /**
-     * Set custom timeout
-     * @param ms - Timeout in milliseconds (1000-60000)
-     */
-    timeout(ms: number): this;
-    /**
-     * Set cache policy
-     * @param ttl - Cache TTL in seconds
-     * @param strategy - Cache strategy
-     */
-    cache(ttl: number, strategy?: 'stale-while-revalidate' | 'cache-first' | 'network-first'): this;
-    /**
-     * Get the query definition (for debugging)
-     */
-    getDefinition(): AdhocQueryDefinition;
-    /**
-     * Get the parameters (for debugging)
-     */
-    getParameters(): Record<string, unknown>;
-    /**
-     * Execute the query
-     */
-    execute(): Promise<AdhocQueryResult<T>>;
-    /**
-     * Execute and return the records as an array (for list queries).
-     */
-    items(): Promise<T[]>;
-    /**
-     * Execute and return the single record (for singleton queries).
-     */
-    data(): Promise<T | undefined>;
-    /**
-     * Clone the builder
-     */
-    clone(): AdhocQueryBuilder<T>;
-}
-/**
- * Client for executing ad-hoc queries
- *
- * @example
- * ```typescript
- * const queryClient = new AdhocQueryClient(httpClient)
- *
- * // Fluent builder
- * const products = await queryClient.build()
- *   .from('product')
- *   .where({ status: 'active' })
- *   .limit(20)
- *   .execute()
- *
- * // Direct execution
- * const result = await queryClient.execute({
- *   fetch: { contentType: 'product', limit: 10 }
- * })
- * ```
- */
-declare class AdhocQueryClient {
-    private readonly httpClient;
-    /** The client's locale, asked on every query rather than copied when this client was taken. */
-    private readonly clientLocale;
-    /**
-     * @param locale - The client's locale (`withLocale()`, `updateConfig({ locale })`), sent as the
-     *   `locale` parameter of every query that binds none: the function `TypedRelyIOClient` hands
-     *   over, or a locale fixed for this client
-     */
-    constructor(httpClient: HttpClient, locale?: ClientLocale);
-    /**
-     * Create a new query builder
-     */
-    build<T = unknown>(): AdhocQueryBuilder<T>;
-    /**
-     * Execute a query definition directly
-     * @param definition - Query definition
-     * @param parameters - Parameter values
-     * @param options - Execution options
-     * @param request - `headers` this one request adds to the client's own, e.g. `X-RelyIO-Dataset`
-     *   to query another dataset the key can see. A name the client already sends is replaced for
-     *   this request only.
-     */
-    execute<T = unknown>(definition: AdhocQueryDefinition, parameters?: Record<string, unknown>, options?: AdhocQueryOptions, request?: {
-        headers?: Record<string, string>;
-    }): Promise<AdhocQueryResult<T>>;
-    /**
-     * Quick fetch helper
-     * @param contentType - Content type
-     * @param options - Fetch options
-     */
-    fetch<T = unknown>(contentType: string, options?: Omit<FetchBlock, 'contentType'>): Promise<T[]>;
-    /**
-     * Quick singleton fetch helper
-     * @param singletonKey - Singleton key
-     */
-    fetchSingleton<T = unknown>(singletonKey: string): Promise<T | undefined>;
-    /**
-     * Quick aggregate helper
-     * @param source - Source content type
-     * @param metrics - Metrics to compute
-     * @param groupBy - Optional grouping field
-     */
-    aggregate<T = unknown>(source: string, metrics: Record<string, AggregateMetric>, groupBy?: string | string[]): Promise<T[]>;
-}
-
-/**
- * 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;
-
-/**
- * `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 — `.fresh(change.fresh)` on `findById()`, `query()` and `search()`, `{ fresh }` to a
- * singleton's `fetch()`. 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').findById(id).execute()
-     * ```
-     *
-     * 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'];
-/**
- * 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 products = await relyio.content('product').query().execute()
- *
- * // Search
- * const results = await relyio.search('wireless').in('product').execute()
- *
- * // Batch operations
- * const batch = await relyio.batch()
- *   .create('product', { content: { title: 'New' } })
- *   .execute()
- * ```
- */
-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 readonly 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 `withLocale()` 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 live edge's poll client id: chosen once, when first needed, and kept for this client's life. */
-    private _liveClientId;
-    constructor(config: TypedClientConfig<TSchema>);
-    /**
-     * Get the schema definition
-     */
-    get schema(): 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;
-    /**
-     * Get the ad-hoc query client. Every query it sends is in the client's locale as it is then.
-     */
-    get query(): AdhocQueryClient;
-    /**
-     * 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 products = await relyio.content('product')
-     *   .query()
-     *   .where({ status: 'active' })  // ← Field names autocomplete with schema!
-     *   .locale('en-US')
-     *   .limit(20)
-     *   .execute()
-     * ```
-     */
-    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.
-     *
-     * Mirrors `content()` but targets `entryType: 'asset'` entries on the same
-     * dynamic `/{assetTypeId}` routes, and adds the `file(entryUid)` sub-resource
-     * builder + 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')
-     *   .include(['featuredProducts'])
-     *   .locale('en')
-     *   .fetch()
-     * ```
-     */
-    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<unknown>;
-    /**
-     * 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')
-     *   .include(['defaultTemplate'])
-     *   .fetch()
-     * ```
-     */
-    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<unknown>;
-    /**
-     * Start a search query with full-text, semantic, or hybrid search.
-     *
-     * Where a schema types the client, the results are its entries — every content type's until
-     * `in()` or `across()` narrows them (`INV-SS-TYPES-INFERRED`).
-     *
-     * @example
-     * ```typescript
-     * const results = await relyio.search('wireless headphones')
-     *   .in('product')
-     *   .where({ status: 'active' })
-     *   .limit(20)
-     *   .includeScore()
-     *   .execute()
-     * ```
-     */
-    search<T extends BaseContent = SearchEntry<TSchema>>(query: string): SearchBuilder<T, TSchema>;
-    /**
-     * Start an autocomplete query for search suggestions
-     *
-     * @example
-     * ```typescript
-     * const suggestions = await relyio.autocomplete('wire')
-     *   .in('product')
-     *   .field('title')
-     *   .fuzzy()
-     *   .limit(10)
-     *   .execute()
-     * ```
-     */
-    autocomplete(query: string): AutocompleteBuilder;
-    /**
-     * Find content similar to a given entry using vector search
-     *
-     * @example
-     * ```typescript
-     * const similar = await relyio.similar('entry_abc123')
-     *   .in('product')
-     *   .locale('fr-FR')
-     *   .limit(5)
-     *   .execute()
-     * ```
-     */
-    similar<T extends BaseContent = BaseContent>(sourceId: string): SimilarBuilder<T>;
-    /**
-     * Start a batch operation for bulk create/update/delete.
-     *
-     * By default each operation lands or fails on its own. `atomic: true` makes the batch one
-     * transaction, which the API accepts only when every operation is the same kind of write and none
-     * writes a singleton that does not exist yet.
-     *
-     * @example
-     * ```typescript
-     * const result = await relyio.batch()
-     *   .create('product', { content: { title: 'iPhone', price: 999 } })
-     *   .update('product', 'entry_abc', { content: { price: 899 } })
-     *   .delete('product', 'entry_xyz')
-     *   .upsertSingleton('homepage', { content: { hero: 'Welcome!' } })
-     *   .execute()
-     *
-     * console.log(result.summary.succeeded)
-     *
-     * // All or nothing: one kind of write
-     * await relyio.batch()
-     *   .update('product', 'entry_abc', { content: { price: 899 } })
-     *   .update('product', 'entry_def', { content: { price: 799 } })
-     *   .execute({ atomic: true })
-     * ```
-     */
-    batch(): BatchBuilder<NonNullable<TSchema>>;
-    /** The search client, whose builders send the client's locale as it is when each one is sent. */
-    private searchClient;
-    /**
-     * 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).findById(change.entryId).fresh(change.fresh).execute()
-     * }
-     * ```
-     *
-     * @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).findById(change.entryId).fresh(change.fresh).execute(),
-     *   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').findById(id).execute()
-     * for await (const change of relyio.changes({ since, ids: [id] })) { … }
-     * ```
-     */
-    changesHead(options?: ChangesHeadOptions): Promise<string>;
-    /**
-     * Build and execute an ad-hoc query dynamically
-     *
-     * @example
-     * ```typescript
-     * const result = await relyio.adhoc()
-     *   .from('product')
-     *   .where({ status: 'active' })
-     *   .include(['brand', 'categories'])
-     *   .select({
-     *     id: 'id',
-     *     title: 'title',
-     *     price: 'pricing.basePrice'
-     *   })
-     *   .limit(20)
-     *   .execute()
-     * ```
-     */
-    adhoc<T = unknown>(): AdhocQueryBuilder<T>;
-    /**
-     * Execute a predefined query by name (from schema)
-     * Type-safe when schema is provided: autocompletes query names
-     *
-     * @example
-     * ```typescript
-     * const featured = await relyio.executeQuery('featured-products', {
-     *   limit: 10,
-     *   category: 'electronics'
-     * })
-     * ```
-     */
-    executeQuery<K extends TSchema extends AnySchemaDefinition ? SchemaQueryNames<TSchema> : string>(queryName: K, params?: Record<string, unknown>): Promise<unknown[]>;
-    /**
-     * 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>;
-    /**
-     * Get schema information from the API
-     */
-    getSchemaInfo(contentType?: string): Promise<unknown>;
-    /**
-     * List all content types from the API
-     */
-    listContentTypes(): Promise<Array<{
-        id: string;
-        name: string;
-        type: 'content' | 'singleton';
-    }>>;
-    /**
-     * Get API health status
-     */
-    health(): Promise<{
-        status: 'ok' | 'degraded' | 'down';
-        timestamp: string;
-    }>;
-    /**
-     * Check if the API is ready
-     */
-    ready(): Promise<boolean>;
-    /**
-     * Test the connection to the API
-     */
-    testConnection(): Promise<boolean>;
-    /**
-     * 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, a `query` client, or a builder such as `search()` or `batch()`, 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, and a sub-client's own `withLocale()`, still win over it. A client made
-     * by `withLocale()` is a client of its own: an update of this one does not reach it.
-     *
-     * @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 already derived with `withLocale()` is a client of its own and keeps
-     * its key.
-     *
-     * 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;
-    /**
-     * Create a locale-scoped client
-     *
-     * Every call the returned client builds is in this locale unless the call names one of its own,
-     * which wins: every read — `content()`, `asset()`, `singleton()`, `settings()`, `search()`,
-     * `similar()`, `autocomplete()`, `executeQuery()` and the ad-hoc queries — and every write and
-     * version-history read — `create()` and `update()`, the singleton and settings writes, the asset
-     * file writes, `versions()` and `version()`, and each operation `batch()` builds. `restore()`
-     * always names its locale; a delete, and a `batch().raw()` operation, carry none of the client's.
-     *
-     * Type-safe when schema is provided: autocompletes valid locale codes!
-     *
-     * @example
-     * ```typescript
-     * const spanish = relyio.withLocale('es-ES')  // ← Autocompletes with schema!
-     *
-     * // Reads and writes use Spanish
-     * const products = await spanish.content('product').query().execute()
-     * const homepage = await spanish.singleton('homepage').fetch()
-     * const results = await spanish.search('zapatos').execute()
-     * await spanish.content('product').update(id, { title: 'Zapatos' })
-     *
-     * // Original client unchanged
-     * const englishProducts = await relyio.content('product').query().execute()
-     * ```
-     */
-    withLocale<L extends TSchema extends AnySchemaDefinition ? SchemaLocaleCodes<TSchema> : string>(locale: L): TypedRelyIOClient<TSchema>;
-    /**
-     * Get the current default locale
-     */
-    getLocale(): string | undefined;
-    /**
-     * Get available locales from the API
-     *
-     * @example
-     * ```typescript
-     * const { locales, defaultLocale } = await relyio.getLocales()
-     *
-     * // Build language switcher
-     * const options = locales.map(l => ({
-     *   code: l.code,
-     *   label: l.displayName,
-     *   isDefault: l.default,
-     * }))
-     * ```
-     */
-    getLocales(search?: string): Promise<{
-        locales: Array<{
-            code: string;
-            displayName?: string;
-            default?: boolean;
-            fallback?: string[];
-            direction?: 'ltr' | 'rtl';
-            active?: boolean;
-        }>;
-        defaultLocale: string | null;
-        total: number;
-    }>;
-    /**
-     * Get the default locale from the API
-     */
-    getDefaultLocale(): Promise<string | null>;
-}
-/**
- * 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 products = await relyio.content('product').fetchAll()
- * ```
- *
- * @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 products = await relyio.content('product').fetchAll()
- * ```
- *
- * @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 BatchOptions as $, type ActiveSandbox as A, type SearchMode as B, type Change as C, type SearchResultItem as D, type ExtendedQueryResult as E, type FeedChange as F, type SearchHitMetadata as G, HttpClient as H, type SearchResponse as I, type AutocompleteSuggestion as J, type AutocompleteResponse as K, LIVE_KEEPALIVE_INTERVAL_MS as L, type SimilarResult as M, type SimilarResponse as N, type SearchFilter as O, type Project as P, type SearchFields as Q, type Register as R, type SandboxState as S, TypedRelyIOClient as T, type SearchSort as U, type SearchTypeName as V, type SearchEntry as W, BatchClient as X, BatchBuilder as Y, type BatchMethod as Z, type BatchOperation as _, ChangesExpiredError as a, type BatchOperationResult as a0, type BatchSummary as a1, type BatchResponse as a2, AdhocQueryClient as a3, AdhocQueryBuilder as a4, type FetchBlock as a5, type AggregateBlock as a6, type AggregateMetric as a7, type SearchBlock as a8, type FilterValue as a9, type MultipartTarget as aA, type UploadProgress as aB, ResourceNotFoundError as aC, ResourceConflictError as aD, ResourceExpiredError as aE, isResourceNotFound as aF, type FileErrorCode as aG, type FileUploadErrorCode as aH, FileUploadError as aI, FileValidationError as aJ, type FileValidationConstraints as aK, validateFile as aL, type FullTextConfig as aa, type AdhocQueryDefinition as ab, type AdhocQueryOptions as ac, type QueryMetadata as ad, type AdhocQueryResult as ae, AssetClient as af, AssetFileBuilder as ag, AssetUploadBuilder as ah, isAssetEntry as ai, type AssetVisibility as aj, type FileStatus as ak, type FileBackend as al, type AssetFileExtracted as am, type FileStatusResult as an, type AssetEntryResponse as ao, type PopulatedAssetReference as ap, type PresignInput as aq, type PresignResult as ar, type ConfirmInput as as, type ConfirmResult as at, type ResolveUrlInput as au, type ResolveUrlResult as av, type CreateAssetOptions as aw, type WaitUntilReadyOptions as ax, type MultipartCreateResult as ay, type MultipartPart as az, type ChangesExpiredReason as b, createClient as c, type TypedClientConfig as d, type ClientSchema as e, type RegisteredSchema as f, type SendOptions as g, entityTagOf as h, type ConditionalWriteOptions as i, type RetryableWriteOptions as j, type ChangesHeadOptions as k, type ChangesOptions as l, LIVE_SOCKET_OPEN_TIMEOUT_MS as m, type LiveChangesOptions as n, ContentClient as o, SingletonClient as p, SettingsClient as q, ContentQueryBuilder as r, ContentByIdBuilder as s, type ChildrenOptions as t, type SingletonFetchOptions as u, type SettingsFetchOptions as v, SearchClient as w, SearchBuilder as x, AutocompleteBuilder as y, SimilarBuilder as z };