@org-quicko/silo-client 1.0.0

package/dist/media/media-usage-page.d.cts

@@ -0,0 +1,35 @@
+import { Page } from "../pagination/page.cjs";
+import type { RequestOptions } from "../request-options.cjs";
+import type { Transport } from "../transport/transport.cjs";
+import type { MediaUsage } from "./media-usage.cjs";
+/** `MediaAsset.usages()`'s query. The wire echoes no window, so the
+ * page is built from what was asked for rather than what came back. */
+export interface MediaUsageQuery {
+    limit?: number;
+    offset?: number;
+}
+/**
+ * One page of an asset's referrers, and the awkward page shape. The wire gives a
+ * true `total` this key may not fully see, plus `visible` (what it may) and
+ * `visibleCapped`, and echoes no window at all. `total` still reports the
+ * true count via the base class; `pageCount`/`hasMore` are overridden here
+ * to derive from `visible` instead, since that is all these rows can ever
+ * add up to — not touching `Page` itself, since `total` keeps its normal
+ * meaning for every other page in the client.
+ */
+export declare class MediaUsagePage extends Page<MediaUsage> {
+    private readonly transport;
+    private readonly assetId;
+    readonly visible: number;
+    readonly visibleCapped: boolean;
+    private constructor();
+    get usages(): readonly MediaUsage[];
+    get pageCount(): number | null;
+    get hasMore(): boolean;
+    next(options?: RequestOptions): Promise<MediaUsagePage | null>;
+    previous(options?: RequestOptions): Promise<MediaUsagePage | null>;
+    /** `MediaAsset.usages()`'s entry point: builds the requested window itself,
+     * since the server does not echo one back. */
+    static load(transport: Transport, assetId: string, query: MediaUsageQuery, options?: RequestOptions): Promise<MediaUsagePage>;
+    private static loadWindow;
+}

package/dist/media/media-usage-page.d.ts

@@ -0,0 +1,35 @@
+import { Page } from "../pagination/page.js";
+import type { RequestOptions } from "../request-options.js";
+import type { Transport } from "../transport/transport.js";
+import type { MediaUsage } from "./media-usage.js";
+/** `MediaAsset.usages()`'s query. The wire echoes no window, so the
+ * page is built from what was asked for rather than what came back. */
+export interface MediaUsageQuery {
+    limit?: number;
+    offset?: number;
+}
+/**
+ * One page of an asset's referrers, and the awkward page shape. The wire gives a
+ * true `total` this key may not fully see, plus `visible` (what it may) and
+ * `visibleCapped`, and echoes no window at all. `total` still reports the
+ * true count via the base class; `pageCount`/`hasMore` are overridden here
+ * to derive from `visible` instead, since that is all these rows can ever
+ * add up to — not touching `Page` itself, since `total` keeps its normal
+ * meaning for every other page in the client.
+ */
+export declare class MediaUsagePage extends Page<MediaUsage> {
+    private readonly transport;
+    private readonly assetId;
+    readonly visible: number;
+    readonly visibleCapped: boolean;
+    private constructor();
+    get usages(): readonly MediaUsage[];
+    get pageCount(): number | null;
+    get hasMore(): boolean;
+    next(options?: RequestOptions): Promise<MediaUsagePage | null>;
+    previous(options?: RequestOptions): Promise<MediaUsagePage | null>;
+    /** `MediaAsset.usages()`'s entry point: builds the requested window itself,
+     * since the server does not echo one back. */
+    static load(transport: Transport, assetId: string, query: MediaUsageQuery, options?: RequestOptions): Promise<MediaUsagePage>;
+    private static loadWindow;
+}

package/dist/media/media-usage.d.cts

@@ -0,0 +1,13 @@
+/**
+ * One entry's reference to a media asset, mapped from the wire's snake_case
+ * (`media_id`, `env`, `entry_id`) by `MediaAssetMapper`. The one
+ * referrer type across the client — `MediaUsagePage` and `MediaInUseError`
+ * both use this rather than each declaring their own.
+ */
+export interface MediaUsage {
+    mediaId: string;
+    project: string;
+    environment: string;
+    collection: string;
+    entryId: string;
+}

package/dist/media/media-usage.d.ts

@@ -0,0 +1,13 @@
+/**
+ * One entry's reference to a media asset, mapped from the wire's snake_case
+ * (`media_id`, `env`, `entry_id`) by `MediaAssetMapper`. The one
+ * referrer type across the client — `MediaUsagePage` and `MediaInUseError`
+ * both use this rather than each declaring their own.
+ */
+export interface MediaUsage {
+    mediaId: string;
+    project: string;
+    environment: string;
+    collection: string;
+    entryId: string;
+}

package/dist/media/media.d.cts

@@ -0,0 +1,37 @@
+import type { RequestOptions } from "../request-options.cjs";
+import type { Transport } from "../transport/transport.cjs";
+import { MediaAsset } from "./media-asset.cjs";
+import type { MediaDeleteOptions } from "./media-delete-options.cjs";
+import { MediaDeleteReport } from "./media-delete-report.cjs";
+import { MediaFolders } from "./media-folders.cjs";
+import { MediaPage } from "./media-page.cjs";
+import { MediaPageStream } from "./media-page-stream.cjs";
+import type { MediaQuery } from "./media-query.cjs";
+import { MediaStream } from "./media-stream.cjs";
+import type { MediaUploadBytes, MediaUploadFileOptions } from "./media-upload.cjs";
+/** The media library: instance-global, never scoped to a project or
+ * environment. */
+export declare class Media {
+    private readonly transport;
+    readonly folders: MediaFolders;
+    constructor(transport: Transport);
+    upload(input: MediaUploadBytes, options?: RequestOptions): Promise<MediaAsset>;
+    upload(input: File | Blob, fileOptions?: MediaUploadFileOptions, options?: RequestOptions): Promise<MediaAsset>;
+    list(query?: MediaQuery, options?: RequestOptions): Promise<MediaPage>;
+    /** One `MediaAsset` at a time, across every page. */
+    all(query?: MediaQuery, options?: RequestOptions): MediaStream;
+    /** One whole `MediaPage` at a time, across every page. */
+    pages(query?: MediaQuery, options?: RequestOptions): MediaPageStream;
+    get(id: string, options?: RequestOptions): Promise<MediaAsset>;
+    /** Every distinct file extension actually in the library. */
+    extensions(options?: RequestOptions): Promise<string[]>;
+    /** Refuses locally past {@link BulkDeleteCap} — the server caps it too,
+     * and a local error reads better than a 400. Always answers `200`:
+     * per-id outcomes live in the report, not in a thrown error. */
+    deleteMany(ids: readonly string[], options?: MediaDeleteOptions): Promise<MediaDeleteReport>;
+    private static toWireQuery;
+    private static toBlob;
+    /** A `File` carries its own name; a bare `Blob` does not, and uploading it
+     * as "blob" is worse than refusing outright. */
+    private static filenameOf;
+}

package/dist/media/media.d.ts

@@ -0,0 +1,37 @@
+import type { RequestOptions } from "../request-options.js";
+import type { Transport } from "../transport/transport.js";
+import { MediaAsset } from "./media-asset.js";
+import type { MediaDeleteOptions } from "./media-delete-options.js";
+import { MediaDeleteReport } from "./media-delete-report.js";
+import { MediaFolders } from "./media-folders.js";
+import { MediaPage } from "./media-page.js";
+import { MediaPageStream } from "./media-page-stream.js";
+import type { MediaQuery } from "./media-query.js";
+import { MediaStream } from "./media-stream.js";
+import type { MediaUploadBytes, MediaUploadFileOptions } from "./media-upload.js";
+/** The media library: instance-global, never scoped to a project or
+ * environment. */
+export declare class Media {
+    private readonly transport;
+    readonly folders: MediaFolders;
+    constructor(transport: Transport);
+    upload(input: MediaUploadBytes, options?: RequestOptions): Promise<MediaAsset>;
+    upload(input: File | Blob, fileOptions?: MediaUploadFileOptions, options?: RequestOptions): Promise<MediaAsset>;
+    list(query?: MediaQuery, options?: RequestOptions): Promise<MediaPage>;
+    /** One `MediaAsset` at a time, across every page. */
+    all(query?: MediaQuery, options?: RequestOptions): MediaStream;
+    /** One whole `MediaPage` at a time, across every page. */
+    pages(query?: MediaQuery, options?: RequestOptions): MediaPageStream;
+    get(id: string, options?: RequestOptions): Promise<MediaAsset>;
+    /** Every distinct file extension actually in the library. */
+    extensions(options?: RequestOptions): Promise<string[]>;
+    /** Refuses locally past {@link BulkDeleteCap} — the server caps it too,
+     * and a local error reads better than a 400. Always answers `200`:
+     * per-id outcomes live in the report, not in a thrown error. */
+    deleteMany(ids: readonly string[], options?: MediaDeleteOptions): Promise<MediaDeleteReport>;
+    private static toWireQuery;
+    private static toBlob;
+    /** A `File` carries its own name; a bare `Blob` does not, and uploading it
+     * as "blob" is worse than refusing outright. */
+    private static filenameOf;
+}

package/dist/pagination/page-window.d.cts

@@ -0,0 +1,14 @@
+/**
+ * The `limit` and `offset` a page answered — as the server clamped them, not
+ * as they were asked for. Navigation is arithmetic on this window, not
+ * on the request that produced it.
+ */
+export declare class PageWindow {
+    readonly limit: number;
+    readonly offset: number;
+    constructor(limit: number, offset: number);
+    /** The window one page ahead. */
+    next(): PageWindow;
+    /** The window one page back, or `null` before the start. */
+    previous(): PageWindow | null;
+}

package/dist/pagination/page-window.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The `limit` and `offset` a page answered — as the server clamped them, not
+ * as they were asked for. Navigation is arithmetic on this window, not
+ * on the request that produced it.
+ */
+export declare class PageWindow {
+    readonly limit: number;
+    readonly offset: number;
+    constructor(limit: number, offset: number);
+    /** The window one page ahead. */
+    next(): PageWindow;
+    /** The window one page back, or `null` before the start. */
+    previous(): PageWindow | null;
+}

package/dist/pagination/page.d.cts

@@ -0,0 +1,27 @@
+import { PageWindow } from "./page-window.cjs";
+/**
+ * The shared shape of one page of results. Holds rows, the answered
+ * window, and the total, but does not load anything — a concrete page (an
+ * `EntryPage`, a `MediaPage`,...) declares its own `next()`/`previous()`
+ * that call its own loader and return its own type.
+ *
+ * `truncated` marks a page whose `total` counts what a scan examined rather
+ * than what exists: `pageCount` is then unknowable, and `hasMore`
+ * falls back to "this page came back full".
+ */
+export declare abstract class Page<Row> {
+    protected readonly rows: readonly Row[];
+    protected readonly window: PageWindow;
+    readonly total: number;
+    readonly truncated: boolean;
+    protected constructor(rows: readonly Row[], total: number, window: PageWindow, truncated?: boolean);
+    get limit(): number;
+    get offset(): number;
+    get pageNumber(): number;
+    get pageCount(): number | null;
+    get hasMore(): boolean;
+    /** The window the next page would load, or `null` when there is not one —
+     * so no subclass repeats the "only if there is more" arithmetic. */
+    protected windowForNext(): PageWindow | null;
+    [Symbol.iterator](): Iterator<Row>;
+}

package/dist/pagination/page.d.ts

@@ -0,0 +1,27 @@
+import { PageWindow } from "./page-window.js";
+/**
+ * The shared shape of one page of results. Holds rows, the answered
+ * window, and the total, but does not load anything — a concrete page (an
+ * `EntryPage`, a `MediaPage`,...) declares its own `next()`/`previous()`
+ * that call its own loader and return its own type.
+ *
+ * `truncated` marks a page whose `total` counts what a scan examined rather
+ * than what exists: `pageCount` is then unknowable, and `hasMore`
+ * falls back to "this page came back full".
+ */
+export declare abstract class Page<Row> {
+    protected readonly rows: readonly Row[];
+    protected readonly window: PageWindow;
+    readonly total: number;
+    readonly truncated: boolean;
+    protected constructor(rows: readonly Row[], total: number, window: PageWindow, truncated?: boolean);
+    get limit(): number;
+    get offset(): number;
+    get pageNumber(): number;
+    get pageCount(): number | null;
+    get hasMore(): boolean;
+    /** The window the next page would load, or `null` when there is not one —
+     * so no subclass repeats the "only if there is more" arithmetic. */
+    protected windowForNext(): PageWindow | null;
+    [Symbol.iterator](): Iterator<Row>;
+}

package/dist/pagination/row-stream.d.cts

@@ -0,0 +1,28 @@
+import type { RequestOptions } from "../request-options.cjs";
+import { PageWindow } from "./page-window.cjs";
+/** Loads one page for a given window, and answers the window the server
+ * actually used. */
+export type RowLoader<Row> = (window: PageWindow) => Promise<{
+    rows: Row[];
+    window: PageWindow;
+}>;
+/**
+ * The shared auto-pager behind `collection.all()` and similar.
+ * Advances by the window the server echoed, never by what was asked for, and
+ * stops on the first short or empty page — the sign that nothing more is
+ * behind it.
+ *
+ * Offset iteration over data being written concurrently is not a snapshot:
+ * an entry created ahead of the cursor can be missed, and one deleted behind
+ * it can shift a row into a page already yielded.
+ */
+export declare class RowStream<Row> implements AsyncIterable<Row> {
+    private readonly loader;
+    private readonly startingLimit;
+    private readonly options;
+    constructor(loader: RowLoader<Row>, startingLimit: number, options?: RequestOptions);
+    [Symbol.asyncIterator](): AsyncIterator<Row>;
+    /** Drains the whole stream, for a caller who knows the result set is
+     * small. */
+    toArray(): Promise<Row[]>;
+}

package/dist/pagination/row-stream.d.ts

@@ -0,0 +1,28 @@
+import type { RequestOptions } from "../request-options.js";
+import { PageWindow } from "./page-window.js";
+/** Loads one page for a given window, and answers the window the server
+ * actually used. */
+export type RowLoader<Row> = (window: PageWindow) => Promise<{
+    rows: Row[];
+    window: PageWindow;
+}>;
+/**
+ * The shared auto-pager behind `collection.all()` and similar.
+ * Advances by the window the server echoed, never by what was asked for, and
+ * stops on the first short or empty page — the sign that nothing more is
+ * behind it.
+ *
+ * Offset iteration over data being written concurrently is not a snapshot:
+ * an entry created ahead of the cursor can be missed, and one deleted behind
+ * it can shift a row into a page already yielded.
+ */
+export declare class RowStream<Row> implements AsyncIterable<Row> {
+    private readonly loader;
+    private readonly startingLimit;
+    private readonly options;
+    constructor(loader: RowLoader<Row>, startingLimit: number, options?: RequestOptions);
+    [Symbol.asyncIterator](): AsyncIterator<Row>;
+    /** Drains the whole stream, for a caller who knows the result set is
+     * small. */
+    toArray(): Promise<Row[]>;
+}

package/dist/query/field-path.d.cts

@@ -0,0 +1,14 @@
+/**
+ * Builds the JSONPath strings the filter and sort AST address. A name may
+ * already carry a bracket segment (`tags[0]`, `tags[-1]`) or a dot for a
+ * nested field (`author.name`) — both pass through untouched, since prefixing
+ * is plain string concatenation.
+ */
+export declare class FieldPath {
+    /** `field("title")` is `$.data.title`. */
+    static field(name: string): string;
+    /** `each("tags")` is `$.data.tags[*]`, so nobody types the wildcard. */
+    static each(name: string): string;
+    /** `meta("updated_at")` addresses the envelope, not `data`: `$.updated_at`. */
+    static meta(name: string): string;
+}

package/dist/query/field-path.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Builds the JSONPath strings the filter and sort AST address. A name may
+ * already carry a bracket segment (`tags[0]`, `tags[-1]`) or a dot for a
+ * nested field (`author.name`) — both pass through untouched, since prefixing
+ * is plain string concatenation.
+ */
+export declare class FieldPath {
+    /** `field("title")` is `$.data.title`. */
+    static field(name: string): string;
+    /** `each("tags")` is `$.data.tags[*]`, so nobody types the wildcard. */
+    static each(name: string): string;
+    /** `meta("updated_at")` addresses the envelope, not `data`: `$.updated_at`. */
+    static meta(name: string): string;
+}

package/dist/query/filter-expression.d.cts

@@ -0,0 +1,15 @@
+import type { FilterNode } from "./filter-node.cjs";
+/**
+ * A built filter, ready to combine or send. Wraps one `FilterNode` and
+ * grows a bigger one on `and`/`or`/`not` rather than mutating what it wraps,
+ * so `left.and(right).or(other)` never surprises a caller holding `left`.
+ */
+export declare class FilterExpression {
+    private readonly node;
+    constructor(node: FilterNode);
+    and(other: FilterExpression): FilterExpression;
+    or(other: FilterExpression): FilterExpression;
+    not(): FilterExpression;
+    /** The wire shape: what `?filter=` sends. */
+    toJSON(): FilterNode;
+}

package/dist/query/filter-expression.d.ts

@@ -0,0 +1,15 @@
+import type { FilterNode } from "./filter-node.js";
+/**
+ * A built filter, ready to combine or send. Wraps one `FilterNode` and
+ * grows a bigger one on `and`/`or`/`not` rather than mutating what it wraps,
+ * so `left.and(right).or(other)` never surprises a caller holding `left`.
+ */
+export declare class FilterExpression {
+    private readonly node;
+    constructor(node: FilterNode);
+    and(other: FilterExpression): FilterExpression;
+    or(other: FilterExpression): FilterExpression;
+    not(): FilterExpression;
+    /** The wire shape: what `?filter=` sends. */
+    toJSON(): FilterNode;
+}

package/dist/query/filter-field.d.cts

@@ -0,0 +1,19 @@
+import { FilterExpression } from "./filter-expression.cjs";
+/**
+ * One path awaiting an operator. Generic over `Value` so `TypedFilter` can
+ * constrain what an operator accepts to the field's declared type, while
+ * `Filter`'s untyped statics leave it as `unknown`.
+ */
+export declare class FilterField<Value = unknown> {
+    private readonly path;
+    constructor(path: string);
+    equals(value: Value): FilterExpression;
+    notEquals(value: Value): FilterExpression;
+    contains(value: Value): FilterExpression;
+    greaterThan(value: Value): FilterExpression;
+    atLeast(value: Value): FilterExpression;
+    lessThan(value: Value): FilterExpression;
+    atMost(value: Value): FilterExpression;
+    oneOf(values: Value[]): FilterExpression;
+    exists(): FilterExpression;
+}

package/dist/query/filter-field.d.ts

@@ -0,0 +1,19 @@
+import { FilterExpression } from "./filter-expression.js";
+/**
+ * One path awaiting an operator. Generic over `Value` so `TypedFilter` can
+ * constrain what an operator accepts to the field's declared type, while
+ * `Filter`'s untyped statics leave it as `unknown`.
+ */
+export declare class FilterField<Value = unknown> {
+    private readonly path;
+    constructor(path: string);
+    equals(value: Value): FilterExpression;
+    notEquals(value: Value): FilterExpression;
+    contains(value: Value): FilterExpression;
+    greaterThan(value: Value): FilterExpression;
+    atLeast(value: Value): FilterExpression;
+    lessThan(value: Value): FilterExpression;
+    atMost(value: Value): FilterExpression;
+    oneOf(values: Value[]): FilterExpression;
+    exists(): FilterExpression;
+}

package/dist/query/filter-node.d.cts

@@ -0,0 +1,9 @@
+import type { FilterOperator } from "./filter-operator.cjs";
+/** One node of the wire's filter AST: a leaf tests `path` against `value`, a
+ *  group combines nested nodes in `args`. */
+export interface FilterNode {
+    op: FilterOperator;
+    path?: string;
+    value?: unknown;
+    args?: FilterNode[];
+}

package/dist/query/filter-node.d.ts

@@ -0,0 +1,9 @@
+import type { FilterOperator } from "./filter-operator.js";
+/** One node of the wire's filter AST: a leaf tests `path` against `value`, a
+ *  group combines nested nodes in `args`. */
+export interface FilterNode {
+    op: FilterOperator;
+    path?: string;
+    value?: unknown;
+    args?: FilterNode[];
+}

package/dist/query/filter-operator.d.cts

@@ -0,0 +1,7 @@
+/** The closed set of operators the filter AST accepts: nine leaves that test
+ *  one path, and three groups that combine nested nodes. */
+export type FilterOperator = "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "contains" | "exists" | "and" | "or" | "not";
+/** The same set at runtime, so a drift test can compare it against the
+ *  server's own vocabulary. An operator silo adds and the client does not
+ *  offer is a gap a type alone cannot detect. */
+export declare const FilterOperators: readonly FilterOperator[];

package/dist/query/filter-operator.d.ts

@@ -0,0 +1,7 @@
+/** The closed set of operators the filter AST accepts: nine leaves that test
+ *  one path, and three groups that combine nested nodes. */
+export type FilterOperator = "eq" | "neq" | "gt" | "gte" | "lt" | "lte" | "in" | "contains" | "exists" | "and" | "or" | "not";
+/** The same set at runtime, so a drift test can compare it against the
+ *  server's own vocabulary. An operator silo adds and the client does not
+ *  offer is a gap a type alone cannot detect. */
+export declare const FilterOperators: readonly FilterOperator[];

package/dist/query/filter.d.cts

@@ -0,0 +1,18 @@
+import { FilterExpression } from "./filter-expression.cjs";
+import { FilterField } from "./filter-field.cjs";
+import type { FilterNode } from "./filter-node.cjs";
+/**
+ * The untyped filter statics, for a filter built from user input at runtime
+ * or a caller not using `collection<Fields>()`. `TypedFilter` offers the
+ * same surface, typed to a collection's fields.
+ */
+export declare class Filter {
+    static field(name: string): FilterField;
+    static each(name: string): FilterField;
+    static meta(name: string): FilterField;
+    static and(left: FilterExpression, right: FilterExpression): FilterExpression;
+    static or(left: FilterExpression, right: FilterExpression): FilterExpression;
+    static not(expression: FilterExpression): FilterExpression;
+    /** The escape hatch: wraps a hand-built node exactly as given. */
+    static raw(node: FilterNode): FilterExpression;
+}

package/dist/query/filter.d.ts

@@ -0,0 +1,18 @@
+import { FilterExpression } from "./filter-expression.js";
+import { FilterField } from "./filter-field.js";
+import type { FilterNode } from "./filter-node.js";
+/**
+ * The untyped filter statics, for a filter built from user input at runtime
+ * or a caller not using `collection<Fields>()`. `TypedFilter` offers the
+ * same surface, typed to a collection's fields.
+ */
+export declare class Filter {
+    static field(name: string): FilterField;
+    static each(name: string): FilterField;
+    static meta(name: string): FilterField;
+    static and(left: FilterExpression, right: FilterExpression): FilterExpression;
+    static or(left: FilterExpression, right: FilterExpression): FilterExpression;
+    static not(expression: FilterExpression): FilterExpression;
+    /** The escape hatch: wraps a hand-built node exactly as given. */
+    static raw(node: FilterNode): FilterExpression;
+}

package/dist/query/sort-term.d.cts

@@ -0,0 +1,13 @@
+/** Ascending unless `descending()` was called. */
+export type SortDirection = "asc" | "desc";
+/** One sort key: a path plus a direction. Stringifies to what the `sort`
+ *  query parameter wants — the path alone when ascending, `-`-prefixed when
+ *  descending. */
+export declare class SortTerm {
+    private readonly path;
+    private readonly direction;
+    constructor(path: string, direction?: SortDirection);
+    ascending(): SortTerm;
+    descending(): SortTerm;
+    toString(): string;
+}

package/dist/query/sort-term.d.ts

@@ -0,0 +1,13 @@
+/** Ascending unless `descending()` was called. */
+export type SortDirection = "asc" | "desc";
+/** One sort key: a path plus a direction. Stringifies to what the `sort`
+ *  query parameter wants — the path alone when ascending, `-`-prefixed when
+ *  descending. */
+export declare class SortTerm {
+    private readonly path;
+    private readonly direction;
+    constructor(path: string, direction?: SortDirection);
+    ascending(): SortTerm;
+    descending(): SortTerm;
+    toString(): string;
+}

package/dist/query/sort.d.cts

@@ -0,0 +1,15 @@
+import { SortTerm } from "./sort-term.cjs";
+/**
+ * Sort statics. No `each`, deliberately: a sort path must select at most one
+ * node, so there is no wildcard variant to offer.
+ */
+export declare class Sort {
+    static by(name: string): SortTerm;
+    static meta(name: string): SortTerm;
+    /** Sorts on `updated_at`, most recent first. Named for the field, not a
+     *  vague idea of recency — `recentlyCreated` is a different order. */
+    static recentlyUpdated(): SortTerm;
+    static recentlyCreated(): SortTerm;
+    /** Joins terms with a comma: what the `sort` query parameter wants. */
+    static of(...terms: SortTerm[]): string;
+}

package/dist/query/sort.d.ts

@@ -0,0 +1,15 @@
+import { SortTerm } from "./sort-term.js";
+/**
+ * Sort statics. No `each`, deliberately: a sort path must select at most one
+ * node, so there is no wildcard variant to offer.
+ */
+export declare class Sort {
+    static by(name: string): SortTerm;
+    static meta(name: string): SortTerm;
+    /** Sorts on `updated_at`, most recent first. Named for the field, not a
+     *  vague idea of recency — `recentlyCreated` is a different order. */
+    static recentlyUpdated(): SortTerm;
+    static recentlyCreated(): SortTerm;
+    /** Joins terms with a comma: what the `sort` query parameter wants. */
+    static of(...terms: SortTerm[]): string;
+}

package/dist/query/typed-filter.d.cts

@@ -0,0 +1,32 @@
+import { FilterExpression } from "./filter-expression.cjs";
+import { FilterField } from "./filter-field.cjs";
+import type { FilterNode } from "./filter-node.cjs";
+/** A plain field of `Fields`, or a dotted/bracketed extension of one —
+ * `"author.name"` and `"tags[0]"` stay valid even though neither is a key
+ * of `Fields` by itself. */
+type TypedFieldPath<Fields> = (keyof Fields & string) | `${keyof Fields & string}.${string}` | `${keyof Fields & string}[${string}]`;
+/** The value an operator on `Key` should accept: `Fields[Key]` when `Key` is
+ * a plain field, `unknown` for a dotted or bracketed extension, whose
+ * target type this client cannot resolve statically. */
+type TypedFieldValue<Fields, Key extends string> = Key extends keyof Fields ? Fields[Key] : unknown;
+/** `each` walks one element of an array field at a time, so its operators
+ * take the element type — `each("tags")` on `tags: string[]` should accept
+ * a `string`, not a `string[]`. */
+type TypedEachValue<Fields, Key extends string> = Key extends keyof Fields ? Fields[Key] extends readonly (infer Element)[] ? Element : Fields[Key] : unknown;
+/**
+ * `Filter`'s surface, typed to one collection's fields:
+ * `posts.filter.field("status")` autocompletes `keyof Post`, and
+ * `posts.filter.field("stauts")` does not compile. `meta`, `and`, `or`,
+ * `not` and `raw` are untyped, the same as on `Filter`, since they do not
+ * address `Fields` at all.
+ */
+export declare class TypedFilter<Fields> {
+    field<Key extends TypedFieldPath<Fields>>(name: Key): FilterField<TypedFieldValue<Fields, Key>>;
+    each<Key extends TypedFieldPath<Fields>>(name: Key): FilterField<TypedEachValue<Fields, Key>>;
+    meta(name: string): FilterField;
+    and(left: FilterExpression, right: FilterExpression): FilterExpression;
+    or(left: FilterExpression, right: FilterExpression): FilterExpression;
+    not(expression: FilterExpression): FilterExpression;
+    raw(node: FilterNode): FilterExpression;
+}
+export {};

package/dist/query/typed-filter.d.ts

@@ -0,0 +1,32 @@
+import { FilterExpression } from "./filter-expression.js";
+import { FilterField } from "./filter-field.js";
+import type { FilterNode } from "./filter-node.js";
+/** A plain field of `Fields`, or a dotted/bracketed extension of one —
+ * `"author.name"` and `"tags[0]"` stay valid even though neither is a key
+ * of `Fields` by itself. */
+type TypedFieldPath<Fields> = (keyof Fields & string) | `${keyof Fields & string}.${string}` | `${keyof Fields & string}[${string}]`;
+/** The value an operator on `Key` should accept: `Fields[Key]` when `Key` is
+ * a plain field, `unknown` for a dotted or bracketed extension, whose
+ * target type this client cannot resolve statically. */
+type TypedFieldValue<Fields, Key extends string> = Key extends keyof Fields ? Fields[Key] : unknown;
+/** `each` walks one element of an array field at a time, so its operators
+ * take the element type — `each("tags")` on `tags: string[]` should accept
+ * a `string`, not a `string[]`. */
+type TypedEachValue<Fields, Key extends string> = Key extends keyof Fields ? Fields[Key] extends readonly (infer Element)[] ? Element : Fields[Key] : unknown;
+/**
+ * `Filter`'s surface, typed to one collection's fields:
+ * `posts.filter.field("status")` autocompletes `keyof Post`, and
+ * `posts.filter.field("stauts")` does not compile. `meta`, `and`, `or`,
+ * `not` and `raw` are untyped, the same as on `Filter`, since they do not
+ * address `Fields` at all.
+ */
+export declare class TypedFilter<Fields> {
+    field<Key extends TypedFieldPath<Fields>>(name: Key): FilterField<TypedFieldValue<Fields, Key>>;
+    each<Key extends TypedFieldPath<Fields>>(name: Key): FilterField<TypedEachValue<Fields, Key>>;
+    meta(name: string): FilterField;
+    and(left: FilterExpression, right: FilterExpression): FilterExpression;
+    or(left: FilterExpression, right: FilterExpression): FilterExpression;
+    not(expression: FilterExpression): FilterExpression;
+    raw(node: FilterNode): FilterExpression;
+}
+export {};