@haddowg/json-api-client 1.0.0

package/dist/validate-BmyPbJCK.d.cts

@@ -0,0 +1,1254 @@
+//#region src/descriptor.d.ts
+/**
+ * The generated runtime descriptor (ADR 0001). The codegen emits one of these per
+ * server `as const satisfies ApiDescriptor`; the client's TYPES are derived from it
+ * (one source of truth). It carries everything the generic runtime needs that types
+ * alone can't: attribute-vs-relation, cardinality, related type(s), per-operation
+ * path templates (uriType/prefix-aware), paginator kind, and the create client-id
+ * policy.
+ */
+type Cardinality = 'one' | 'many';
+/**
+ * The mutation verbs a single relationship endpoint advertises (derived from the HTTP
+ * methods it exposes). These are NOT uniform across relations — the bundle gates them
+ * per relation (`cannotAdd`/`cannotRemove`/`cannotReplace`, per-relation endpoint
+ * exposure) — so the descriptor carries the capability per relation and the fluent
+ * surface gates `add`/`remove`/`replace`/`set` on it (see ADR 0001 follow-up).
+ *
+ * For a to-many: `add` <- POST, `remove` <- DELETE, `replace` <- PATCH.
+ * For a to-one: `set` <- PATCH. A flag is `true` iff the endpoint advertises the verb.
+ */
+interface RelationMutations {
+  add?: boolean;
+  remove?: boolean;
+  replace?: boolean;
+  set?: boolean;
+}
+interface RelationDescriptor {
+  cardinality: Cardinality;
+  /** Related JSON:API type(s); more than one = polymorphic. */
+  types: readonly string[];
+  /** Whether members carry pivot data (`meta.pivot`). */
+  pivot?: boolean;
+  /**
+   * The pivot fields carried on each member's `meta.pivot` (a `belongsToMany` relation), as a
+   * field-name → wire-format-hint map (the same hint vocabulary as {@link ResourceDescriptor.attributes}).
+   * Types `$pivot` precisely (`{ position: number; weight: number; addedAt: string }`) instead of a
+   * loose `Record<string, unknown>` (D33). Absent when the relation carries no pivot.
+   */
+  pivotFields?: Readonly<Record<string, string>>;
+  /**
+   * `false` when the related endpoint (`GET /{type}/{id}/{rel}`) is suppressed for this relation
+   * (the bundle's `withoutRelatedEndpoint()`, ADR 0027) — `.related()` is then a compile error /
+   * runtime guard rather than a 404. Absent means exposed (the default).
+   */
+  related?: boolean;
+  /**
+   * `false` when the relationship endpoint (`.../relationships/{rel}`) is suppressed for this
+   * relation (the bundle's `withoutRelationshipEndpoint()`, ADR 0027) — `.get()` (and every
+   * mutation) is then gated off. Absent means exposed (the default).
+   */
+  relationship?: boolean;
+  /**
+   * The per-relation mutation verbs the relationship endpoint advertises. An explicit `{}` means
+   * the endpoint exposes no mutation verb (gates every verb OFF). Absent means the descriptor
+   * carries no signal (a hand-written descriptor) — gating then falls back to cardinality alone.
+   * A codegen descriptor always emits this (at least `{}`) so suppression never fails open.
+   */
+  mutations?: RelationMutations;
+  /**
+   * The `withCount` count tokens + negotiation profile this relation's related/relationship reads
+   * advertise (`_self_` + the relation's own countable relations). Lets `.related()`/`.get()` send
+   * `withCount` and negotiate the right profile; absent when the relation advertises no Countable
+   * profile (D3).
+   */
+  countable?: CountableDescriptor;
+  /**
+   * The paginator kind this relation's OWN related/relationship endpoints advertise
+   * (`GET /{type}/{id}/{rel}` / `.../relationships/{rel}`), when it DIVERGES from the related
+   * type's collection-level {@link ResourceDescriptor.paginator}. A related endpoint may paginate
+   * differently than the related type's own collection (e.g. a cursor-paginated related to-many
+   * whose target type is page-paginated at its top-level collection) — so the client resolves a
+   * related/embedded to-many array's `$page.kind` from this per-relation value first, falling back
+   * to the related type's collection paginator (D6a). Absent when the two agree (the common case).
+   */
+  paginator?: PaginatorKind;
+}
+type PaginatorKind = 'page' | 'offset' | 'cursor' | 'none';
+type ClientIdPolicy = 'forbidden' | 'optional' | 'required';
+/** Where a custom action is invoked: collection-scoped (`/{type}/-actions/{name}`) or resource-scoped (`/{type}/{id}/-actions/{name}`). */
+type ActionScope = 'collection' | 'resource';
+/** The body a custom action accepts: a JSON:API document, no body, or a raw (non-JSON:API) payload. */
+type ActionInput = 'document' | 'none' | 'raw';
+/**
+ * What a custom action returns: a JSON:API document (materialised into the resource view of its
+ * {@link ActionDescriptor.outputType}), a meta-only document (its top-level `meta`), or nothing (a
+ * `204`).
+ */
+type ActionOutput = 'document' | 'meta' | 'none';
+/**
+ * A custom action declared on a type (`#[AsJsonApiAction]`). The runtime reaches it via
+ * `client.<type>.actions.<name>(...)` (collection scope) or
+ * `client.<type>.id(id).actions.<name>(...)` (resource scope); `input`/`output` drive how the body
+ * is sent and the response shaped (see CONTEXT.md "Write surface").
+ */
+interface ActionDescriptor {
+  scope: ActionScope;
+  /** The action path template (e.g. `/albums/{id}/-actions/reissue`). */
+  path: string;
+  /**
+   * The HTTP method the action is invoked over, upper-case (e.g. `PATCH`). Absent means `POST`
+   * (the default) — so an action declaring a single non-POST method (`#[AsJsonApiAction(methods:
+   * ['PATCH'])]`) stays reachable rather than being silently dropped.
+   */
+  method?: string;
+  input: ActionInput;
+  output: ActionOutput;
+  /**
+   * The JSON:API type of a `document`-input action's body — lets the client accept FLAT input
+   * (like `create`) and build the envelope + remap `422` pointers, rather than the caller
+   * hand-building `{ data: { type, attributes } }`. Absent for `none`/`raw` inputs, or a bespoke
+   * command document whose type isn't a registered resource (then the raw envelope is passed
+   * through).
+   */
+  inputType?: string;
+  /**
+   * The JSON:API type of a `document`-output action's primary resource — the client materialises
+   * the response into that type's resource view (matching the read path), so the typed result is
+   * `result.title`, not `result.data.attributes.title`. Absent for `meta`/`none` outputs.
+   */
+  outputType?: string;
+  /** Whether a `document`-output action returns a single resource (`one`) or a collection (`many`). */
+  outputCardinality?: Cardinality;
+  /**
+   * The declared request media type for a `raw`-input action (e.g. `application/octet-stream`),
+   * sent verbatim as the `Content-Type` so the server accepts the non-JSON:API body. Absent for
+   * `document` (the JSON:API media type) and `none` (no body) inputs.
+   */
+  contentType?: string;
+}
+/**
+ * The `withCount` capability of a type's read endpoints (the Countable profile, core ADR
+ * 0101). `tokens` are the count tokens a `withCount` query may carry (`_self_` counts the
+ * collection itself; a relation name counts that relation per item); `profile` is the URI a
+ * client must negotiate (in `Accept`) before the server honours `withCount` — else it is
+ * rejected (400) under strict query-param validation. Absent when no read endpoint of the
+ * type advertises `withCount`.
+ */
+interface CountableDescriptor {
+  tokens: readonly string[];
+  profile: string;
+}
+interface ResourceDescriptor {
+  /** Attribute name -> wire format hint (drives optional value coercion). */
+  attributes: Readonly<Record<string, string>>;
+  relations: Readonly<Record<string, RelationDescriptor>>;
+  /** Per-operation path templates, e.g. `{ fetchOne: '/albums/{id}' }`. */
+  paths: Readonly<Record<string, string>>;
+  paginator: PaginatorKind;
+  clientId: ClientIdPolicy;
+  /**
+   * The `withCount` count tokens + negotiation profile for this type's read endpoints.
+   * Absent when no read endpoint advertises `withCount`.
+   */
+  countable?: CountableDescriptor;
+  /**
+   * The relation paths the read endpoints accept in `include` — the exact enum the OpenAPI
+   * document advertises, including nested dotted paths (`tracks.album`). Drives `include`
+   * narrowing. Absent when the type advertises no includable relations (so `include` is then
+   * a compile error, matching the server's `400 INCLUSION_NOT_ALLOWED`).
+   */
+  includable?: readonly string[];
+  /**
+   * The sort tokens the COLLECTION read accepts in `sort` — signed field names (`title`,
+   * `-title`). Drives `sort` narrowing. Absent when the collection advertises no sorting (so
+   * `sort` is then a compile error, matching the server's `400 SORTING_UNSUPPORTED`).
+   */
+  sortable?: readonly string[];
+  /**
+   * The filter keys the COLLECTION read accepts in `filter[...]`. Drives `filter` key narrowing
+   * (values stay `unknown` — value shapes/operators vary per filter, out of scope for v0.1).
+   * Absent when the collection advertises no filters (so any `filter` is then a compile error,
+   * matching the server's `400 FILTERING_UNRECOGNIZED`).
+   */
+  filterable?: readonly string[];
+  /** Custom actions declared on this type, keyed by action name. Absent/empty when none. */
+  actions?: Readonly<Record<string, ActionDescriptor>>;
+}
+type ApiDescriptor = Readonly<Record<string, ResourceDescriptor>>;
+/**
+ * The server-level Atomic Operations capability (ADR 0001): the single `/operations`
+ * endpoint, detected when its requestBody uses the atomic ext media type. `null` when the
+ * server exposes no atomic endpoint. Carried alongside the per-type descriptor (not inside
+ * it — atomic is server-level, not per-type) so the runtime `client.atomic` builder can
+ * reach the path.
+ */
+interface AtomicDescriptor {
+  path: string;
+}
+//#endregion
+//#region src/materialise.d.ts
+/** A trimmed, by-reference top-level envelope shared by every resource from one response. */
+interface DocumentEnvelope {
+  jsonapi?: Record<string, unknown>;
+  meta?: Record<string, unknown>;
+  links?: Record<string, unknown>;
+}
+/** Resource-level links (`self` is the common one; the wire may carry more). */
+interface ResourceLinks {
+  self?: string;
+  [key: string]: unknown;
+}
+/** The relationship-instance envelope for a materialised related value (its `$edge`). */
+interface Edge {
+  links?: Record<string, unknown>;
+  meta?: Record<string, unknown>;
+}
+/** Normalised pagination, discriminated by paginator kind; count-free-safe. */
+interface Page {
+  kind: PaginatorKind;
+  /** The raw `meta.page` block, when present (shape varies by kind). */
+  meta?: Record<string, unknown>;
+  /** Navigation links by relation (`first`/`prev`/`next`/`last`), when present. */
+  links: {
+    first?: string;
+    prev?: string;
+    next?: string;
+    last?: string;
+  };
+}
+/** The uniform shape `$rel(name)` returns. */
+interface RelationView {
+  data?: unknown;
+  links?: Record<string, unknown>;
+  meta?: Record<string, unknown>;
+}
+/** Non-enumerable envelope accessors shared by every materialised resource. */
+interface ResourceEnvelope {
+  readonly $meta: Record<string, unknown> | undefined;
+  readonly $links: ResourceLinks | undefined;
+  readonly $self: string | undefined;
+  readonly $document: DocumentEnvelope;
+  readonly $raw: RawResource;
+  $rel(name: string): RelationView | undefined;
+}
+/** Edge-local accessors carried by a materialised related VALUE (per-edge view). */
+interface EdgeEnvelope {
+  readonly $edge: Edge | undefined;
+  readonly $pivot: Record<string, unknown> | undefined;
+}
+/** Relationship-level accessors carried by an augmented to-many array. */
+interface ArrayEnvelope {
+  readonly $page: Page;
+  readonly $links: Record<string, unknown> | undefined;
+  readonly $meta: Record<string, unknown> | undefined;
+  $next(): Promise<unknown>;
+  $prev(): Promise<unknown>;
+}
+/** The runtime context materialise reads its descriptor + navigation seam from. */
+interface MaterialiseContext {
+  descriptor: ApiDescriptor;
+  /**
+   * Re-fetch + re-materialise a link (wired in Build 4); returns the materialised value.
+   * `linkage` propagates the originating surface so a paginated relationship-endpoint
+   * array re-materialises as identifiers (not resources) on `$next()`/`$prev()`. `paginator`
+   * carries the current page's kind so the re-materialised page reports the same `$page.kind`
+   * (a divergent per-relation paginator, or an EMPTY next page that carries no member to sniff).
+   */
+  navigate: (url: string, linkage?: boolean, paginator?: PaginatorKind) => Promise<unknown>;
+  /**
+   * The opt-in per-resource validator (ADR 0004), resolved from `ClientOptions.validate`. When
+   * present, every wire resource in `data`/`included` is validated against its per-type schema
+   * before the document is materialised. Absent => no per-field validation (the default).
+   */
+  validate?: ResolvedValidator | undefined;
+}
+/** A raw JSON:API resource object (or bare identifier) off the wire. */
+interface RawResource {
+  type: string;
+  id: string;
+  meta?: Record<string, unknown>;
+  links?: ResourceLinks;
+  attributes?: Record<string, unknown>;
+  relationships?: Record<string, RawRelationship>;
+}
+interface RawRelationship {
+  data?: unknown;
+  links?: Record<string, unknown>;
+  meta?: Record<string, unknown>;
+}
+/**
+ * Materialise a JSON:API document into a hydrated graph (ADR 0002 / CONTEXT.md):
+ *
+ * - single resource -> a flattened resource object (own enumerable type/id/attributes/
+ *   relations + non-enumerable `$`-accessors);
+ * - collection / related collection -> an augmented array of resource objects;
+ * - relationship linkage -> an augmented array of identifier views (to-many) or a single
+ *   identifier / null (to-one).
+ *
+ * Included resources hydrate into nested per-edge views (reads through to the shared
+ * node for attributes, owns its own `$edge`/`$pivot`); linked-but-not-included relations
+ * stay as identifiers; links-only relations are `undefined`. The envelope rides
+ * non-enumerable `$`-accessors so `{...res}` / `JSON.stringify(res)` are clean.
+ *
+ * `linkage` discriminates a relationship-endpoint response (primary `data` is pure
+ * resource-identifier linkage) from a resource/collection response (primary `data` is a
+ * full resource) — a structural guess can't tell them apart for an attribute-less,
+ * relation-less resource, so the caller passes the surface it issued.
+ *
+ * `paginatorOverride` sets the top-level array's `$page.kind` for a related/relationship read,
+ * where the paginator is the RELATION's (which may diverge from the related type's collection —
+ * D6a) and an empty page carries no member to sniff a type from. `primaryType` is preferred for a
+ * top-level collection read (statically-known); both override the sniff-from-`data[0]` fallback.
+ */
+declare function materialise(doc: Document, ctx: MaterialiseContext, linkage?: boolean, primaryType?: string, paginatorOverride?: PaginatorKind): unknown;
+/**
+ * A to-many relation's paginator kind. The relation's OWN related/relationship endpoint may
+ * paginate differently than the related type's top-level collection (D6a), so prefer the
+ * per-relation `paginator` (carried in the descriptor only when it diverges); otherwise fall back
+ * to the related type's own paginator (the relationship and related endpoints both paginate that
+ * type), so the discriminant is identical across the three surfaces. A polymorphic relation
+ * resolves off its first declared related type (its members span types, matching the relationship
+ * endpoint's first-member resolution).
+ */
+declare function relatedPaginatorKind(relation: RelationDescriptor | undefined, ctx: MaterialiseContext): PaginatorKind;
+//#endregion
+//#region src/types.d.ts
+/** The JSON:API media type. */
+declare const JSON_API_MEDIA_TYPE = "application/vnd.api+json";
+/** The Atomic Operations extension URI. */
+declare const ATOMIC_EXT = "https://jsonapi.org/ext/atomic";
+/**
+ * The media-type parameters a request opts into: extension URIs (`ext`) and/or profile URIs
+ * (`profile`). Each is rendered as a space-joined, quoted media-type parameter per RFC 6839 /
+ * the JSON:API spec (`ext="<uri> <uri>"`, `profile="<uri> <uri>"`).
+ */
+interface MediaTypeParams {
+  ext?: readonly string[] | undefined;
+  profiles?: readonly string[] | undefined;
+}
+/**
+ * Compose the JSON:API media type with any opted-in `ext`/`profile` parameters. Each parameter
+ * is a space-joined, double-quoted URI list, in the canonical order `ext` then `profile` so the
+ * output is deterministic (stable for caching/assertions). Empty/absent lists are omitted; with
+ * neither, the bare {@link JSON_API_MEDIA_TYPE} is returned (no behaviour change for a plain
+ * request). Used for both `Accept` and (when a body is present) `Content-Type`.
+ */
+declare function mediaType(params?: MediaTypeParams): string;
+/**
+ * The media type for an Atomic Operations request/response: the JSON:API media type carrying
+ * the atomic `ext` parameter. Sent as both `Content-Type` and `Accept` on a `client.atomic`
+ * batch (per the JSON:API atomic extension).
+ */
+declare const ATOMIC_MEDIA_TYPE: string;
+/** A resource identifier: the shape a non-included but linked relation takes. */
+interface ResourceIdentifier<TType extends string = string> {
+  type: TType;
+  id: string;
+  meta?: Record<string, unknown>;
+}
+/** A local id reference used inside an atomic transaction (`{ type, lid }`). */
+interface LocalIdentifier<TType extends string = string> {
+  type: TType;
+  lid: string;
+}
+//#endregion
+//#region src/atomic.d.ts
+/**
+ * A reference to a resource for an `update`/`remove` op: a bare identifier (or a materialised
+ * resource — its `{type,id}` extracted), OR a `{ type, lid }` local identifier targeting a
+ * resource CREATED EARLIER IN THE SAME BATCH (e.g. a `tx.create` handle), so an op can update
+ * or remove a just-created resource that has no server id yet (per the JSON:API atomic ext,
+ * `ref` may carry `lid` instead of `id`).
+ */
+type AtomicRef = ResourceIdentifier | {
+  type: string;
+  id: string;
+} | LocalIdentifier | {
+  type: string;
+  lid: string;
+};
+/**
+ * Flat create input for type `T`: the `type` discriminant plus the type's flat create
+ * attributes/relation slots (reusing {@link CreateInput}; relation slots may reference a prior
+ * `tx.create` handle). `D`/`W` thread the descriptor + write-attribute map for precise fields;
+ * the loose defaults keep a codegen-less caller compiling.
+ */
+type AtomicCreateInput<D extends ApiDescriptor, W, T extends TypeName<D>> = {
+  type: T;
+} & CreateInput<D, W, T>;
+/**
+ * Flat update input for type `T`: the `type` discriminant + the target's identity (`id`, OR a
+ * `lid` for a resource created earlier in the same batch) plus the type's flat update
+ * attributes/relation slots (reusing {@link UpdateInput}).
+ */
+type AtomicUpdateInput<D extends ApiDescriptor, W, T extends TypeName<D>> = ({
+  type: T;
+  id: string;
+  lid?: never;
+} & UpdateInput<D, W, T>) | ({
+  type: T;
+  lid: string;
+  id?: never;
+} & UpdateInput<D, W, T>);
+/**
+ * The handle a {@link AtomicRecorder.create} returns. It is a `lid`-bearing relationship ref
+ * (`{ type, lid }`) — pass it (or spread it) into a later op's relation slot to wire the
+ * just-created resource without a server id. It also carries its op `kind` (`'create'`) and its
+ * `opIndex` (its position in the batch, the created resource's positional result) so the typed
+ * result tuple can map it back to the right positional result.
+ */
+interface AtomicCreateHandle<T extends string = string> extends LocalIdentifier {
+  readonly type: T;
+  readonly kind: 'create';
+  readonly opIndex: number;
+}
+/**
+ * The handle a {@link AtomicRecorder.update} returns: its type discriminant `T`, its op `kind`
+ * (`'update'`) and its `opIndex`. Returned (alongside the create handle) from the callback so its
+ * positional result is typed as the materialised resource of `T`.
+ */
+interface AtomicUpdateHandle<T extends string = string> {
+  readonly type: T;
+  readonly kind: 'update';
+  readonly opIndex: number;
+}
+/**
+ * The handle a {@link AtomicRecorder.delete} returns: its op `kind` (`'delete'`) and its
+ * `opIndex`. A delete carries no data, so its positional result is `undefined`.
+ */
+interface AtomicDeleteHandle {
+  readonly kind: 'delete';
+  readonly opIndex: number;
+}
+/**
+ * Any handle a recorder method returns — the element type of the callback's result tuple, used
+ * as the inference constraint for the typed-tuple `atomic` form. The discriminant is left open
+ * (`string`, NOT `TypeName<D>`) DELIBERATELY, so the type is descriptor-agnostic: a tighter
+ * `TypeName<D>` constraint would flow the full type union into each element's contextual type
+ * during array-literal inference, widening a `tx.create({ type: 'albums' })` handle's `T` back to
+ * the whole union — losing the per-op narrowing. The recorder methods already guarantee each `T`
+ * is a real `TypeName<D>`, so the open constraint is sound; `AtomicResultOf` re-infers the precise
+ * `T` per element (guarded by `TypeName<D>` there).
+ */
+type AtomicHandle = AtomicCreateHandle<string> | AtomicUpdateHandle<string> | AtomicDeleteHandle;
+/**
+ * The recorder handed to the `client.atomic` callback. Each method appends an op (preserving
+ * order) and returns a handle carrying the op's discriminant `T`, `kind`, and `opIndex`. The
+ * methods are generic over `T` (inferred from the input's `type`), so a create/update is typed
+ * by the type's write-input ({@link CreateInput}/{@link UpdateInput}) and its handle resolves to
+ * the materialised resource of `T`. `create` still returns a usable `{ type, lid }` ref so a
+ * just-created resource wires into a later op without a server id.
+ */
+interface AtomicRecorder<D extends ApiDescriptor, W> {
+  create<T extends TypeName<D>>(input: AtomicCreateInput<D, W, T>): AtomicCreateHandle<T>;
+  update<T extends TypeName<D>>(input: AtomicUpdateInput<D, W, T>): AtomicUpdateHandle<T>;
+  delete(ref: AtomicRef): AtomicDeleteHandle;
+}
+/** One positional result of an atomic batch: the materialised `data` (a resource/`null`) plus any op `meta`. */
+interface AtomicResult<Data = unknown> {
+  data: Data;
+  meta?: Record<string, unknown>;
+}
+/**
+ * The typed result tuple for a callback that returns a tuple of handles `Ops`: each returned
+ * handle maps (by {@link AtomicResultOf}) to its materialised positional result — a create/update
+ * handle to the `AtomicResult` of its type, a delete handle to `undefined`. The mapping is
+ * positional in the RETURNED order (sound regardless of subset/reorder, since the runtime resolves
+ * each handle by its `opIndex`).
+ */
+type AtomicResults<D extends ApiDescriptor, A, Ops extends readonly AtomicHandle[]> = { -readonly [K in keyof Ops]: AtomicResultOf<D, A, Ops[K]> };
+/**
+ * Run an atomic transaction. Invokes `build` with a recorder, collecting the operations (always
+ * via the recorder's side effect, preserving op order), then posts `{ "atomic:operations": [...] }`
+ * to the atomic endpoint with the ext media type as both `Content-Type` and `Accept`. The server's
+ * `{ "atomic:results": [...] }` is parsed positionally — each result's `data` materialised the same
+ * as a read.
+ *
+ * The return shape depends on what `build` returns:
+ *
+ * - returns a tuple of handles -> a per-op POSITIONALLY-TYPED tuple: each returned handle is
+ *   resolved to its result BY ITS `opIndex` (`results[handle.opIndex]`), so the tuple is sound
+ *   regardless of the order/subset the callback returns the handles in (a delete handle resolves
+ *   to `undefined`);
+ * - returns void/nothing -> the loose, ordered `AtomicResult[]` (backward-compatible).
+ *
+ * A thrown {@link JsonApiError} has each error's pointer remapped to `(opIndex, flatPath)` (the
+ * failing op's type drives the flat-path inversion) before it propagates.
+ */
+declare function runAtomic<D extends ApiDescriptor, A, W, const Ops>(request: JsonApiContext, materialiseCtx: MaterialiseContext, descriptor: D, path: string, build: (tx: AtomicRecorder<D, W>) => Ops): Promise<Ops extends readonly AtomicHandle[] ? AtomicResults<D, A, Ops> : AtomicResult[]>;
+//#endregion
+//#region src/result-types.d.ts
+/**
+ * An augmented array (CONTEXT.md "To-many relationship values are augmented arrays"):
+ * a real, read-only `T[]` carrying the non-enumerable relationship-level envelope
+ * (`$page`/`$links`/`$meta`) plus link-driven `$next()`/`$prev()` navigation. The same
+ * model backs top-level collections, related-endpoint collections, and hydrated/linkage
+ * to-many relationship values ("one model, three surfaces").
+ */
+type Collection<T> = ReadonlyArray<T> & Omit<ArrayEnvelope, '$next' | '$prev'> & {
+  $next(): Promise<Collection<T> | undefined>;
+  $prev(): Promise<Collection<T> | undefined>;
+};
+/**
+ * The edge-local accessors carried by a materialised related VALUE (a per-edge view):
+ * `$edge` (this membership's edge meta/links) and `$pivot` (typed sugar over
+ * `$edge.meta.pivot`). `$pivot` is graceful: present iff the endpoint rendered
+ * `meta.pivot` (relationship/related endpoints), `undefined` otherwise.
+ */
+interface EdgeMembers<Pivot = Record<string, unknown>> {
+  readonly $edge: Edge | undefined;
+  readonly $pivot: Pivot | undefined;
+}
+/** The resource-level `$`-accessors on a materialised resource object. */
+interface ResourceAccessors {
+  readonly $meta: Record<string, unknown> | undefined;
+  readonly $links: ResourceLinks | undefined;
+  readonly $self: string | undefined;
+  readonly $document: DocumentEnvelope;
+  readonly $raw: Record<string, unknown>;
+  $rel(name: string): RelationView | undefined;
+}
+/** Every wire type declared by the descriptor `D`. */
+type TypeName<D extends ApiDescriptor> = Extract<keyof D, string>;
+/** The relation names declared on type `T` of descriptor `D`. */
+type RelationName<D extends ApiDescriptor, T extends TypeName<D>> = Extract<keyof D[T]['relations'], string>;
+/** The attribute object for type `T`, from the generated attributes map `A` (falls back to `{}`). */
+type AttributesOf<A, T> = T extends keyof A ? A[T] : Record<string, never>;
+/**
+ * A sparse-fieldset selection map: wire type -> the member names (`fields[type]`) a read
+ * requested for that type. Threaded through {@link ResourceObjectView} so an unrequested
+ * attribute/relation is statically ABSENT, matching the runtime (the server only emits the
+ * requested members). The default `unknown` means "no fieldset narrowing" — every member is
+ * present, as it was before.
+ */
+type FieldSelectionMap = Readonly<Record<string, readonly string[]>>;
+/**
+ * The selected member names for type `T` from a fieldset map `F`, or the {@link AllFields}
+ * sentinel when `F` declares no entry for `T` (so that type's members are all present). The
+ * `unknown` map (no `fields` query at all) also resolves to {@link AllFields}. A member of `F`
+ * keyed `T` whose value is `readonly string[]` selects exactly those names.
+ */
+type AllFields = {
+  readonly __allFields: unique symbol;
+};
+/** Resolve the selected member-name union for type `T` from fieldset map `F` (or {@link AllFields}). */
+type SelectedFields<F, T extends string> = F extends FieldSelectionMap ? T extends keyof F ? F[T][number] : AllFields : AllFields;
+/**
+ * Pick only the members of `Obj` selected by `Sel` (a member-name union, or {@link AllFields}
+ * to keep them all). When narrowing, a key absent from `Sel` is dropped, so the resulting
+ * object's keys are exactly the requested members — the static mirror of a sparse fieldset.
+ */
+type PickSelected<Obj, Sel> = [Sel] extends [AllFields] ? Obj : Pick<Obj, Extract<keyof Obj, Sel>>;
+/**
+ * The related wire type(s) of relation `R` on type `T`. A union when polymorphic; the
+ * member is narrowed to types that actually exist in the descriptor so the hydrated
+ * shape composes.
+ */
+type RelatedType<D extends ApiDescriptor, T extends TypeName<D>, R extends RelationName<D, T>> = Extract<D[T]['relations'][R]['types'][number], TypeName<D>>;
+/** True when relation `R` of type `T` is to-many. */
+type IsMany<D extends ApiDescriptor, T extends TypeName<D>, R extends RelationName<D, T>> = D[T]['relations'][R]['cardinality'] extends 'many' ? true : false;
+/**
+ * The bare resource-identifier shape a non-included (but linked) relation takes,
+ * carrying the per-edge `$edge`/`$pivot` accessors the runtime attaches to every
+ * materialised related value.
+ */
+type IdentifierMember<TType extends string, Pivot = Record<string, unknown>> = ResourceIdentifier<TType> & EdgeMembers<Pivot>;
+/**
+ * A hydrated related resource: a per-edge VIEW — the full `ResourceObjectView` of the
+ * related node plus this membership's `$edge`/`$pivot`. Relations one hop deep stay as
+ * identifiers (no nested-include narrowing in the read API today). The fieldset map `F`
+ * threads through so a sparse fieldset on the included type narrows its attributes/relations.
+ * `Pivot` types the per-edge `$pivot` (a `belongsToMany` relation's `meta.pivot`).
+ */
+type HydratedMember<D extends ApiDescriptor, A, TType extends TypeName<D>, F = unknown, Pivot = Record<string, unknown>> = ResourceObjectView<D, A, TType, never, F> & EdgeMembers<Pivot>;
+/** A hydrated related value distributes over a polymorphic union of related types. */
+type Hydrated<D extends ApiDescriptor, A, TType extends TypeName<D>, F = unknown, Pivot = Record<string, unknown>> = TType extends TypeName<D> ? HydratedMember<D, A, TType, F, Pivot> : never;
+/** An identifier related value distributes over a polymorphic union of related types. */
+type Identifier<TType extends string, Pivot = Record<string, unknown>> = TType extends string ? IdentifierMember<TType, Pivot> : never;
+/**
+ * The static value of one relation slot, resolved by cardinality and whether the
+ * relation name is present in the read's `include` tuple `Inc`:
+ *
+ * - to-one, included  -> the hydrated related resource, or `null` (an empty to-one with
+ *   `data: null` materialises to `null` even when included);
+ * - to-one, excluded  -> `Identifier | null | undefined` (absent/links-only/empty are valid);
+ * - to-many, included -> a `Collection` of hydrated members;
+ * - to-many, excluded -> a `Collection` of identifier members.
+ *
+ * (Excluded to-many stays a `Collection`: linkage may still be present, and a lazy
+ * to-many materialises as an augmented array regardless — only its members differ.)
+ */
+type RelationValue<D extends ApiDescriptor, A, T extends TypeName<D>, R extends RelationName<D, T>, Inc, F = unknown> = R extends Inc ? IsMany<D, T, R> extends true ? Collection<Hydrated<D, A, RelatedType<D, T, R>, F>> : Hydrated<D, A, RelatedType<D, T, R>, F> | null : IsMany<D, T, R> extends true ? Collection<Identifier<RelatedType<D, T, R>>> : Identifier<RelatedType<D, T, R>> | null | undefined;
+/**
+ * The relation slots of type `T`, each typed by cardinality and include-presence, then
+ * narrowed to the fieldset selection for `T` (relations are sparse-fieldset members too — an
+ * unrequested relation is statically absent).
+ */
+type Relations<D extends ApiDescriptor, A, T extends TypeName<D>, Inc, F = unknown> = PickSelected<{ [R in RelationName<D, T>]: RelationValue<D, A, T, R, Inc, F> }, SelectedFields<F, T>>;
+/**
+ * A materialised resource object: flattened `type` + `id` + attributes + relation slots
+ * as own enumerable props, intersected with the resource-level `$`-accessors. `Inc` is
+ * the union of relation names included by the read (narrows relations to hydrated); `F` is
+ * the sparse-fieldset selection map (narrows attributes/relations to the requested members —
+ * `type`/`id`/the `$`-accessors are always present). The default `F = unknown` keeps every
+ * member (no fieldset narrowing).
+ */
+type ResourceObjectView<D extends ApiDescriptor, A, T extends TypeName<D>, Inc = never, F = unknown> = {
+  type: T;
+  id: string;
+} & PickSelected<AttributesOf<A, T>, SelectedFields<F, T>> & Relations<D, A, T, Inc, F> & ResourceAccessors;
+/**
+ * The element type of the `include` array for type `T`: a path from the descriptor's
+ * `includable` enum — the exact set the server advertises, including nested dotted paths
+ * (`tracks.album`). `never` when the type advertises nothing includable (so `include` is a
+ * compile error, matching the server's `400 INCLUSION_NOT_ALLOWED`). Only the top-level
+ * relation of each path drives return-type narrowing (see {@link IncludedRelations}).
+ */
+type IncludePath<D extends ApiDescriptor, T extends TypeName<D>> = D[T] extends {
+  includable: infer I;
+} ? I extends readonly (infer P)[] ? P & string : never : never;
+/**
+ * The union of top-level relation names present in an `include` tuple (drops dotted children).
+ * Mapped element-wise over the tuple (`{ [K in keyof Inc]: ... }[number]`) rather than
+ * distributed over `Inc[number]` — a distributive template-literal `infer` collapses the union to
+ * a single head when the tuple mixes dotted and plain paths (e.g. `['artist', 'tracks.album']`
+ * would drop `tracks`), silently leaving an included relation un-hydrated.
+ */
+type IncludedRelations<D extends ApiDescriptor, T extends TypeName<D>, Inc extends readonly IncludePath<D, T>[]> = Extract<{ [K in keyof Inc]: Inc[K] extends `${infer Head}.${string}` ? Head : Inc[K] }[number], RelationName<D, T>>;
+/**
+ * The `withCount` count tokens type `T` accepts (its `countable.tokens` literal union), or
+ * `never` when the type advertises no Countable profile (`withCount` is then unusable). `_self_`
+ * counts the collection; a relation name counts that relation per item.
+ */
+type CountToken<D extends ApiDescriptor, T extends TypeName<D>> = D[T] extends {
+  countable: {
+    tokens: infer Tokens;
+  };
+} ? Tokens extends readonly (infer Token)[] ? Token & string : never : never;
+/**
+ * A sort token type `T`'s COLLECTION read accepts (its `sortable` literal union — signed
+ * field names like `title`/`-title`), or `never` when the collection advertises no sorting.
+ */
+type SortToken<D extends ApiDescriptor, T extends TypeName<D>> = D[T] extends {
+  sortable: infer S;
+} ? S extends readonly (infer Token)[] ? Token & string : never : never;
+/**
+ * A filter key type `T`'s COLLECTION read accepts (its `filterable` literal union), or `never`
+ * when the collection advertises no filters.
+ */
+type FilterKey<D extends ApiDescriptor, T extends TypeName<D>> = D[T] extends {
+  filterable: infer Fl;
+} ? Fl extends readonly (infer Key)[] ? Key & string : never : never;
+/**
+ * The `sort` value for type `T`: one of the advertised tokens or a tuple of them. `never`
+ * (so `sort` cannot be supplied at all) when the collection advertises no sorting — a
+ * compile-time mirror of the server's `400 SORTING_UNSUPPORTED`.
+ */
+type SortQuery<D extends ApiDescriptor, T extends TypeName<D>> = [SortToken<D, T>] extends [never] ? never : SortToken<D, T> | readonly SortToken<D, T>[];
+/**
+ * The `filter` object for type `T`: keys constrained to the advertised filter params (values
+ * stay `unknown` — value shapes/operators vary). `never` (so `filter` cannot be supplied) when
+ * the collection advertises no filters — a compile-time mirror of `400 FILTERING_UNRECOGNIZED`.
+ */
+type FilterQuery<D extends ApiDescriptor, T extends TypeName<D>> = [FilterKey<D, T>] extends [never] ? never : Partial<Record<FilterKey<D, T>, unknown>>;
+/**
+ * The element type of the `fields` map for a typed read: a member-name array per wire type,
+ * each name constrained to that type's declared attributes/relations. Capturing the literal
+ * names (a `const` tuple) drives the sparse-fieldset return-type narrowing.
+ */
+type FieldsMap<D extends ApiDescriptor> = { [T in TypeName<D>]?: readonly MemberName<D, T>[] };
+/**
+ * A selectable sparse-fieldset member of type `T`: an attribute name (the descriptor's
+ * `attributes` keys) or a relation name. The descriptor carries the literal member names, so
+ * `fields` entries are constrained to real members.
+ */
+type MemberName<D extends ApiDescriptor, T extends TypeName<D>> = Extract<keyof D[T]['attributes'], string> | RelationName<D, T>;
+/**
+ * A read query carrying a typed, narrowing `include`, a typed `fields` (drives sparse-fieldset
+ * return narrowing), a `withCount` constrained to the type's count tokens, plus the loose
+ * JSON:API query families. `Inc`/`F` are inferred (as `const`) at the call site. Used for the
+ * COLLECTION read (`list`); the single-resource read (`get`) uses {@link SingleReadQuery}, which
+ * drops `withCount` (no `GET /{type}/{id}` endpoint advertises it).
+ */
+interface TypedReadQuery<D extends ApiDescriptor, T extends TypeName<D>, Inc extends readonly IncludePath<D, T>[], F extends FieldsMap<D> = FieldsMap<D>> {
+  /** The relations to include — drives static narrowing; constrained to the advertised paths. */
+  include?: Inc;
+  /** Filter the collection — keys constrained to the type's advertised `filter[...]` params. */
+  filter?: FilterQuery<D, T>;
+  /** Sort the collection — constrained to the type's advertised (signed) sort tokens. */
+  sort?: SortQuery<D, T>;
+  /** Sparse fieldsets per type — drives return-type narrowing (unrequested members are absent). */
+  fields?: F;
+  /** Relationship-count tokens (the Countable profile) — comma-joined onto `withCount`. */
+  withCount?: readonly CountToken<D, T>[];
+  page?: Record<string, unknown>;
+}
+/**
+ * A single-resource read query (`GET /{type}/{id}`): only `include` and sparse `fields`. A
+ * single-resource endpoint advertises neither `sort`/`filter`/`page` (no collection to order,
+ * filter or page) nor `withCount` — accepting any of them would be a lying type (the server
+ * rejects an unrecognised parameter with `400` under strict query-param validation).
+ */
+interface SingleReadQuery<D extends ApiDescriptor, T extends TypeName<D>, Inc extends readonly IncludePath<D, T>[], F extends FieldsMap<D> = FieldsMap<D>> {
+  /** The relations to include — drives static narrowing; constrained to the advertised paths. */
+  include?: Inc;
+  /** Sparse fieldsets per type — drives return-type narrowing (unrequested members are absent). */
+  fields?: F;
+}
+/**
+ * The static return type of a read on type `T` given its `include` tuple and `fields` selection
+ * `F` — the resource object with the named relations narrowed to hydrated and its members
+ * narrowed to the requested sparse fieldset.
+ */
+type ReadResult<D extends ApiDescriptor, A, T extends TypeName<D>, Inc extends readonly IncludePath<D, T>[] = [], F = unknown> = ResourceObjectView<D, A, T, IncludedRelations<D, T, Inc>, F>;
+/** A loose read query (filter/sort/include/fields/page/withCount) for the relationship/related endpoints. */
+interface RelationReadQuery {
+  filter?: Record<string, unknown>;
+  sort?: string | readonly string[];
+  include?: readonly string[];
+  fields?: Record<string, readonly string[]>;
+  page?: Record<string, unknown>;
+  /**
+   * Relationship-count tokens (`_self_` + the relation's countable relations) — the related/
+   * relationship endpoints advertise their own `withCount`, and the client negotiates the
+   * relation's Countable profile so a strict server accepts it (D3).
+   */
+  withCount?: readonly string[];
+}
+/** The TS type a descriptor wire-format hint maps to (mirrors the runtime coercion vocabulary). */
+type FormatToTs<H> = H extends 'number' | 'integer' ? number : H extends 'boolean' ? boolean : H extends 'object' ? Record<string, unknown> : H extends 'array' ? readonly unknown[] : H extends 'unknown' ? unknown : string;
+/**
+ * The typed `meta.pivot` shape of relation `R` — built from the descriptor's per-relation
+ * `pivotFields` (field-name → format hint), e.g. `{ position: number; weight: number; addedAt:
+ * string }`. Falls back to a loose record when the relation carries no pivot fields (D33).
+ */
+type PivotFieldsOf<D extends ApiDescriptor, T extends TypeName<D>, R extends RelationName<D, T>> = D[T]['relations'][R] extends {
+  pivotFields: infer P;
+} ? { readonly [K in keyof P]: FormatToTs<P[K]> } : Record<string, unknown>;
+/**
+ * A hydrated related VALUE for relation `R` of type `T`, resolved by cardinality over the
+ * (possibly polymorphic) related type(s): a `Collection` of hydrated members for to-many,
+ * the hydrated member (or `null`) for to-one. Each member's `$pivot` is typed from the
+ * relation's `pivotFields` (D33).
+ */
+type RelatedValue<D extends ApiDescriptor, A, T extends TypeName<D>, R extends RelationName<D, T>> = IsMany<D, T, R> extends true ? Collection<Hydrated<D, A, RelatedType<D, T, R>, unknown, PivotFieldsOf<D, T, R>>> : Hydrated<D, A, RelatedType<D, T, R>, unknown, PivotFieldsOf<D, T, R>> | null;
+/**
+ * A linkage VALUE for relation `R` (the `/relationships/{rel}` endpoint, identifiers only):
+ * a `Collection` of identifier members for to-many, a single identifier (or `null`) for to-one.
+ * Each member's `$pivot` is typed from the relation's `pivotFields` (D33).
+ */
+type LinkageValue<D extends ApiDescriptor, T extends TypeName<D>, R extends RelationName<D, T>> = IsMany<D, T, R> extends true ? Collection<Identifier<RelatedType<D, T, R>, PivotFieldsOf<D, T, R>>> : Identifier<RelatedType<D, T, R>, PivotFieldsOf<D, T, R>> | null;
+/**
+ * A relationship accessor off a {@link ResourceHandle} (`client.albums.id('1').tracks`):
+ * reads — `.get()` (linkage) / `.related()` (related collection); writes — to-many
+ * `.add`/`.remove`/`.replace([refs])` (POST/DELETE/PATCH) and to-one `.set(ref|null)`
+ * (PATCH). A read is present only when the relation exposes that endpoint (the descriptor's
+ * `related`/`relationship` flags, from the bundle's `withoutRelatedEndpoint()` /
+ * `withoutRelationshipEndpoint()`, ADR 0027); a write is present only when the relationship
+ * endpoint advertises that verb (the per-relation `mutations` flags, from `cannotAdd`/
+ * `cannotRemove`/`cannotReplace`). A suppressed read or forbidden verb is typed `never`, so
+ * calling it is a compile error rather than a server round-trip. A write returns the materialised
+ * linkage, or `void` when the server replies `204`.
+ */
+interface RelationshipAccessor<D extends ApiDescriptor, A, T extends TypeName<D>, R extends RelationName<D, T>> {
+  get: ExposesRelationship<D, T, R> extends true ? (query?: RelationReadQuery) => Promise<LinkageValue<D, T, R>> : never;
+  related: ExposesRelated<D, T, R> extends true ? (query?: RelationReadQuery) => Promise<RelatedValue<D, A, T, R>> : never;
+  add: RelationMutation<D, T, R, 'add', readonly WriteRef<D, T, R>[]>;
+  remove: RelationMutation<D, T, R, 'remove', readonly LinkageRefOf<RelatedType<D, T, R>>[]>;
+  replace: RelationMutation<D, T, R, 'replace', readonly WriteRef<D, T, R>[]>;
+  set: RelationMutation<D, T, R, 'set', LinkageRefOf<RelatedType<D, T, R>> | null>;
+}
+/**
+ * A linkage ref for a to-many membership WRITE (`add`/`replace`) on relation `R`, with `$pivot`
+ * typed from the relation's `pivotFields` — so a `belongsToMany` add carries the precise pivot
+ * shape (`{ position, weight, … }`) instead of a loose record (D33).
+ */
+type WriteRef<D extends ApiDescriptor, T extends TypeName<D>, R extends RelationName<D, T>> = LinkageRefOf<RelatedType<D, T, R>> & {
+  $pivot?: PivotFieldsOf<D, T, R>;
+};
+/**
+ * True unless relation `R`'s related endpoint is suppressed (`related: false`, the bundle's
+ * `withoutRelatedEndpoint()`). Absent flag ⇒ exposed (the default / a hand-written descriptor).
+ */
+type ExposesRelated<D extends ApiDescriptor, T extends TypeName<D>, R extends RelationName<D, T>> = D[T]['relations'][R] extends {
+  related: false;
+} ? false : true;
+/**
+ * True unless relation `R`'s relationship endpoint is suppressed (`relationship: false`, the
+ * bundle's `withoutRelationshipEndpoint()`). Absent flag ⇒ exposed (the default).
+ */
+type ExposesRelationship<D extends ApiDescriptor, T extends TypeName<D>, R extends RelationName<D, T>> = D[T]['relations'][R] extends {
+  relationship: false;
+} ? false : true;
+/** The mutation verb a relationship accessor method maps to (`add`/`remove`/`replace` to-many, `set` to-one). */
+type MutationVerb = 'add' | 'remove' | 'replace' | 'set';
+/** The cardinality a mutation verb belongs to (`set` is to-one; the rest are to-many). */
+type VerbCardinality<V extends MutationVerb> = V extends 'set' ? 'one' : 'many';
+/**
+ * True when relation `R` of type `T` advertises mutation verb `V`. The descriptor's
+ * `mutations` flags are authoritative when present; when the relation carries no
+ * `mutations` block at all (an older/looser descriptor), gating falls back to cardinality
+ * alone so the verb stays callable. Crucially, an explicit `mutations: {}` (or one missing
+ * the verb's flag) gates the verb OFF.
+ */
+type AdvertisesVerb<D extends ApiDescriptor, T extends TypeName<D>, R extends RelationName<D, T>, V extends MutationVerb> = D[T]['relations'][R] extends {
+  mutations: infer M;
+} ? M extends Partial<Record<V, boolean>> ? M[V] extends true ? true : false : false : true;
+/**
+ * A relationship-mutation method, gated by both cardinality and the per-relation verb
+ * capability: present (typed `(refs) => Promise<…>`) only when the relation's cardinality
+ * matches the verb's cardinality AND the relation advertises the verb (see
+ * {@link AdvertisesVerb}); otherwise `never`, so calling the wrong verb for the cardinality
+ * — or a verb the relation forbids (e.g. a to-many lacking `replace`) — is a compile error.
+ * The result is the materialised linkage value or `void` (a `204` response).
+ */
+type RelationMutation<D extends ApiDescriptor, T extends TypeName<D>, R extends RelationName<D, T>, V extends MutationVerb, Refs> = D[T]['relations'][R]['cardinality'] extends VerbCardinality<V> ? AdvertisesVerb<D, T, R, V> extends true ? (refs: Refs) => Promise<LinkageValue<D, T, R> | void> : never : never;
+/** The relationship accessors of type `T`, keyed by relation name. */
+type RelationshipAccessors<D extends ApiDescriptor, A, T extends TypeName<D>> = { [R in RelationName<D, T>]: RelationshipAccessor<D, A, T, R> };
+/**
+ * Writable pivot data carried on a to-many member as `$pivot` (a belongsToMany relation
+ * with `pivot: true`). Loose by design — the OpenAPI write attributes don't model per-edge
+ * pivot fields, so the runtime passes the object through as `meta.pivot`.
+ */
+type PivotInput = Record<string, unknown>;
+/**
+ * A single linkage reference accepted by a relationship-write input: a bare resource
+ * identifier `{ type, id }`, a materialised resource object (its `type`/`id` are extracted by
+ * the runtime), OR a local identifier `{ type, lid }` — an atomic-transaction `tx.create` handle
+ * referencing a resource created earlier in the same batch (the runtime serialises the `lid`).
+ * A to-many member may additionally carry `$pivot`.
+ */
+type LinkageRef<TType extends string> = (ResourceIdentifier<TType> & {
+  $pivot?: PivotInput;
+}) | (LocalIdentifier<TType> & {
+  $pivot?: PivotInput;
+}) | (ResourceObjectView<ApiDescriptor, unknown, TType> & {
+  $pivot?: PivotInput;
+});
+/** A linkage ref distributed over a (possibly polymorphic) union of related types. */
+type LinkageRefOf<TType extends string> = TType extends string ? LinkageRef<TType> : never;
+/**
+ * The relationship VALUE accepted in a create/update input slot, by cardinality:
+ * to-one accepts a single ref or `null` (clear); to-many accepts an array of refs.
+ */
+type RelationInput<D extends ApiDescriptor, T extends TypeName<D>, R extends RelationName<D, T>> = IsMany<D, T, R> extends true ? readonly LinkageRefOf<RelatedType<D, T, R>>[] : LinkageRefOf<RelatedType<D, T, R>> | null;
+/** The relationship slots of type `T` as optional write input keys (one per declared relation). */
+type RelationInputs<D extends ApiDescriptor, T extends TypeName<D>> = { [R in RelationName<D, T>]?: RelationInput<D, T, R> };
+/** The `{ create; update }` write-attribute pair for type `T` (or an open pair when `T` is absent from `W`). */
+type WritePair<W, T> = T extends keyof W ? W[T] : {
+  create: Record<string, unknown>;
+  update: Record<string, unknown>;
+};
+/** The create attribute object for type `T` from the write map `W`. */
+type CreateAttributesOf<W, T> = WritePair<W, T> extends {
+  create: infer C;
+} ? C : object;
+/** The update attribute object for type `T` from the write map `W`. */
+type UpdateAttributesOf<W, T> = WritePair<W, T> extends {
+  update: infer U;
+} ? U : object;
+/**
+ * The `id` field of a create input, typed by the type's `clientId` policy:
+ * `forbidden` -> no `id` key; `optional` -> `id?: string`; `required` -> `id: string`.
+ */
+type CreateId<D extends ApiDescriptor, T extends TypeName<D>> = D[T]['clientId'] extends 'required' ? {
+  id: string;
+} : D[T]['clientId'] extends 'optional' ? {
+  id?: string;
+} : {
+  id?: never;
+};
+/**
+ * The flat input to `client.<type>.create(input)`: the type's create attributes + relation
+ * slots, plus an `id` keyed by the client-id policy. The runtime builds the JSON:API
+ * envelope (routing keys to attributes/relationships via the descriptor).
+ */
+type CreateInput<D extends ApiDescriptor, W, T extends TypeName<D>> = CreateAttributesOf<W, T> & RelationInputs<D, T> & CreateId<D, T>;
+/**
+ * The flat input to `client.<type>.id(id).update(patch)`: the type's update attributes (all
+ * optional) + relation slots. The id rides the handle, never the input.
+ */
+type UpdateInput<D extends ApiDescriptor, W, T extends TypeName<D>> = UpdateAttributesOf<W, T> & RelationInputs<D, T>;
+/** Options for a create/update write — an optional `include`/`fields` narrowing the materialised response. */
+interface WriteOptions<D extends ApiDescriptor, T extends TypeName<D>, Inc extends readonly IncludePath<D, T>[] = [], F extends FieldsMap<D> = FieldsMap<D>> {
+  include?: Inc;
+  /** Sparse fieldsets per type — narrows the materialised write response. */
+  fields?: F;
+}
+/**
+ * The materialised positional result of a single atomic op handle:
+ *
+ * - an {@link AtomicCreateHandle}/{@link AtomicUpdateHandle} for type `T` -> the `AtomicResult`
+ *   wrapping the materialised resource view of `T` (the same {@link ResourceObjectView} a
+ *   standalone create/update read returns — `data` is typed, not `unknown`, plus the optional op
+ *   `meta`);
+ * - an {@link AtomicDeleteHandle} -> `undefined` (a remove carries no data).
+ *
+ * Drives the per-op positional typing of {@link AtomicResults} (the callback's returned tuple of
+ * handles maps to a tuple of these).
+ */
+type AtomicResultOf<D extends ApiDescriptor, A, Handle> = Handle extends AtomicDeleteHandle ? undefined : Handle extends AtomicCreateHandle<infer T> ? T extends TypeName<D> ? AtomicResult<ResourceObjectView<D, A, T>> : never : Handle extends AtomicUpdateHandle<infer T> ? T extends TypeName<D> ? AtomicResult<ResourceObjectView<D, A, T>> : never : never;
+/** The custom actions declared on type `T` (the descriptor's `actions` block, or `{}`). */
+type ActionsOf<D extends ApiDescriptor, T extends TypeName<D>> = D[T] extends {
+  actions: infer Acts;
+} ? Acts : Record<string, never>;
+/** The action names of type `T` declared at scope `Scope` (collection vs resource). */
+type ActionNameAtScope<D extends ApiDescriptor, T extends TypeName<D>, Scope extends string> = Extract<{ [N in Extract<keyof ActionsOf<D, T>, string>]: ActionsOf<D, T>[N] extends {
+  scope: Scope;
+} ? N : never }[Extract<keyof ActionsOf<D, T>, string>], string>;
+/**
+ * The generated per-action body/result types (CONTEXT.md "Write surface" — a typed action
+ * surface). The codegen emits precise `<Type><Action>Input`/`Output` aliases (expanding the
+ * referenced JSON:API component) and threads them in keyed `type -> actionName -> { input?;
+ * output? }` as the client's fourth type argument. Default `{}` (no codegen, or `createClient`
+ * called directly): actions fall back to the loose `Record<string,unknown>` in / `unknown` out.
+ * Deliberately an EMPTY object (no index signature) — an index-signatured map would resolve
+ * every action's body type to `never`.
+ */
+type DefaultActionTypes = Record<never, never>;
+/** The `{ input?; output? }` body-type entry for action `N` of type `T` from the action map `Act` (empty `{}` when absent). */
+type ActionTypesFor<Act, T extends string, N extends string> = T extends keyof Act ? N extends keyof Act[T] ? Act[T][N] : Record<never, never> : Record<never, never>;
+/**
+ * The typed body of a `document` action — the generated input type when the map carries one,
+ * else a loose JSON:API document. Gated on the literal `'input'` key being present (not
+ * structural `infer`) so a missing entry falls back rather than collapsing to `never`.
+ */
+type ActionInputBody<E> = 'input' extends keyof E ? E['input'] : Record<string, unknown>;
+/** The materialised result of a `document` action — the generated output type when present, else `unknown`. */
+type ActionOutputBody<E> = 'output' extends keyof E ? E['output'] : unknown;
+/**
+ * The static value an action returns, by its declared `output`:
+ *
+ * - `document` — the MATERIALISED resource view of the action's `outputType` (matching the read
+ *   path — `result.title`, not `result.data.attributes.title`), a {@link Collection} when the
+ *   output is a collection (`outputCardinality: 'many'`). Falls back to the generated
+ *   {@link ActionOutputBody} only when the descriptor names no resolvable `outputType` (a bespoke
+ *   document, or a pre-`outputType` generated client);
+ * - `meta` — the response document's top-level `meta` object;
+ * - `none` — `void` (a `204`).
+ */
+type ActionResult<D extends ApiDescriptor, A, Act extends ActionDescriptor, E> = Act extends {
+  output: 'document';
+} ? Act extends {
+  outputType: infer OT extends TypeName<D>;
+} ? Act extends {
+  outputCardinality: 'many';
+} ? Promise<Collection<ReadResult<D, A, OT>>> : Promise<ReadResult<D, A, OT>> : Promise<ActionOutputBody<E>> : Act extends {
+  output: 'meta';
+} ? Promise<Record<string, unknown>> : Promise<void>;
+/**
+ * A single custom-action method, typed by its declared `input` mode:
+ *
+ * - `none`  — no argument;
+ * - `document` — FLAT input (the `inputType`'s {@link CreateInput}, so the client builds the
+ *   envelope + remaps `422` pointers like `create`); falls back to the generated
+ *   {@link ActionInputBody} for a bespoke command document with no resolvable `inputType`;
+ * - `raw`   — an arbitrary body (sent with a relaxed content type).
+ *
+ * The result is shaped by the action's `output` (see {@link ActionResult}).
+ */
+type ActionMethod<D extends ApiDescriptor, A, W, Act extends ActionDescriptor, E> = Act extends {
+  input: 'none';
+} ? () => ActionResult<D, A, Act, E> : Act extends {
+  input: 'document';
+} ? Act extends {
+  inputType: infer IT extends TypeName<D>;
+} ? (input: CreateInput<D, W, IT>) => ActionResult<D, A, Act, E> : (input: ActionInputBody<E>) => ActionResult<D, A, Act, E> : (input: unknown) => ActionResult<D, A, Act, E>;
+/**
+ * The typed map of a type's custom actions at one scope (`collection` on the
+ * {@link TypeAccessor}, `resource` on the {@link ResourceHandle}). Each entry is an
+ * {@link ActionMethod} keyed by the action name, typed from the descriptor (`input`/`output` modes,
+ * `inputType`/`outputType`/`outputCardinality`) with `A`/`W` for the materialised result + flat
+ * input; only actions declared at `Scope` are present. Empty (`{}`) when the type declares no
+ * actions at that scope. `Act` supplies the generated per-action body-type fallbacks.
+ */
+type ActionsAccessor<D extends ApiDescriptor, A, W, T extends TypeName<D>, Scope extends string, Act = DefaultActionTypes> = { [N in ActionNameAtScope<D, T, Scope>]: ActionsOf<D, T>[N] extends ActionDescriptor ? ActionMethod<D, A, W, ActionsOf<D, T>[N], ActionTypesFor<Act, T, N>> : never };
+/**
+ * A resource handle (no fetch) for a known id. Carries the read surface (`get`), the writes
+ * scoped to a known id (`update`/`delete`), a relationship accessor per declared relation (by
+ * name), a universal `.rel(name)` fallback (for relations whose name collides with a reserved
+ * member like `get`/`update`/`rel`), and `.actions` (the type's resource-scoped custom
+ * actions). `W` is the generated write-attribute map.
+ */
+type ResourceHandle<D extends ApiDescriptor, A, W, T extends TypeName<D>, Act = DefaultActionTypes> = {
+  readonly type: T;
+  readonly id: string;
+  get<const Inc extends readonly IncludePath<D, T>[] = [], const F extends FieldsMap<D> = {}>(query?: SingleReadQuery<D, T, Inc, F>): Promise<ReadResult<D, A, T, Inc, F>>;
+  update<const Inc extends readonly IncludePath<D, T>[] = [], const F extends FieldsMap<D> = {}>(patch: UpdateInput<D, W, T>, opts?: WriteOptions<D, T, Inc, F>): Promise<ReadResult<D, A, T, Inc, F>>;
+  delete(): Promise<void>;
+  rel<R extends RelationName<D, T>>(name: R): RelationshipAccessor<D, A, T, R>; /** The type's resource-scoped custom actions, keyed by name (sub `{id}` from this handle). */
+  readonly actions: ActionsAccessor<D, A, W, T, 'resource', Act>;
+} & RelationshipAccessors<D, A, T>;
+/** The collection-scoped accessor for one wire type (`client.albums`). */
+interface TypeAccessor<D extends ApiDescriptor, A, W, T extends TypeName<D>, Act = DefaultActionTypes> {
+  list<const Inc extends readonly IncludePath<D, T>[] = [], const F extends FieldsMap<D> = {}>(query?: TypedReadQuery<D, T, Inc, F>): Promise<Collection<ReadResult<D, A, T, Inc, F>>>;
+  get<const Inc extends readonly IncludePath<D, T>[] = [], const F extends FieldsMap<D> = {}>(id: string, query?: SingleReadQuery<D, T, Inc, F>): Promise<ReadResult<D, A, T, Inc, F>>;
+  create<const Inc extends readonly IncludePath<D, T>[] = [], const F extends FieldsMap<D> = {}>(input: CreateInput<D, W, T>, opts?: WriteOptions<D, T, Inc, F>): Promise<ReadResult<D, A, T, Inc, F>>;
+  id(id: string): ResourceHandle<D, A, W, T, Act>;
+  /** The type's collection-scoped custom actions, keyed by name. */
+  readonly actions: ActionsAccessor<D, A, W, T, 'collection', Act>;
+}
+/**
+ * The descriptor-driven client surface: one {@link TypeAccessor} per wire type. `W` is the
+ * generated `WriteAttributes` map (per-type `{ create; update }` attribute pairs) and `Act`
+ * the generated per-action body-type map; both thread through to the write/action surfaces and
+ * default so read-only / codegen-less callers compile.
+ */
+type Client<D extends ApiDescriptor, A = DefaultAttributes<D>, W = DefaultWriteAttributes<D>, Act = DefaultActionTypes> = { [T in TypeName<D>]: TypeAccessor<D, A, W, T, Act> } & {
+  /**
+   * Run an Atomic Operations batch (CONTEXT.md "Atomic — typed transaction builder"): the
+   * callback records `create`/`update`/`delete` ops on a non-type-scoped recorder (each carries
+   * its `type`), posted all-or-nothing to the server's atomic endpoint. Present only when the
+   * client was built with the server's `atomic` capability; calling it on an API without one
+   * throws.
+   *
+   * The return shape is driven by what the callback returns (a single signature, branched in the
+   * return type — NOT an overload set, which would defeat the per-op `const` tuple inference):
+   *
+   * - return a tuple of handles -> a PER-OP POSITIONALLY-TYPED tuple of results: a create/update
+   *   handle resolves to the `AtomicResult` of that type (data typed as the materialised
+   *   resource), a delete handle to `undefined`. The mapping is by `opIndex`, so it stays sound
+   *   regardless of the order/subset of handles returned;
+   * - return void/nothing -> the loose, ordered `AtomicResult[]` (backward-compatible).
+   */
+  atomic<const Ops>(build: (tx: AtomicRecorder<D, W>) => Ops): Promise<Ops extends readonly AtomicHandle[] ? AtomicResults<D, A, Ops> : AtomicResult[]>;
+};
+/**
+ * The fallback attribute map when a caller doesn't supply the generated `Attributes`
+ * (direct `createClient` users without codegen): every type's attributes are an open
+ * `Record<string, unknown>` so reads still type-check, just without precise fields.
+ */
+type DefaultAttributes<D extends ApiDescriptor> = { [T in TypeName<D>]: Record<string, unknown> };
+/**
+ * The fallback write-attribute map when a caller doesn't supply the generated
+ * `WriteAttributes`: every type accepts an open `{ create; update }` pair so writes still
+ * type-check without precise per-type field constraints.
+ */
+type DefaultWriteAttributes<D extends ApiDescriptor> = { [T in TypeName<D>]: {
+  create: Record<string, unknown>;
+  update: Record<string, unknown>;
+} };
+//#endregion
+//#region src/transport.d.ts
+/** A single outbound request, already serialised to strings. */
+interface TransportRequest {
+  method: string;
+  url: string;
+  headers: Record<string, string>;
+  body?: string;
+}
+/** A single inbound response, body still a string for the runtime to parse. */
+interface TransportResponse {
+  status: number;
+  headers: Record<string, string>;
+  body: string;
+}
+/**
+ * The transport seam: a tiny, `fetch`-shaped function (not a class), so any impl
+ * (native `fetch`, undici, an axios adapter) drops in. Retries are deliberately out
+ * of scope here — the transport (or the TanStack layer) owns them.
+ */
+type JsonApiTransport = (req: TransportRequest) => Promise<TransportResponse>;
+/** The default transport, backed by the global `fetch`. */
+declare const fetchTransport: JsonApiTransport;
+//#endregion
+//#region src/client.d.ts
+/**
+ * The `fetch` headers init type. `@types/node` declares the global `RequestInit` (used
+ * by the transport) but not `HeadersInit`; we derive it from `RequestInit.headers` to
+ * stay dep-free and consistent with the rest of the runtime's web-globals usage.
+ */
+type HeadersInit = NonNullable<RequestInit['headers']>;
+/** Options for {@link createClient}. */
+interface ClientOptions {
+  /** Base URL the generated path templates are resolved against. */
+  baseUrl: string;
+  /** Transport seam; defaults to the `fetch` adapter when omitted. */
+  transport?: JsonApiTransport;
+  /** Per-request header provider (e.g. bearer auth); may be async. */
+  headers?: () => HeadersInit | Promise<HeadersInit>;
+  /**
+   * The server-level Atomic Operations capability (the codegen's `atomic` constant): `{ path }`
+   * when the server exposes the atomic endpoint, else `null`/omitted. When present, the client
+   * exposes `client.atomic(tx => …)`; otherwise calling it throws.
+   */
+  atomic?: AtomicDescriptor | null;
+  /**
+   * The opt-in per-field validation seam (ADR 0004). Off by default — the client always runs
+   * light structural guards (is this a JSON:API document? does each `data`/`included` member
+   * carry `type`+`id`?) but otherwise trusts the wire. Supply either the schema-driven config
+   * `{ schemas, validator }` — the codegen-emitted per-type `schemas` map plus a validation
+   * engine adapter (each wire resource is validated against `schemas[type]`; a type with no
+   * schema is skipped) — or a bare validator function that owns schema lookup itself. The
+   * validation engine (e.g. ajv) is brought by the caller; the client never depends on one.
+   */
+  validate?: ValidationOption;
+}
+/**
+ * The reserved members on a {@link ResourceHandle} — names the Proxy resolves itself, so a
+ * relation of the same name is shadowed and must route through `.rel(name)`. The codegen
+ * imports this to warn at build time (keeping the runtime + the collision detector in sync).
+ * `then` is reserved so a handle is never mistaken for a thenable.
+ */
+declare const HANDLE_RESERVED: ReadonlySet<string>;
+/**
+ * Build a descriptor-driven read client. Generic at runtime (a Proxy over the descriptor),
+ * not per-type codegen: `client.<type>` yields a {@link TypeAccessor}, `.id(id)` a handle,
+ * and a handle's relation accessors drive the relationship/related endpoints. Navigation
+ * (`$next()`/`$prev()`, related links) is wired through `materialise`'s `navigate` seam,
+ * which executes the (absolute) link and re-materialises.
+ */
+declare function createClient<D extends ApiDescriptor, A = DefaultAttributes<D>, W = DefaultWriteAttributes<D>, Act = DefaultActionTypes>(descriptor: D, options: ClientOptions): Client<D, A, W, Act>;
+//#endregion
+//#region src/request.d.ts
+/**
+ * A read query, in the flat shape the fluent surface accepts. Serialised to the
+ * JSON:API bracketed query-parameter families by {@link serializeQuery}.
+ */
+interface ReadQuery {
+  filter?: Record<string, unknown>;
+  sort?: string | string[];
+  include?: string[];
+  fields?: Record<string, string[]>;
+  /** Relationship-count tokens (the Countable profile) — serialised comma-joined onto `withCount`. */
+  withCount?: readonly string[];
+  page?: Record<string, unknown>;
+}
+/** A loose JSON:API document — enough structure for the runtime to materialise. */
+interface Document {
+  data?: unknown;
+  included?: unknown[];
+  links?: Record<string, unknown>;
+  meta?: Record<string, unknown>;
+  jsonapi?: Record<string, unknown>;
+}
+/** The ambient context a request executes in (carried by the client). */
+interface JsonApiContext {
+  baseUrl: string;
+  transport: JsonApiTransport;
+  headers?: () => HeadersInit | Promise<HeadersInit>;
+}
+/** A single read/write request, before serialisation. */
+interface JsonApiRequest {
+  method: string;
+  /** A path relative to `baseUrl`, or an absolute `http(s)://` URL (e.g. a page link). */
+  path: string;
+  query?: ReadQuery;
+  body?: unknown;
+  /**
+   * Override the request `Content-Type` (defaults to the negotiated JSON:API media type when a
+   * body is present). Set for a custom action's `raw` input, where the payload is not a JSON:API
+   * document. When set it wins over {@link ext}/{@link profiles} for `Content-Type`.
+   */
+  contentType?: string;
+  /**
+   * Override the request `Accept` header (defaults to the negotiated JSON:API media type). Set
+   * for a `raw`-input action that still expects a document response; when set it wins over
+   * {@link ext}/{@link profiles} for `Accept`.
+   */
+  accept?: string;
+  /**
+   * Extension URIs to negotiate (the media-type `ext` parameter), e.g. the atomic ext. Composed
+   * into both `Accept` and (when a body is present) `Content-Type` via the JSON:API media type,
+   * unless {@link accept}/{@link contentType} override the respective header.
+   */
+  ext?: readonly string[];
+  /**
+   * Profile URIs to negotiate (the media-type `profile` parameter), e.g. the Countable profile a
+   * `withCount` read requires. Composed into both `Accept` and (when a body is present)
+   * `Content-Type`, unless {@link accept}/{@link contentType} override the respective header.
+   */
+  profiles?: readonly string[];
+  /**
+   * Send the body verbatim (a `string`) instead of JSON-stringifying it. Used for a `raw`
+   * action body that's already serialised; a non-string body still falls back to
+   * `JSON.stringify`.
+   */
+  raw?: boolean;
+}
+/**
+ * Serialise a read query to a query string (no leading `?`). Bracketed keys
+ * (`filter[title]`, `page[number]`, `fields[albums]`) are kept literal; only values
+ * are percent-encoded. Empty/undefined entries are skipped; key order is deterministic
+ * (family order, then insertion order within a family) so URLs are stable for caching.
+ */
+declare function serializeQuery(query: ReadQuery): string;
+/**
+ * Execute a request: build the URL (verbatim when already absolute — for page links —
+ * else `baseUrl + path`), apply content negotiation and any async per-request headers,
+ * then drive the transport. A 2xx with a body parses to a {@link Document}; an empty /
+ * 204 body resolves to `undefined`. A non-2xx throws a {@link JsonApiError} carrying the
+ * parsed error objects (tolerating a non-JSON error body with an empty list).
+ */
+declare function execute(ctx: JsonApiContext, req: JsonApiRequest): Promise<Document | undefined>;
+//#endregion
+//#region src/validate.d.ts
+/**
+ * A wire resource as it appears in a document's `data`/`included` — a JSON:API resource
+ * object (or bare identifier). The structural guards assert `type` (and, where required,
+ * `id`); the opt-in validator sees the whole object to check the rest against its schema.
+ */
+interface WireResource {
+  type: string;
+  id?: string;
+  [key: string]: unknown;
+}
+/**
+ * The opt-in per-resource validator: validate one wire `resource` against its JSON `schema`
+ * (the bundle's per-type resource-object schema). The engine is the user's — throw (or
+ * aggregate-then-throw) on an invalid resource; return for a valid one. With the bare-function
+ * seam form there is no per-type schema, so `schema` is `undefined` and the function owns the
+ * whole decision.
+ */
+type Validator = (resource: WireResource, schema: unknown) => void;
+/** A per-type JSON Schema map (the codegen-emitted `schemas` constant), keyed by JSON:API type. */
+type SchemaMap = Readonly<Record<string, unknown>>;
+/**
+ * The schema-driven validation seam: a per-type `schemas` map plus a `validator` engine. Each
+ * wire resource is validated against `schemas[resource.type]`; a type with no schema is skipped.
+ */
+interface ValidationConfig {
+  schemas: SchemaMap;
+  validator: Validator;
+}
+/**
+ * The `validate?` option on {@link ClientOptions}: either the schema-driven {@link ValidationConfig}
+ * (the common case — the codegen-emitted `schemas` map + an engine adapter) or a bare
+ * {@link Validator} that owns schema lookup itself (it is called per resource with `schema` =
+ * `undefined`). Absent => no per-field validation (zero overhead, no engine dependency).
+ */
+type ValidationOption = ValidationConfig | Validator;
+/** A normalised validator: resolve a resource's schema (or `undefined`) and validate it. */
+interface ResolvedValidator {
+  validate(resource: WireResource): void;
+}
+/**
+ * Normalise the `validate?` option to a single per-resource validator. The config form looks the
+ * schema up by `resource.type` and skips a type with no schema (the seam stays graceful for a
+ * partially-covered bundle); the bare-function form calls the validator with `schema = undefined`,
+ * delegating the whole decision to the caller. Returns `undefined` when validation is off.
+ */
+declare function resolveValidator(option: ValidationOption | undefined): ResolvedValidator | undefined;
+/**
+ * The light structural guards every parsed response passes through (ADR 0004): assert the body
+ * is a JSON:API document and that each `data`/`included` member carries a string `type` (and,
+ * for a full resource, an `id`). This is the always-on, engine-free floor — it never duplicates
+ * the opt-in per-field validation; it only proves the envelope invariant the runtime relies on.
+ *
+ * A primary-`data` resource and every `included` resource must carry `type`+`id`. A relationship
+ * endpoint's primary data is pure resource-identifier linkage, which also carries `type`+`id`, so
+ * the same guard holds; `linkage` is accepted for symmetry with the materialiser but the assertion
+ * is identical (an identifier is `type`+`id`). `data: null` (an empty to-one) and a missing
+ * `data` (a meta-only document) are valid and pass.
+ */
+declare function assertJsonApiDocument(body: unknown): asserts body is Document;
+/**
+ * Run the opt-in validator over every wire resource in a document's `data` + `included`, each
+ * against its per-type schema. Called only when a validator is configured (off by default). The
+ * structural guards have already proven each member carries `type`+`id`, so the cast is sound.
+ */
+declare function validateDocument(body: Document, validator: ResolvedValidator): void;
+//#endregion
+export { SortQuery as $, DefaultActionTypes as A, RelationView as At, IncludePath as B, AtomicDescriptor as Bt, fetchTransport as C, mediaType as Ct, Collection as D, EdgeEnvelope as Dt, Client as E, Edge as Et, FieldsMap as F, ActionDescriptor as Ft, ReadResult as G, RelationDescriptor as Gt, LinkageRef as H, ClientIdPolicy as Ht, FilterKey as I, ActionInput as It, RelationshipAccessor as J, RelationName as K, RelationMutations as Kt, FilterQuery as L, ActionOutput as Lt, DefaultWriteAttributes as M, ResourceLinks as Mt, EdgeMembers as N, materialise as Nt, CountToken as O, MaterialiseContext as Ot, FieldSelectionMap as P, relatedPaginatorKind as Pt, SingleReadQuery as Q, HydratedMember as R, ActionScope as Rt, TransportResponse as S, ResourceIdentifier as St, AtomicResultOf as T, DocumentEnvelope as Tt, MemberName as U, CountableDescriptor as Ut, IncludedRelations as V, Cardinality as Vt, PivotInput as W, PaginatorKind as Wt, ResourceHandle as X, ResourceAccessors as Y, ResourceObjectView as Z, HANDLE_RESERVED as _, ATOMIC_EXT as _t, Validator as a, WriteOptions as at, JsonApiTransport as b, LocalIdentifier as bt, resolveValidator as c, AtomicDeleteHandle as ct, JsonApiContext as d, AtomicRef as dt, SortToken as et, JsonApiRequest as f, AtomicResult as ft, ClientOptions as g, runAtomic as gt, serializeQuery as h, AtomicUpdateInput as ht, ValidationOption as i, UpdateInput as it, DefaultAttributes as j, ResourceEnvelope as jt, CreateInput as k, Page as kt, validateDocument as l, AtomicHandle as lt, execute as m, AtomicUpdateHandle as mt, SchemaMap as n, TypeName as nt, WireResource as o, AtomicCreateHandle as ot, ReadQuery as p, AtomicResults as pt, RelationReadQuery as q, ResourceDescriptor as qt, ValidationConfig as r, TypedReadQuery as rt, assertJsonApiDocument as s, AtomicCreateInput as st, ResolvedValidator as t, TypeAccessor as tt, Document as u, AtomicRecorder as ut, HeadersInit as v, ATOMIC_MEDIA_TYPE as vt, ActionsAccessor as w, ArrayEnvelope as wt, TransportRequest as x, MediaTypeParams as xt, createClient as y, JSON_API_MEDIA_TYPE as yt, IdentifierMember as z, ApiDescriptor as zt };
+//# sourceMappingURL=validate-BmyPbJCK.d.cts.map