@relyio/sdk 0.19.0 → 0.20.0

package/dist/register-DeMsaurp.d.cts

@@ -1,693 +0,0 @@
-import { c$ as paths, d0 as RetryConfig, d1 as MergedRelyIOConfig, d2 as ApiResponse, cR as components, cx as FileUpload } from './define-content-type-BZ6X8GvL.cjs';
-import { a as SchemaDefinition } from './define-schema-BPlZl4a2.cjs';
-
-/**
- * Where the SDK's transport gets its truth.
- *
- * Every route this client calls is named by its **path template as the
- * committed document spells it**, and the body type it expects is read out of
- * that document rather than written down here. `api-schema.ts` beside this file
- * is generated by `pnpm api:types` from `apps/services/api/openapi-spec.json`,
- * which is itself generated from that service's `RouteContract`s
- * (`INV-API-DOCUMENT-IS-DERIVED`). So the chain is: one declaration in
- * `routes.ts` → the serializer that produces the body → the document → these
- * types → the method that reads it.
- *
- * That chain is the answer to the question this phase exists to close. Before
- * it, six SDK methods read a key the server does not send; each had no caller
- * and no test, so nothing could see them. Now:
- *
- * - A route that changes **kind** — `collection` to `object`, say — changes
- *   whether the document's 200 body carries `page` and whether `data` is an
- *   array. `Wire<…>` follows, `readPayload` follows, and the method's declared
- *   return type stops matching. `tsc` names the method.
- * - A route that changes **path** or is deleted stops being a `keyof paths`, so
- *   the call site fails on the literal.
- * - A route that changes **dialect** changes `page` from `CursorPage` to
- *   `OffsetPage`, and anything reading `nextCursor` fails.
- *
- * `/v1` lives in these templates because it lives in the document
- * (`INV-API-VERSION-IS-DECIDED-ONCE`). Before this phase the SDK's base URL was
- * `https://api.relyio.com` and its paths were `/{contentType}`, so every
- * versioned request went to a path the router does not serve.
- *
- * Spec: `devtools/docs/guide/engineering/api-contract-spec.md`,
- * `INV-API-CLIENT-IS-DERIVED`.
- */
-
-/** Every path the committed document declares. */
-type ApiPath = keyof paths;
-type Verb = 'get' | 'post' | 'put' | 'patch' | 'delete';
-/** The verbs the document declares on this path — not the seven HTTP has. */
-type ApiMethod<P extends ApiPath> = {
-    [M in Verb]: M extends keyof paths[P] ? paths[P][M] extends {
-        responses: unknown;
-    } ? M : never : never;
-}[Verb];
-type Operation<P extends ApiPath, M extends ApiMethod<P>> = M extends keyof paths[P] ? paths[P][M] : never;
-type JsonBody<R> = R extends {
-    content: {
-        'application/json': infer B;
-    };
-} ? B : never;
-/**
- * The success body the document declares, preferring 200 where a route serves
- * both. A route with neither — `kind: 'empty'`, which serves 204 — resolves to
- * `never`, and `readPayload` cannot be called on it.
- */
-type ApiSuccessBody<P extends ApiPath, M extends ApiMethod<P>> = Operation<P, M> extends {
-    responses: infer R;
-} ? 200 extends keyof R ? JsonBody<R[200]> : 201 extends keyof R ? JsonBody<R[201]> : never : never;
-/**
- * The document's success body with the payload typed as the caller's `T`.
- *
- * The array arm is tested **first** on purpose: `{ data: unknown[] }` also
- * satisfies `{ data: unknown }`, so the object arm would swallow every
- * collection and hand a list route's caller a single entity — which is the
- * exact defect class (`ContentClient.children` reading `.data.items` from an
- * object route) that this phase makes unrepresentable.
- */
-type Wire<P extends ApiPath, M extends ApiMethod<P>, T> = ApiSuccessBody<P, M> extends {
-    data: unknown[];
-} ? Omit<ApiSuccessBody<P, M>, 'data'> & {
-    data: T[];
-} : ApiSuccessBody<P, M> extends {
-    data: unknown;
-} ? Omit<ApiSuccessBody<P, M>, 'data'> & {
-    data: T;
-} : ApiSuccessBody<P, M>;
-/**
- * The path parameters the document declares for this operation, or `never`
- * where it declares none.
- *
- * `never` rather than `{}`: a route with no segments must **forbid** a `path`
- * argument, not merely tolerate an empty one, and `keyof Record<string, never>`
- * is `string`, so an empty-object encoding cannot be told apart from a real
- * one at the type level.
- */
-type PathParamsOf<P extends ApiPath, M extends ApiMethod<P>> = Operation<P, M> extends {
-    parameters: {
-        path?: infer X;
-    };
-} ? [X] extends [undefined] ? never : NonNullable<X> : never;
-/**
- * The query parameters the document declares for this operation, or `never` where it declares
- * none (REL-687).
- *
- * The service declares them beside each route — a query DTO's whitelisted properties, the names a
- * handler reads, `?_fresh` on a read the edge keeps — and `apps/services/api`'s
- * `contract/query-parameters.spec.ts` holds the document to what each handler reads. So a name the
- * API stops reading stops compiling here, and a name it refuses — `offset` on the entry list, which
- * the SDK once sent on every `.offset()` and the API answered with a 400 — never compiled at all.
- *
- * `never` for the same reason {@link PathParamsOf} uses it: a route with no query must forbid one.
- */
-type QueryOf<P extends ApiPath, M extends ApiMethod<P>> = Operation<P, M> extends {
-    parameters: {
-        query?: infer Q;
-    };
-} ? [Q] extends [undefined] ? never : NonNullable<Q> : never;
-/** What {@link matchRoute} recovers from a URL the client emitted. */
-interface RouteMatch {
-    /** The document's path template — the value a tag translator switches on. */
-    path: ApiPath;
-    /** The template's `{name}` segments, decoded: the inverse of {@link fillPath}. */
-    params: Record<string, string>;
-    /** The query string; a key that appears more than once comes back as an array. */
-    query: Record<string, string | string[]>;
-}
-interface MatchRouteOptions {
-    /**
-     * The client's `baseUrl`, when it carries a path prefix of its own
-     * (`https://example.com/relyio`). Its path is removed before the template is
-     * matched. Unneeded for the default `https://api.relyio.com`.
-     */
-    baseUrl?: string;
-}
-/**
- * Recover the route a URL names: the inverse of {@link fillPath}, over the same
- * committed document (`INV-API-CLIENT-IS-DERIVED`).
- *
- * `matchRoute(url).path` is an `ApiPath`, so anything that keys behaviour on a
- * request — a cache-tag translator, say — switches on the document's templates
- * and never on a route table of its own.
- *
- * Returns `null` for a URL no declared template matches — a presigned storage
- * URL, or a path outside `baseUrl` — rather than a guess.
- */
-declare function matchRoute(url: string | URL, options?: MatchRouteOptions): RouteMatch | null;
-
-/**
- * The part of a request a retry decision is allowed to look at.
- *
- * `method` is typed as a plain `string` rather than as `RequestConfig['method']`
- * on purpose. The five verbs that union names are the five the typed transport
- * can express today; the question "may this be sent twice?" is a fact about
- * HTTP, and an unrecognised verb has to reach the conservative arm rather than
- * be unrepresentable.
- */
-interface RetryableRequest {
-    method: string;
-    headers?: Record<string, string>;
-}
-/**
- * Whether a failed request may be sent again, and after how long.
- *
- * The two halves are separate because they fail separately. The incumbent loop
- * had neither: it asked `error.retryable` and nothing else, so a `POST` that met
- * a 500 was sent again twice — and `SERVICE_INDETERMINATE`, whose whole meaning
- * is "the service could not decide", is marked retryable, which means the write
- * may already have landed. Meanwhile the `Retry-After` the service sent was
- * collected by the transport and read by nobody, so a 429 whose window is
- * measured in minutes was retried after an exponential guess capped at ten
- * seconds.
- *
- * `error` is `Error`, not `SDKError`, because that is what the loop actually
- * holds: a `TypeError: fetch failed` is only mapped to an `SDKError` **after**
- * the loop gives up, so a policy typed to `SDKError` could not see the transport
- * failures it most needs to retry.
- */
-interface RetryPolicy {
-    /**
-     * Never replays a request that could apply twice: a write is retried only
-     * when it carries `Idempotency-Key`, or the verb is idempotent.
-     *
-     * @param attempt - How many attempts have been made, 1 for the first.
-     */
-    shouldRetry(attempt: number, error: Error, request: RetryableRequest): boolean;
-    /** Honours `Retry-After` / `RateLimitError.resetAt` over exponential backoff. */
-    delayFor(attempt: number, error: Error): number;
-}
-/**
- * Whether sending this request a second time can apply it a second time.
- *
- * Two ways to be safe, and they are genuinely different questions: the verb may
- * be idempotent by definition, or the request may carry an `Idempotency-Key`
- * that makes the service answer a replay from the original outcome rather than
- * applying it again.
- */
-declare function isReplaySafe(request: RetryableRequest): boolean;
-/**
- * The policy the SDK ships with.
- *
- * Construction takes the same `RetryConfig` the SDK has always exported; what
- * it no longer takes is a `retryCondition`, because a caller-supplied predicate
- * over `(error, attempt)` structurally **cannot** see the request and so cannot
- * express the rule this class exists for.
- */
-declare class DefaultRetryPolicy implements RetryPolicy {
-    private readonly config;
-    constructor(config: RetryConfig);
-    shouldRetry(attempt: number, error: Error, request: RetryableRequest): boolean;
-    delayFor(attempt: number, error: Error): number;
-}
-/**
- * The retry policy a client sends with, at `maxAttempts` attempts (the first included): the SDK's
- * own, from `retryAttempts`, and the CLI's (REL-721).
- *
- * The backoff numbers are stated here once. The CLI ran a second policy beside this one —
- * `axios-retry` with its own delays and its own reading of a refusal, which retried by numeric
- * status — so a refusal one client gave up on, the other sent again. Now both ask this function, and
- * a change to when a request is replayed reaches both.
- */
-declare function retryPolicyFor(maxAttempts: number): RetryPolicy;
-
-/**
- * What a call site supplies beside the route it named.
- *
- * `path` is required exactly when the document's template has segments, and
- * forbidden when it does not — so a call that forgot to scope a request, or one
- * that scoped a request the route does not scope, is a compile error rather
- * than a URL with a literal `{id}` in it.
- */
-type SendOptions<P extends ApiPath, M extends ApiMethod<P>> = {
-    /**
-     * Query string values: exactly the names the document declares for this route, at the types it
-     * declares them (`QueryOf`, REL-687). An undeclared name is a compile error, not a 400.
-     */
-    query?: QueryOf<P, M>;
-    body?: unknown;
-    /** Request headers this call adds, e.g. `If-Match` / `Idempotency-Key` (API4). */
-    headers?: Record<string, string>;
-    signal?: AbortSignal;
-    timeout?: number;
-} & ([PathParamsOf<P, M>] extends [never] ? {
-    path?: never;
-} : {
-    path: PathParamsOf<P, M>;
-});
-/**
- * Core HTTP client for the RelyIO SDK.
- *
- * `send` is **the** typed entry: it names a route by the path template the
- * committed document declares, and returns that operation's body type with the
- * payload typed as `T`. `readPayload` from `@relyio/api-contract/client` is
- * then the one unwrap — there is no second spelling and no runtime test of
- * which envelope arrived (`INV-API-CLIENT-IS-DERIVED`).
- *
- * What the class makes public is what something outside it calls: `send` and `fetchPayload` are
- * the requests; `configure`, `withHeaders` and `setApiKey` are the owning client's (`updateConfig()`,
- * `with()`, `setApiKey()`). There are no verb helpers, no header or base-URL accessors and no
- * untyped `request` (REL-717): a route is named by its document path, or it is not called.
- */
-declare class HttpClient {
-    /** What every request reads off the configuration, derived by {@link configure} and nowhere else. */
-    protected connection: Connection;
-    /**
-     * Set on a view {@link withHeaders} made: the client every request is sent through, and the
-     * headers laid beneath each request's own. A view keeps no connection of its own that matters —
-     * everything it is asked to change, it changes on that client.
-     */
-    protected view?: {
-        readonly client: ControlledHttpClient;
-        readonly headers: Readonly<Record<string, string>>;
-        /** The End user's token function this view asks in place of its client's, when it names one. */
-        readonly getToken?: EndUserTokenSource;
-    };
-    constructor(config: MergedRelyIOConfig);
-    protected announce(): void;
-    /**
-     * Send bytes to an address that is not a RelyIO route — an asset upload's presigned `PUT` and its
-     * multipart parts — through the client's configured `fetch`, so a wrapper that records, proxies or
-     * forbids network access sees every request this client makes (REL-2671). Nothing else is added: no
-     * key, no retry, no timeout, because the address belongs to the storage service, not to RelyIO.
-     *
-     * Static so the instances a customer holds stay `send` and `fetchPayload` (REL-3107). The `fetch`
-     * is read per call, from the client a view sends through, like the requests are.
-     */
-    static transfer(client: HttpClient, url: string, init: RequestInit): Promise<Response>;
-    /**
-     * Call a route the committed document declares, and get back the body that
-     * document says it serves.
-     */
-    send<P extends ApiPath, M extends ApiMethod<P>, T = unknown>(path: P, method: M, options: SendOptions<P, M>): Promise<ApiResponse<Wire<P, M, T>>>;
-    /**
-     * Call a route and return its payload — `send` plus the one unwrap, which is
-     * what all but a handful of call sites want.
-     */
-    fetchPayload<P extends ApiPath, M extends ApiMethod<P>, T = unknown>(path: P, method: M, options: SendOptions<P, M>): Promise<Wire<P, M, T> extends {
-        data: unknown;
-    } ? Wire<P, M, T>['data'] : never>;
-    /**
-     * Make an HTTP request, retrying only where a retry is safe.
-     *
-     * The headers are merged **once**, before the first attempt, and every attempt
-     * sends that same object. That is what makes a minted `Idempotency-Key` stable
-     * across the retries of one logical write: the service sees one key and
-     * answers the replay from the original outcome instead of applying it twice.
-     *
-     * The loop always makes one attempt. The incumbent's `while (attempt <
-     * maxAttempts)` made none at `retryAttempts: 0` — a value the config validator
-     * then accepted, and now refuses — and then dereferenced an unassigned
-     * `lastError`. `retryAttempts` is the most attempts, the first included; an
-     * `HttpClient` constructed directly is not validated, so the first attempt
-     * stays unconditional.
-     *
-     * A request that would carry no `X-API-Key` makes none: it rejects with
-     * `MissingApiKeyError` before `fetch` is called, is not retried, and names
-     * `apiKey`. This is where a client built without a key learns it — the
-     * constructor accepts one so that a module-scope client can be evaluated by a
-     * build that holds no key (REL-1120) — and so does one whose `setApiKey` was
-     * given none.
-     *
-     * The End user's token is asked for once, after the key is known to be there and before the first
-     * attempt — of `getToken`, the nearest view's function, or the configuration's — so every retry
-     * of one call sends the token its first attempt sent. See `RelyIOConfig.getToken`.
-     */
-    private request;
-    /**
-     * One attempt.
-     *
-     * The caller's `signal` and the timeout both end it, through one controller.
-     * The incumbent handed `fetch` the caller's signal **instead of** its own, so a
-     * request that passed a signal had no timeout at all — and a caller abort then
-     * surfaced as `Request timed out`. `timedOut` is what tells the two apart: a
-     * timeout is a `TimeoutError`, a caller abort is the platform's `AbortError`,
-     * rethrown as it came.
-     */
-    private makeRequest;
-    /**
-     * The headers without those a browser controls itself, when this is a browser; unchanged when it
-     * is not.
-     *
-     * A name is matched without regard to case (RFC 9110 §5.1), because a browser refuses `Origin`
-     * whatever case a page spells it in. This matched only the all-lowercase and all-uppercase
-     * spellings, so `Origin` and `User-Agent` — how people write them — reached `fetch` (REL-1409).
-     */
-    private filterHeadersForBrowser;
-    /**
-     * Prepare request body based on content type and environment
-     */
-    private prepareRequestBody;
-    private parseResponse;
-    private resolveUrl;
-    private mergeRequestConfig;
-    private buildQueryString;
-    private headersToObject;
-    private log;
-}
-/**
- * The client the SDK's own factory holds: {@link HttpClient} plus the three things only the owning
- * client does to it — `configure` (`updateConfig()`), `withHeaders` (`with()`) and `setApiKey`
- * (`setApiKey()`). It is not exported from the package, so a customer holding the client from
- * `getHttpClient()` sees `send` and `fetchPayload` and nothing else (REL-3107).
- */
-declare class ControlledHttpClient extends HttpClient {
-    /**
-     * A view of this client that sends every request through it with `headers` added — beneath the
-     * request's own, over this client's — and changes nothing else: its key, base URL, timeout,
-     * retries and `fetch` are this client's as they are when each request is sent, so a later
-     * `configure()` or `setApiKey()` on this client reaches the view, and one on the view reaches
-     * this client. `client.with({ dataset })` is one (REL-2417).
-     *
-     * `options.getToken` is the End user's token function the view asks in place of this client's,
-     * and of any view it is made from: `client.with({ getToken })` (REL-3882).
-     */
-    withHeaders(headers: Readonly<Record<string, string>>, options?: {
-        readonly getToken?: EndUserTokenSource;
-    }): ControlledHttpClient;
-    /**
-     * Run on `config` from now on: every later request — whoever holds this client — is sent to its
-     * `baseUrl`, with its headers, key and dataset, its timeout and retries, through its `fetch`, and
-     * logged by its `debug` options.
-     *
-     * The client's own `updateConfig()` calls this rather than building a second client, so a
-     * `content()` or other sub-client taken before the update sends through the update too. Anything
-     * set on this client since it was last configured — `setApiKey()` — is replaced by what `config`
-     * says.
-     */
-    configure(config: MergedRelyIOConfig): void;
-    /**
-     * Replace the key every later request sends as `X-API-Key`, and the `apiKey` the configuration
-     * reports.
-     *
-     * The key is read the way construction reads it (`presentCredential`): an absent, empty or blank key is
-     * no key, so the header is dropped and the next request is refused with `MissingApiKeyError`
-     * before anything is sent. A key header of any other spelling — one given in `headers` — goes
-     * too, from the headers sent and from the headers the configuration reports, so the old key is
-     * never sent beside the new one.
-     *
-     * The configuration is the one the owning `TypedRelyIOClient` holds (it hands its own to the
-     * constructor), so its `getConfig().apiKey` — what a surface reads to decide a key's kind — is the
-     * key sent from here on.
-     *
-     * This replaced `setAuthToken`, which added `Authorization: Bearer` beside an `X-API-Key` it
-     * never touched: the API reads `X-API-Key` first, so the old key was the one used (REL-1385).
-     */
-    setApiKey(apiKey: string): void;
-}
-/** What `getToken` is: asked per call, answering the signed-in End user's token or `null`. */
-type EndUserTokenSource = NonNullable<MergedRelyIOConfig['getToken']>;
-/** Everything a request reads off the configuration, replaced whole whenever it changes. */
-interface Connection {
-    /**
-     * The configuration itself, for what is read per request — `fetch`, the `browser` options,
-     * `debug` — and the object `setApiKey` writes the key into, which the owning client reports.
-     */
-    readonly config: MergedRelyIOConfig;
-    readonly baseUrl: string;
-    readonly defaultHeaders: Readonly<Record<string, string>>;
-    readonly timeout: number;
-    readonly retryPolicy: RetryPolicy;
-}
-
-/**
- * One Record type's Records over the Content API (spec 1, REL-3771): `relyio.records('order')`.
- *
- * A Record is an app's data — an order, a stock level, a cart — written by your server with a
- * secret key and live the moment it lands: no draft, no publication, no locale, no version. A
- * publishable key lists and gets the Records a Record type's read Policy grants it — anonymously, or
- * as the End user whose token it carries (spec 4, REL-3883) — and creates, updates and deletes them
- * only as that End user, as the type's write Policy allows (REL-3884): RelyIO sets the owner from
- * the token. With no token it writes nothing (`PUBLISHABLE_KEY_REFUSED`).
- *
- * Every body is read from the committed document (`INV-API-CLIENT-IS-DERIVED`): the paths are the
- * document's, and `RecordMetadata` is its schema by name.
- */
-
-/** What the API reports about a Record beside its fields. */
-type RecordMetadata = components['schemas']['RecordMetadata'];
-/** A Record as a read answers it: its fields at the top level, and `_metadata`. */
-type BaseRecord = Record<string, unknown> & {
-    _metadata: RecordMetadata;
-};
-/** What a Record read and write take beside their own options. */
-interface RecordCallOptions {
-    /** The dataset, by id or name, over the client's. */
-    dataset?: string;
-    signal?: AbortSignal;
-}
-/**
- * What a Record read may expand (REL-3772): include paths, in the grammar `content().get` takes —
- * `lines.product`, `convertedTo.lines.product(title)`. A reference to an entry expands into the
- * entry as this key reads it — published with a secret key, its draft with a preview key — and one
- * to a Record into the Record. A reference to an entry the key cannot see, or that is gone, reads
- * as `null` — unless it is a pinned reference (`pin: 'version'`), which reads the entry as it was
- * at the version the Record pinned, whatever it has done since, its `_metadata.pin` naming that
- * version and the one the key reads now (REL-3776).
- */
-interface RecordReadOptions extends RecordCallOptions {
-    include?: readonly string[];
-    /**
-     * The locale each included entry is composed in, with its schema's fallback; the schema's
-     * default when absent. A Record has no locale of its own (REL-3776).
-     */
-    locale?: string;
-}
-/** What an update takes: the revision the change was made on. */
-interface RecordUpdateOptions extends RecordCallOptions {
-    /**
-     * `_metadata.revision` of the read the change was made on. A Record written since is refused
-     * with `ResourceConflictError`, its `blockage` (`revision-stale`) naming the fields that changed,
-     * and nothing is written.
-     */
-    revision: number;
-}
-/** A list's options: one page of the Records `where` keeps, in one order. */
-interface RecordListOptions<TFields> extends RecordReadOptions {
-    /** Field conditions, in the grammar `content().list({ where })` takes. */
-    where?: {
-        [K in keyof TFields]?: unknown;
-    } & Record<string, unknown>;
-    /** One key: `createdAt`, `updatedAt`, `id` or a field holding one value. Default `createdAt:desc`. */
-    sort?: `${'createdAt' | 'updatedAt' | 'id' | (keyof TFields & string)}:${'asc' | 'desc'}`;
-    limit?: number;
-    cursor?: string;
-    /** Answer `meta.count`: how many Records `where` keeps across every page. */
-    count?: boolean;
-    /** Count the values of each of these fields among the Records `where` keeps, under `meta.facets`. */
-    facets?: ReadonlyArray<keyof TFields & string>;
-}
-/** What an upload of a Record's File takes beside its bytes (REL-3824). */
-interface RecordFileUploadOptions extends RecordCallOptions {
-    /** The File's name, as a read will answer it. */
-    name: string;
-    /** Its media type: one the field's `accept` admits. */
-    type: string;
-}
-/** The bytes of a File: what `fetch` sends as a body, of a length known before it is sent. */
-type RecordFileBytes = Blob | ArrayBuffer | Uint8Array;
-/** One facet's buckets: each value and how many Records hold it, most frequent first. */
-interface RecordFacetBucket {
-    readonly value: unknown;
-    readonly count: number;
-}
-/** One page of a Record list, as the API answers it. */
-interface RecordList<T> {
-    data: T[];
-    page: {
-        nextCursor: string | null;
-        hasMore: boolean;
-    };
-    meta: {
-        count?: number;
-        facets?: Record<string, RecordFacetBucket[]>;
-    };
-}
-/**
- * One Record type's Records.
- *
- * @example
- * ```typescript
- * const orders = relyio.records('order')
- * const order = await orders.create({ shopperEmail: 'ada@example.com', status: 'paid', total: 19 })
- * const { data: paid, meta } = await orders.list({
- *   where: { status: 'paid' },
- *   sort: 'createdAt:asc',
- *   count: true,
- * })
- * ```
- */
-declare class RecordsClient<TRecord extends BaseRecord = BaseRecord, TInput = Record<string, unknown>, 
-/** What an update takes: the create's values without the type's Counters (REL-3765). */
-TUpdate = TInput> {
-    private readonly httpClient;
-    readonly recordType: string;
-    constructor(httpClient: HttpClient, recordType: string);
-    /**
-     * Store a Record, live the moment it lands. Values that break the Record type's fields are
-     * refused with `ValidationError` naming each field, and nothing is stored. Values a unique set of
-     * the type claims, held by another Record, are refused with `ResourceConflictError` — its
-     * `blockage` is `{ kind: 'value-taken', facts: { fields, recordId } }` (REL-3782) — with no
-     * `recordId` for an End user's write, whose read Policy may hide the holder (REL-3863).
-     */
-    create(fields: TInput, options?: RecordCallOptions): Promise<TRecord>;
-    /** One page of the Records `where` keeps, newest first unless `sort` names one key. */
-    list(options?: RecordListOptions<Omit<TRecord, '_metadata'>>): Promise<RecordList<TRecord>>;
-    /**
-     * Upload a File for one of this Record type's file fields (REL-3824), and answer what a create or
-     * update sets the field to. The bytes go straight to object storage at the address the upload
-     * names, never through RelyIO; a File outside the field's `accept` or over its `maxSize` is
-     * refused with `ValidationError` naming the field before any byte is sent. An upload no write
-     * names within a day is deleted with its bytes. Server-side only, as every Record call is.
-     *
-     * @example
-     * ```typescript
-     * const invoice = await relyio.records('order').upload('invoice', pdfBytes, {
-     *   name: 'invoice-1001.pdf',
-     *   type: 'application/pdf',
-     * })
-     * await relyio.records('order').update(id, { invoice }, { revision })
-     * ```
-     */
-    upload(field: string, bytes: RecordFileBytes, options: RecordFileUploadOptions): Promise<FileUpload>;
-    /**
-     * One Record by its id, or `null` when none is stored. A Record type nobody deployed throws
-     * `ResourceNotFoundError` naming it, so it never reads as a missing Record.
-     */
-    get(id: string, options?: RecordReadOptions): Promise<TRecord | null>;
-    /**
-     * Change the fields named, against the revision the change was made on, and answer the Record at
-     * its next revision. A field given `null` is removed; one not named keeps its value. A Record
-     * written since `revision` is refused with `ResourceConflictError` — its `blockage` is
-     * `{ kind: 'revision-stale', facts: { changedFields } }` — and nothing is written. Values that
-     * break the Record type are refused with `ValidationError` naming each field, and values another
-     * Record holds under a unique set with `ResourceConflictError`, its blockage `value-taken`.
-     *
-     * @example
-     * ```typescript
-     * const order = await relyio.records('order').get(id)
-     * await relyio.records('order').update(id, { status: 'shipped' }, {
-     *   revision: order._metadata.revision,
-     * })
-     * ```
-     */
-    update(id: string, fields: {
-        [K in keyof TUpdate]?: TUpdate[K] | null;
-    }, options: RecordUpdateOptions): Promise<TRecord>;
-    /**
-     * Remove a Record. Another Record holding it through a reference declared to block its delete —
-     * the default — is refused with `ResourceConflictError`, its `blockage`
-     * (`{ kind: 'referenced', facts: { referrers } }`) naming each; one declared `nullify` is cleared.
-     */
-    delete(id: string, options?: RecordCallOptions): Promise<void>;
-}
-
-/**
- * The atomic Record batch (spec 1, REL-3774): `relyio.records.batch([...])` — an ordered list of
- * Record operations across Record types, run in one transaction, all or none.
- *
- * Each operation is `create`, `update`, `delete`, `increment` or `decrement`, and names its Record by
- * `id`, by `where` (the one Record of its type whose top-level fields have those values), or both —
- * `where` then a precondition. A refused operation rolls the whole batch back, and the refusal names
- * it: {@link refusedOperationOf} reads its index off the error. A counter moved past its bound is a
- * `ResourceConflictError` whose `blockage` is `counter-out-of-bounds`, naming the field, the bound and
- * the value it holds.
- *
- * Every batch is sent with an `Idempotency-Key` — yours, or one minted for the call — so a batch
- * retried after a lost answer is answered as done, never written twice.
- */
-
-/** A condition's value: what one top-level field holds, compared for equality. */
-type RecordConditionValue = string | number | boolean | null;
-/**
- * Which stored Record an operation lands on: by `id`, by `where`, or both. Every `where` is read
- * before the batch's first operation runs, so it names a Record stored before the batch — never one
- * an earlier operation of the same batch creates.
- */
-type RecordBatchTarget = {
-    id: string;
-    where?: Record<string, RecordConditionValue>;
-} | {
-    id?: undefined;
-    where: Record<string, RecordConditionValue>;
-};
-/** One operation of a batch. `type` is a Record type the schema declares. */
-type RecordBatchOperation<TType extends string = string> = {
-    op: 'create';
-    type: TType;
-    fields: Record<string, unknown>;
-} | ({
-    op: 'update';
-    type: TType;
-    /** The fields to change; one given `null` is removed. A counter is never set. */
-    fields: Record<string, unknown>;
-    /** The revision the change was made on; absent, the update writes over the one stored. */
-    revision?: number;
-} & RecordBatchTarget) | ({
-    op: 'delete';
-    type: TType;
-} & RecordBatchTarget) | ({
-    op: 'increment' | 'decrement';
-    type: TType;
-    /** The counter. */
-    field: string;
-    /** A whole number above zero. */
-    by: number;
-} & RecordBatchTarget);
-/** What a batch takes beside its operations. */
-interface RecordBatchOptions extends RecordCallOptions {
-    /**
-     * The key naming this batch. Sent again — by you, or by a retry — the batch is answered as the
-     * first was and written once; with other operations it is refused. Minted for you when absent.
-     */
-    idempotencyKey?: string;
-}
-/** What a committed batch answers: each operation, in order, and whether this is a replay. */
-type RecordBatchResult = components['schemas']['RecordBatchResult'];
-/** What one operation of a committed batch did. */
-type RecordBatchOperationResult = components['schemas']['RecordBatchOperationResult'];
-/**
- * The index, from 0, of the batch operation a refusal names: a `ResourceConflictError`'s
- * `blockage.facts.operation`, or the first violation under `operations[<index>]` of a
- * `ValidationError`. `undefined` for an error that names none — one about the whole batch, such as
- * an allowance, or no batch refusal at all.
- */
-declare function refusedOperationOf(error: unknown): number | undefined;
-
-/**
- * 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;
-
-export { type AnySchemaDefinition as A, type BaseRecord as B, type RecordBatchOptions as C, DefaultRetryPolicy as D, HttpClient as H, type MatchRouteOptions as M, type QueryOf as Q, type RegisteredSchema as R, type SendOptions as S, type Wire as W, type RecordBatchTarget as a, type RecordBatchResult as b, type Register as c, type RecordConditionValue as d, type ApiPath as e, type ApiMethod as f, type ApiSuccessBody as g, type RouteMatch as h, isReplaySafe as i, type RetryPolicy as j, type RetryableRequest as k, RecordsClient as l, matchRoute as m, type RecordCallOptions as n, type RecordFacetBucket as o, type RecordFileBytes as p, type RecordFileUploadOptions as q, retryPolicyFor as r, type RecordList as s, type RecordListOptions as t, type RecordMetadata as u, type RecordReadOptions as v, type RecordUpdateOptions as w, refusedOperationOf as x, type RecordBatchOperation as y, type RecordBatchOperationResult as z };