@haddowg/json-api-client 1.1.0 → 1.3.0

package/dist/{validate-CfrCMZkA.d.cts → validate-CJPivkqT.d.cts}

@@ -24,6 +24,21 @@ interface RelationMutations {
   replace?: boolean;
   set?: boolean;
 }
+/**
+ * The pivot fields one side of the wire carries on a member's `meta.pivot`: field name to
+ * wire-format hint (the vocabulary of {@link ResourceDescriptor.attributes}), the fields that
+ * are always present, and the fields that may be `null`.
+ */
+interface PivotDescriptor {
+  fields: Readonly<Record<string, string>>;
+  /**
+   * On a response, the fields every member renders; on a request, the fields every member must
+   * send. Absent means every field.
+   */
+  required?: readonly string[];
+  /** The fields whose value may be `null`. Absent means none. */
+  nullable?: readonly string[];
+}
 interface RelationDescriptor {
   cardinality: Cardinality;
   /** Related JSON:API type(s); more than one = polymorphic. */
@@ -31,12 +46,30 @@ interface RelationDescriptor {
   /** 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.
+   * The pivot fields carried on each member's `meta.pivot`, as a field-name → wire-format-hint
+   * map, typed as always present and never `null` on both reads and writes (D33).
+   *
+   * @deprecated Describe each side with {@link readPivot} and {@link writePivot}. Read only when
+   * those are absent.
    */
   pivotFields?: Readonly<Record<string, string>>;
+  /** The `meta.pivot` a response renders on each member (`<Type><Rel>Pivot`). */
+  readPivot?: PivotDescriptor;
+  /**
+   * The `meta.pivot` a request may send on each member (`<Type><Rel>WritePivot`): a create,
+   * update or atomic body, or a relationship mutation.
+   */
+  writePivot?: PivotDescriptor;
+  /**
+   * `true` for a relation create and update accept but no response renders. It stays settable
+   * on write inputs and is left out of the read view, `fields` and the relationship reads.
+   */
+  writeOnly?: boolean;
+  /**
+   * The relation's segment in its related and relationship paths, when it differs from the
+   * relation's name (`/articles/{id}/published-by` for `publisher`). Absent means the name.
+   */
+  uriField?: 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 /
@@ -64,7 +97,7 @@ interface RelationDescriptor {
    */
   countable?: CountableDescriptor;
   /**
-   * The paginator kind this relation's OWN related/relationship endpoints advertise
+   * The paginator 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
@@ -72,9 +105,37 @@ interface RelationDescriptor {
    * 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;
+  paginator?: PaginatorDescriptor;
+}
+/** A built-in pagination strategy. */
+type PaginatorStrategy = 'page' | 'offset' | 'cursor' | 'fixed';
+/** The strategy that answers a read, or `none` for an unpaginated endpoint. */
+type PaginatorKind = PaginatorStrategy | 'none';
+/**
+ * A role a page parameter fills. `page`: number, size; `offset`: offset, limit; `cursor`: after,
+ * before, size; `fixed`: number.
+ */
+type PaginatorRole = 'number' | 'size' | 'offset' | 'limit' | 'after' | 'before';
+/** A strategy whose roles are filled by renamed wire keys, e.g. `{ number: 'p', size: 'size' }`. */
+interface StrategyDescriptor {
+  strategy: PaginatorStrategy;
+  keys: Readonly<Partial<Record<PaginatorRole, string>>>;
+}
+/**
+ * A MultiPaginator menu: the client picks an arm by its `kind` (sent as `page[kind]`), and the
+ * server answers with `default` when the request names none. Arm keys are the `kind` values.
+ */
+interface MenuDescriptor {
+  strategy: 'multi';
+  default: string;
+  arms: Readonly<Record<string, PaginatorStrategy | StrategyDescriptor>>;
 }
-type PaginatorKind = 'page' | 'offset' | 'cursor' | 'none';
+/**
+ * How an endpoint paginates. A bare kind uses the canonical wire keys (`page[number]`,
+ * `page[size]`, ...); a {@link StrategyDescriptor} names renamed keys; a {@link MenuDescriptor}
+ * offers several strategies.
+ */
+type PaginatorDescriptor = PaginatorKind | StrategyDescriptor | MenuDescriptor;
 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';
@@ -145,7 +206,7 @@ interface ResourceDescriptor {
   relations: Readonly<Record<string, RelationDescriptor>>;
   /** Per-operation path templates, e.g. `{ fetchOne: '/albums/{id}' }`. */
   paths: Readonly<Record<string, string>>;
-  paginator: PaginatorKind;
+  paginator: PaginatorDescriptor;
   clientId: ClientIdPolicy;
   /**
    * The `withCount` count tokens + negotiation profile for this type's read endpoints.
@@ -187,6 +248,168 @@ interface AtomicDescriptor {
   path: string;
 }
 //#endregion
+//#region src/pagination.d.ts
+/** The wire key for each role when the server keeps the default names. */
+declare const CANONICAL_PAGE_KEYS: {
+  readonly page: {
+    readonly number: "number";
+    readonly size: "size";
+  };
+  readonly offset: {
+    readonly offset: "offset";
+    readonly limit: "limit";
+  };
+  readonly cursor: {
+    readonly after: "after";
+    readonly before: "before";
+    readonly size: "size";
+  };
+  readonly fixed: {
+    readonly number: "number";
+  };
+  readonly none: {};
+};
+/** Role -> wire key for the strategy that answered. */
+type PageKeys = Readonly<Partial<Record<PaginatorRole, string>>>;
+/** The strategy that answers one read, with its wire keys and, for a menu pick, the arm's `kind`. */
+interface ResolvedPaginator {
+  kind: PaginatorKind;
+  keys: PageKeys;
+  /** The menu arm the request picked with `page[kind]`. Absent when it picked none (the default). */
+  arm?: string;
+}
+/**
+ * Resolve the strategy that answers a read from the endpoint's paginator and the `page` the
+ * request sends. A menu answers with the arm named by `page.kind`, else its `default`.
+ */
+declare function resolvePaginator(paginator: PaginatorDescriptor | undefined, page?: Readonly<Record<string, unknown>>): ResolvedPaginator;
+/** Navigation links by relation (`first`/`prev`/`next`/`last`), when present. */
+interface PageLinks {
+  first?: string;
+  prev?: string;
+  next?: string;
+  last?: string;
+}
+/** Normalised pagination state on a collection, as the runtime builds it; count-free-safe. */
+interface Page {
+  kind: PaginatorKind;
+  /** Role -> wire key for the strategy that answered. */
+  keys: PageKeys;
+  /** The menu arm the request picked with `page[kind]`, when it picked one. */
+  arm?: string;
+  /** The raw `meta.page` block, when present (shape varies by kind). */
+  meta?: Record<string, unknown>;
+  links: PageLinks;
+}
+/**
+ * The `meta.page` block each built-in strategy renders. `total`/`lastPage` (and `to` on an empty
+ * page) are absent when the server does not count.
+ */
+type PageMeta<K extends PaginatorKind> = K extends 'page' ? {
+  currentPage: number;
+  perPage: number;
+  from: number;
+  to?: number;
+  total?: number;
+  lastPage?: number;
+} : K extends 'fixed' ? {
+  currentPage: number;
+  total?: number;
+  lastPage?: number;
+} : K extends 'offset' ? {
+  offset: number;
+  limit: number;
+  from: number;
+  to?: number;
+  total?: number;
+} : K extends 'cursor' ? {
+  perPage: number;
+  from?: string;
+  to?: string;
+  hasMore: boolean;
+} : Record<string, unknown>;
+/** `$page` typed by the strategy `K` that answers, its wire keys and the picked menu arm. */
+type TypedPage<K extends PaginatorKind, Keys extends PageKeys, Arm extends string | undefined = undefined> = {
+  kind: K;
+  keys: Keys;
+  meta?: PageMeta<K>;
+  links: PageLinks;
+} & (Arm extends string ? {
+  arm: Arm;
+} : {
+  arm?: never;
+});
+/** A non-menu paginator entry as `{ strategy, keys }` (a bare kind takes the canonical keys). */
+type StrategyOf<P> = P extends PaginatorKind ? {
+  strategy: P;
+  keys: (typeof CANONICAL_PAGE_KEYS)[P];
+} : P extends StrategyDescriptor ? P : never;
+/** Cursors are opaque strings; every other role is a count. */
+type RoleValue<R> = R extends 'after' | 'before' ? string : number;
+/** The page members one strategy accepts, keyed by their wire names. */
+type StrategyParams<S> = S extends {
+  keys: infer K;
+} ? { -readonly [R in keyof K as K[R] extends string ? K[R] : never]?: RoleValue<R> } : never;
+/** True when `P` is the loose `PaginatorDescriptor` union rather than a generated literal. */
+type IsLoose<P> = [PaginatorKind] extends [P] ? true : false;
+type ArmName<M extends MenuDescriptor> = Extract<keyof M['arms'], string>;
+type ArmParams<M extends MenuDescriptor, A> = A extends ArmName<M> ? {
+  kind: A;
+} & StrategyParams<StrategyOf<M['arms'][A]>> : never;
+type KeysOfUnion<U> = U extends unknown ? keyof U : never;
+/**
+ * The default arm's members without `kind`. Members only another arm reads are `never`: the
+ * server would select that arm by them, while the response is typed as the default.
+ */
+type DefaultArmParams<M extends MenuDescriptor> = StrategyParams<StrategyOf<M['arms'][M['default']]>> & {
+  kind?: undefined;
+} & { [X in Exclude<KeysOfUnion<StrategyParams<StrategyOf<M['arms'][ArmName<M>]>>>, keyof StrategyParams<StrategyOf<M['arms'][M['default']]>>>]?: never };
+/**
+ * The `page` parameter an endpoint with paginator `P` accepts: its strategy's members under
+ * their wire keys (numbers, cursors as strings). A menu takes one arm tagged by `kind`, or the
+ * default arm's members untagged. `never` for an unpaginated endpoint; a loose record when the
+ * descriptor is not a generated literal.
+ */
+type PageParams<P> = IsLoose<P> extends true ? Readonly<Record<string, unknown>> : P extends 'none' ? never : P extends MenuDescriptor ? ArmParams<P, ArmName<P>> | DefaultArmParams<P> : StrategyParams<StrategyOf<P>>;
+/** The member of page parameter union `P` that argument `Q` selects by its `kind`, if any. */
+type SelectedArm<Q, P> = Q extends {
+  kind: infer K;
+} ? Extract<P, {
+  kind: K;
+}> : Extract<P, {
+  kind?: undefined;
+}>;
+/**
+ * A page argument `Q` with any member outside the arm it selects turned into `never`, so a typo,
+ * or another arm's member, is an error.
+ */
+type ExactPageParams<Q, P> = Q & { [K in Exclude<keyof Q, KeysOfUnion<[SelectedArm<Q, P>] extends [never] ? P : SelectedArm<Q, P>>>]: never };
+type StrategyPage<S, Arm extends string | undefined = undefined> = S extends {
+  strategy: infer K extends PaginatorStrategy;
+  keys: infer Keys extends PageKeys;
+} ? TypedPage<K, Keys, Arm> : Page;
+type MenuPage<M extends MenuDescriptor, Q> = [Q] extends [never] ? StrategyPage<StrategyOf<M['arms'][M['default']]>> : Q extends {
+  kind: infer A extends ArmName<M>;
+} ? StrategyPage<StrategyOf<M['arms'][A]>, A> : StrategyPage<StrategyOf<M['arms'][M['default']]>>;
+/**
+ * The `$page` a read on an endpoint with paginator `P` carries, given the `page` argument `Q`
+ * it sent: the picked menu arm's strategy, the default's when it picked none, else the
+ * endpoint's own strategy.
+ */
+type PageOf<P, Q = undefined> = IsLoose<P> extends true ? Page : P extends MenuDescriptor ? MenuPage<P, Q> : P extends 'none' ? TypedPage<'none', Record<never, never>> : StrategyPage<StrategyOf<P>>;
+/**
+ * The `page` argument that reads another page from the strategy that answered `P` (a `$page`):
+ * its members under their wire keys, tagged with the menu arm it picked. A loose record for an
+ * untyped `Page`.
+ */
+type PageParamsOf<P extends Page> = PaginatorKind extends P['kind'] ? Readonly<Record<string, string | number>> : StrategyParams<{
+  keys: P['keys'];
+}> & (P extends {
+  arm: infer A extends string;
+} ? {
+  kind: A;
+} : unknown);
+//#endregion
 //#region src/materialise.d.ts
 /** A trimmed, by-reference top-level envelope shared by every resource from one response. */
 interface DocumentEnvelope {
@@ -204,19 +427,6 @@ 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;
@@ -257,10 +467,11 @@ interface MaterialiseContext {
    * 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).
+   * carries the strategy that answered the current page, so the re-materialised page reports the
+   * same `$page` (a divergent per-relation paginator, a picked menu arm, or an EMPTY next page
+   * that carries no member to sniff).
    */
-  navigate: (url: string, linkage?: boolean, paginator?: PaginatorKind, signal?: AbortSignal) => Promise<unknown>;
+  navigate: (url: string, linkage?: boolean, paginator?: ResolvedPaginator, signal?: AbortSignal) => 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
@@ -301,14 +512,15 @@ interface RawRelationship {
  * 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
+ * `paginatorOverride` sets the top-level array's `$page` for a related/relationship read, where the
+ * paginator is the RELATION's (which may diverge from the related type's collection — D6a), for a
+ * menu read that picked an arm, and where an empty page carries no member to sniff a type from. A
+ * bare kind is read with its canonical wire keys. `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;
+declare function materialise(doc: Document, ctx: MaterialiseContext, linkage?: boolean, primaryType?: string, paginatorOverride?: ResolvedPaginator | PaginatorKind): unknown;
 /**
- * A to-many relation's paginator kind. The relation's OWN related/relationship endpoint may
+ * A to-many relation's paginator. 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
@@ -316,6 +528,8 @@ declare function materialise(doc: Document, ctx: MaterialiseContext, linkage?: b
  * resolves off its first declared related type (its members span types, matching the relationship
  * endpoint's first-member resolution).
  */
+declare function relatedPaginator(relation: RelationDescriptor | undefined, ctx: MaterialiseContext): PaginatorDescriptor | undefined;
+/** The kind a relation's related read answers with when it sends no `page`. See {@link relatedPaginator}. */
 declare function relatedPaginatorKind(relation: RelationDescriptor | undefined, ctx: MaterialiseContext): PaginatorKind;
 //#endregion
 //#region src/types.d.ts
@@ -489,11 +703,13 @@ declare function runAtomic<D extends ApiDescriptor, A, W, const Ops>(request: Js
  * 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").
+ * to-many relationship values ("one model, three surfaces"). `P` types `$page` by the strategy
+ * that answered (see {@link PageOf}); following a link keeps it.
  */
-type Collection<T> = ReadonlyArray<T> & Omit<ArrayEnvelope, '$next' | '$prev'> & {
-  $next(options?: NavigateOptions): Promise<Collection<T> | undefined>;
-  $prev(options?: NavigateOptions): Promise<Collection<T> | undefined>;
+type Collection<T, P = Page> = ReadonlyArray<T> & Omit<ArrayEnvelope, '$page' | '$next' | '$prev'> & {
+  readonly $page: P;
+  $next(options?: NavigateOptions): Promise<Collection<T, P> | undefined>;
+  $prev(options?: NavigateOptions): Promise<Collection<T, P> | undefined>;
 };
 /**
  * The edge-local accessors carried by a materialised related VALUE (a per-edge view):
@@ -518,6 +734,12 @@ interface ResourceAccessors {
 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 relations of type `T` a response never renders (the descriptor's `writeOnly: true`). */
+type WriteOnlyRelationName<D extends ApiDescriptor, T extends TypeName<D>> = { [R in RelationName<D, T>]: D[T]['relations'][R] extends {
+  writeOnly: true;
+} ? R : never }[RelationName<D, T>];
+/** The relations of type `T` a response can render: every relation but the write-only ones. */
+type ReadableRelationName<D extends ApiDescriptor, T extends TypeName<D>> = Exclude<RelationName<D, T>, WriteOnlyRelationName<D, T>>;
 /** 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>;
 /**
@@ -553,6 +775,15 @@ type PickSelected<Obj, Sel> = [Sel] extends [AllFields] ? Obj : Pick<Obj, Extrac
 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 paginator relation `R`'s related/relationship endpoints use: the relation's own when it
+ * diverges (D6a), else its first related type's collection paginator (as the runtime resolves).
+ */
+type RelationPaginator<D extends ApiDescriptor, T extends TypeName<D>, R extends RelationName<D, T>> = D[T]['relations'][R] extends {
+  paginator: infer P;
+} ? P : D[T]['relations'][R]['types'][0] extends infer First extends TypeName<D> ? D[First]['paginator'] : 'none';
+/** The `$page` of relation `R`'s to-many value read with page argument `Q` (none = the default). */
+type RelationPage<D extends ApiDescriptor, T extends TypeName<D>, R extends RelationName<D, T>, Q = undefined> = PageOf<RelationPaginator<D, T, R>, Q>;
 /**
  * The bare resource-identifier shape a non-included (but linked) relation takes,
  * carrying the per-edge `$edge`/`$pivot` accessors the runtime attaches to every
@@ -584,13 +815,13 @@ type Identifier<TType extends string, Pivot = Record<string, unknown>> = TType e
  * (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;
+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>, RelationPage<D, T, R>> : Hydrated<D, A, RelatedType<D, T, R>, F> | null : IsMany<D, T, R> extends true ? Collection<Identifier<RelatedType<D, T, R>>, RelationPage<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).
+ * unrequested relation is statically absent). A write-only relation has no slot.
  */
-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>>;
+type Relations<D extends ApiDescriptor, A, T extends TypeName<D>, Inc, F = unknown> = PickSelected<{ [R in ReadableRelationName<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
@@ -665,18 +896,20 @@ type FilterQuery<D extends ApiDescriptor, T extends TypeName<D>> = [FilterKey<D,
 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.
+ * `attributes` keys) or a relation a response renders. 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>;
+type MemberName<D extends ApiDescriptor, T extends TypeName<D>> = Extract<keyof D[T]['attributes'], string> | ReadableRelationName<D, T>;
+/** The `page` argument a collection read of type `T` accepts (see {@link PageParams}). */
+type ListPageParams<D extends ApiDescriptor, T extends TypeName<D>> = PageParams<D[T]['paginator']>;
 /**
  * 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
+ * return narrowing), a `withCount` constrained to the type's count tokens, a `page` typed by the
+ * collection's paginator (`Pg` drives the `$page` type), 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>> {
+interface TypedReadQuery<D extends ApiDescriptor, T extends TypeName<D>, Inc extends readonly IncludePath<D, T>[], F extends FieldsMap<D> = FieldsMap<D>, Pg extends ListPageParams<D, T> | undefined = ListPageParams<D, T> | undefined> {
   /** 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. */
@@ -687,7 +920,11 @@ interface TypedReadQuery<D extends ApiDescriptor, T extends TypeName<D>, Inc ext
   fields?: F;
   /** Relationship-count tokens (the Countable profile) — comma-joined onto `withCount`. */
   withCount?: readonly CountToken<D, T>[];
-  page?: Record<string, unknown>;
+  /**
+   * The page to read, under the paginator's wire keys. On a menu, `kind` picks a strategy;
+   * without it the server answers with its default.
+   */
+  page?: ExactPageParams<Pg, ListPageParams<D, T>>;
   /** Cancels the read when signalled (e.g. a superseded request). Not sent to the server. */
   signal?: AbortSignal;
 }
@@ -711,13 +948,16 @@ interface SingleReadQuery<D extends ApiDescriptor, T extends TypeName<D>, Inc ex
  * 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 {
+/**
+ * A read query for the relationship/related endpoints: loose filter/sort/include/fields/withCount,
+ * and a `page` of type `Pg` (typed from the relation's paginator on a typed accessor).
+ */
+interface RelationReadQuery<Pg = Readonly<Record<string, unknown>>> {
   filter?: Record<string, unknown>;
   sort?: string | readonly string[];
   include?: readonly string[];
   fields?: Record<string, readonly string[]>;
-  page?: Record<string, unknown>;
+  page?: Pg;
   /**
    * Relationship-count tokens (`_self_` + the relation's countable relations) — the related/
    * relationship endpoints advertise their own `withCount`, and the client negotiates the
@@ -729,27 +969,64 @@ interface RelationReadQuery {
 }
 /** 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).
+/** The string members of a descriptor list, or `never` when it is absent. */
+type ListMember<L> = L extends readonly (infer M)[] ? M & string : never;
+/** The fields of a {@link PivotDescriptor} every member carries (all of them when `required` is absent). */
+type RequiredPivotField<P> = P extends {
+  fields: infer Fl;
+} ? P extends {
+  required: infer Req;
+} ? Extract<keyof Fl, ListMember<Req>> : keyof Fl : never;
+/** One pivot field's TS type: its format hint's type, plus `null` when the field is nullable. */
+type PivotValue<P, K> = P extends {
+  fields: infer Fl;
+} ? K extends keyof Fl ? FormatToTs<Fl[K]> | (K extends ListMember<P extends {
+  nullable: infer N;
+} ? N : never> ? null : never) : never : never;
+/** The fields of a {@link PivotDescriptor}. */
+type PivotFieldNames<P> = P extends {
+  fields: infer Fl;
+} ? keyof Fl : never;
+/** The `meta.pivot` object a {@link PivotDescriptor} describes. */
+type PivotObject<P> = { readonly [K in PivotFieldNames<P> as K extends RequiredPivotField<P> ? K : never]: PivotValue<P, K> } & { readonly [K in PivotFieldNames<P> as K extends RequiredPivotField<P> ? never : K]?: PivotValue<P, K> };
+/** The legacy hint-only pivot shape: every field present and non-null. */
+type LegacyPivot<P> = { readonly [K in keyof P]: FormatToTs<P[K]> };
+/**
+ * The typed `meta.pivot` a response renders on each member of relation `R`, from the descriptor's
+ * `readPivot`, e.g. `{ position: number; weight: number | null; addedAt: string }`. A descriptor
+ * with only `pivotFields` types every field present and non-null; one with neither falls back to
+ * a loose record (D33).
  */
 type PivotFieldsOf<D extends ApiDescriptor, T extends TypeName<D>, R extends RelationName<D, T>> = D[T]['relations'][R] extends {
+  readPivot: infer P;
+} ? PivotObject<P> : D[T]['relations'][R] extends {
   pivotFields: infer P;
-} ? { readonly [K in keyof P]: FormatToTs<P[K]> } : Record<string, unknown>;
+} ? LegacyPivot<P> : Record<string, unknown>;
+/**
+ * The typed `meta.pivot` a request may send on each member of relation `R`, from the descriptor's
+ * `writePivot` (only writable fields, optional unless required). Falls back like
+ * {@link PivotFieldsOf} when the descriptor has no `writePivot`.
+ */
+type WritePivotOf<D extends ApiDescriptor, T extends TypeName<D>, R extends RelationName<D, T>> = D[T]['relations'][R] extends {
+  writePivot: infer P;
+} ? PivotObject<P> : D[T]['relations'][R] extends {
+  pivotFields: infer P;
+} ? LegacyPivot<P> : PivotInput;
 /**
  * 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).
+ * relation's `readPivot` (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;
+type RelatedValue<D extends ApiDescriptor, A, T extends TypeName<D>, R extends RelationName<D, T>, Q = undefined> = IsMany<D, T, R> extends true ? Collection<Hydrated<D, A, RelatedType<D, T, R>, unknown, PivotFieldsOf<D, T, R>>, RelationPage<D, T, R, Q>> : 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).
+ * Each member's `$pivot` is typed from the relation's `readPivot` (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;
+type LinkageValue<D extends ApiDescriptor, T extends TypeName<D>, R extends RelationName<D, T>, Q = undefined> = IsMany<D, T, R> extends true ? Collection<Identifier<RelatedType<D, T, R>, PivotFieldsOf<D, T, R>>, RelationPage<D, T, R, Q>> : Identifier<RelatedType<D, T, R>, PivotFieldsOf<D, T, R>> | null;
+/** The `page` argument relation `R`'s to-many reads accept; `never` for a to-one. */
+type RelationPageParams<D extends ApiDescriptor, T extends TypeName<D>, R extends RelationName<D, T>> = IsMany<D, T, R> extends true ? PageParams<RelationPaginator<D, T, R>> : never;
 /**
  * A relationship accessor off a {@link ResourceHandle} (`client.albums.id('1').tracks`):
  * reads — `.get()` (linkage) / `.related()` (related collection); writes — to-many
@@ -763,27 +1040,30 @@ type LinkageValue<D extends ApiDescriptor, T extends TypeName<D>, R extends Rela
  * 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;
+  get: ReadsRelationship<D, T, R> extends true ? <const Pg extends RelationPageParams<D, T, R> | undefined = undefined>(query?: RelationReadQuery<ExactPageParams<Pg, RelationPageParams<D, T, R>>>) => Promise<LinkageValue<D, T, R, Pg>> : never;
+  related: ExposesRelated<D, T, R> extends true ? <const Pg extends RelationPageParams<D, T, R> | undefined = undefined>(query?: RelationReadQuery<ExactPageParams<Pg, RelationPageParams<D, T, R>>>) => Promise<RelatedValue<D, A, T, R, Pg>> : 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).
+ * A linkage ref for a to-many membership WRITE on relation `R` (`add`/`replace`, or a create or
+ * update input), with `$pivot` typed from the relation's `writePivot` — 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>;
+  $pivot?: WritePivotOf<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).
+ * `withoutRelatedEndpoint()`) or the relation is write-only. 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;
+} | {
+  writeOnly: true;
 } ? false : true;
 /**
  * True unless relation `R`'s relationship endpoint is suppressed (`relationship: false`, the
@@ -792,6 +1072,10 @@ type ExposesRelated<D extends ApiDescriptor, T extends TypeName<D>, R extends Re
 type ExposesRelationship<D extends ApiDescriptor, T extends TypeName<D>, R extends RelationName<D, T>> = D[T]['relations'][R] extends {
   relationship: false;
 } ? false : true;
+/** Whether relation `R`'s linkage can be read back: exposed, and not write-only. */
+type ReadsRelationship<D extends ApiDescriptor, T extends TypeName<D>, R extends RelationName<D, T>> = D[T]['relations'][R] extends {
+  writeOnly: true;
+} ? false : ExposesRelationship<D, T, R>;
 /** 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). */
@@ -818,9 +1102,9 @@ type RelationMutation<D extends ApiDescriptor, T extends TypeName<D>, R extends
 /** 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`.
+ * Writable pivot data carried on a to-many member as `$pivot` (a belongsToMany relation with
+ * `pivot: true`), passed through as `meta.pivot`. The loose fallback for a relation whose
+ * descriptor has no `writePivot`.
  */
 type PivotInput = Record<string, unknown>;
 /**
@@ -841,10 +1125,14 @@ type LinkageRef<TType extends string> = (ResourceIdentifier<TType> & {
 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.
+ * to-one accepts a single ref or `null` (clear); to-many accepts an array of refs, each with an
+ * optional `$pivot` typed from the relation's `writePivot`.
+ */
+type RelationInput<D extends ApiDescriptor, T extends TypeName<D>, R extends RelationName<D, T>> = IsMany<D, T, R> extends true ? readonly WriteRef<D, T, R>[] : LinkageRefOf<RelatedType<D, T, R>> | null;
+/**
+ * The relationship slots of type `T` as optional write input keys (one per declared relation,
+ * write-only ones included).
  */
-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] : {
@@ -993,7 +1281,7 @@ type ResourceHandle<D extends ApiDescriptor, A, W, T extends TypeName<D>, 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>>>;
+  list<const Inc extends readonly IncludePath<D, T>[] = [], const F extends FieldsMap<D> = {}, const Pg extends ListPageParams<D, T> | undefined = undefined>(query?: TypedReadQuery<D, T, Inc, F, Pg>): Promise<Collection<ReadResult<D, A, T, Inc, F>, PageOf<D[T]['paginator'], Pg>>>;
   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>;
@@ -1004,9 +1292,10 @@ interface TypeAccessor<D extends ApiDescriptor, A, W, T extends TypeName<D>, 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.
+ * default so read-only / codegen-less callers compile. `E` is the server's documented
+ * error-code union, carried at the type level only (read it back with `ErrorCodeOf`).
  */
-type Client<D extends ApiDescriptor, A = DefaultAttributes<D>, W = DefaultWriteAttributes<D>, Act = DefaultActionTypes> = { [T in TypeName<D>]: TypeAccessor<D, A, W, T, Act> } & {
+type Client<D extends ApiDescriptor, A = DefaultAttributes<D>, W = DefaultWriteAttributes<D>, Act = DefaultActionTypes, E extends string = string> = { [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
@@ -1024,7 +1313,13 @@ type Client<D extends ApiDescriptor, A = DefaultAttributes<D>, W = DefaultWriteA
    * - 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[]>;
+  readonly [errorCodes]?: E;
 };
+declare const errorCodes: unique symbol;
+/** The error-code union a client type carries, or `string` for one that carries none. */
+type ErrorCodeOf<T> = T extends {
+  readonly [errorCodes]?: infer C extends string;
+} ? C : string;
 /**
  * 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
@@ -1113,9 +1408,9 @@ declare const HANDLE_RESERVED: ReadonlySet<string>;
  * 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.
+ * which resolves the server's link against `baseUrl`, executes it 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>;
+declare function createClient<D extends ApiDescriptor, A = DefaultAttributes<D>, W = DefaultWriteAttributes<D>, Act = DefaultActionTypes, E extends string = string>(descriptor: D, options: ClientOptions): Client<D, A, W, Act, E>;
 //#endregion
 //#region src/request.d.ts
 /**
@@ -1150,8 +1445,17 @@ interface JsonApiContext {
 /** 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). */
+  /**
+   * A path appended to `baseUrl` (a filled path template such as `/albums/1`), or an absolute
+   * `http(s)://` URL. With {@link link} set, a link from the server instead.
+   */
   path: string;
+  /**
+   * `path` is a link the server sent (a `links` member such as `next`, or a `Location` header).
+   * It resolves against `baseUrl` per RFC 3986, so a root-relative `/api/v5/albums?page[number]=2`
+   * keeps the base's origin but not its path, where a path template is appended to the base.
+   */
+  link?: boolean;
   query?: ReadQuery;
   body?: unknown;
   /**
@@ -1195,8 +1499,8 @@ interface JsonApiRequest {
  */
 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,
+ * Execute a request: build the URL (a server link resolved against `baseUrl`, an absolute path
+ * verbatim, 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).
@@ -1270,5 +1574,5 @@ declare function assertJsonApiDocument(body: unknown): asserts body is Document;
  */
 declare function validateDocument(body: Document, validator: ResolvedValidator): void;
 //#endregion
-export { SortQuery as $, DefaultActionTypes as A, Page as At, IncludePath as B, ApiDescriptor as Bt, fetchTransport as C, mediaType as Ct, Collection as D, EdgeEnvelope as Dt, Client as E, Edge as Et, FieldsMap as F, relatedPaginatorKind as Ft, ReadResult as G, PaginatorKind as Gt, LinkageRef as H, Cardinality as Ht, FilterKey as I, ActionDescriptor as It, RelationshipAccessor as J, ResourceDescriptor as Jt, RelationName as K, RelationDescriptor as Kt, FilterQuery as L, ActionInput as Lt, DefaultWriteAttributes as M, ResourceEnvelope as Mt, EdgeMembers as N, ResourceLinks as Nt, CountToken as O, MaterialiseContext as Ot, FieldSelectionMap as P, materialise as Pt, SingleReadQuery as Q, HydratedMember as R, ActionOutput as Rt, TransportResponse as S, ResourceIdentifier as St, AtomicResultOf as T, DocumentEnvelope as Tt, MemberName as U, ClientIdPolicy as Ut, IncludedRelations as V, AtomicDescriptor as Vt, PivotInput as W, CountableDescriptor 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, RelationView as jt, CreateInput as k, NavigateOptions 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, RelationMutations 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, ActionScope as zt };
-//# sourceMappingURL=validate-CfrCMZkA.d.cts.map
+export { RelationshipAccessor as $, ActionDescriptor as $t, DefaultActionTypes as A, DocumentEnvelope as At, IdentifierMember as B, relatedPaginatorKind as Bt, fetchTransport as C, ATOMIC_MEDIA_TYPE as Ct, Collection as D, ResourceIdentifier as Dt, Client as E, MediaTypeParams as Et, FieldSelectionMap as F, RelationView as Ft, MemberName as G, PageLinks as Gt, IncludedRelations as H, ExactPageParams as Ht, FieldsMap as I, ResourceEnvelope as It, ReadableRelationName as J, PageParams as Jt, PivotInput as K, PageMeta as Kt, FilterKey as L, ResourceLinks as Lt, DefaultWriteAttributes as M, EdgeEnvelope as Mt, EdgeMembers as N, MaterialiseContext as Nt, CountToken as O, mediaType as Ot, ErrorCodeOf as P, NavigateOptions as Pt, RelationReadQuery as Q, resolvePaginator as Qt, FilterQuery as R, materialise as Rt, TransportResponse as S, ATOMIC_EXT as St, AtomicResultOf as T, LocalIdentifier as Tt, LinkageRef as U, Page as Ut, IncludePath as V, CANONICAL_PAGE_KEYS as Vt, ListPageParams as W, PageKeys as Wt, RelationPageParams as X, ResolvedPaginator as Xt, RelationName as Y, PageParamsOf as Yt, RelationPaginator as Z, TypedPage as Zt, HANDLE_RESERVED as _, StrategyDescriptor as _n, AtomicResult as _t, Validator as a, Cardinality as an, SortToken as at, JsonApiTransport as b, AtomicUpdateInput as bt, resolveValidator as c, MenuDescriptor as cn, TypedReadQuery as ct, JsonApiContext as d, PaginatorRole as dn, AtomicCreateHandle as dt, ActionInput as en, ResourceAccessors as et, JsonApiRequest as f, PaginatorStrategy as fn, AtomicCreateInput as ft, ClientOptions as g, ResourceDescriptor as gn, AtomicRef as gt, serializeQuery as h, RelationMutations as hn, AtomicRecorder as ht, ValidationOption as i, AtomicDescriptor as in, SortQuery as it, DefaultAttributes as j, Edge as jt, CreateInput as k, ArrayEnvelope as kt, validateDocument as l, PaginatorDescriptor as ln, UpdateInput as lt, execute as m, RelationDescriptor as mn, AtomicHandle as mt, SchemaMap as n, ActionScope as nn, ResourceObjectView as nt, WireResource as o, ClientIdPolicy as on, TypeAccessor as ot, ReadQuery as p, PivotDescriptor as pn, AtomicDeleteHandle as pt, ReadResult as q, PageOf as qt, ValidationConfig as r, ApiDescriptor as rn, SingleReadQuery as rt, assertJsonApiDocument as s, CountableDescriptor as sn, TypeName as st, ResolvedValidator as t, ActionOutput as tn, ResourceHandle as tt, Document as u, PaginatorKind as un, WriteOptions as ut, HeadersInit as v, AtomicResults as vt, ActionsAccessor as w, JSON_API_MEDIA_TYPE as wt, TransportRequest as x, runAtomic as xt, createClient as y, AtomicUpdateHandle as yt, HydratedMember as z, relatedPaginator as zt };
+//# sourceMappingURL=validate-CJPivkqT.d.cts.map