foldkit-crud 0.10.0 → 0.12.0

package/dist/{index.d.mts → index.d.ts}

@@ -1,218 +1,15 @@
+import { Display, DisplayColumn, DisplayKind, DisplayWords } from "./display.js";
+import { screen } from "./screen.js";
+import { Sort, SortState, SortedColumn } from "./sort.js";
 import { Option, Schema } from "effect";
+import { AnyEntity, EntityInput, IdOf, Selection, SelectionPage } from "foldkit-entity";
 import { Bundle } from "foldkit-bundle";
-import { AnyEntity, EntityInput, EntityMember, IdOf, Selection, SelectionPage } from "foldkit-entity";
 import { FormControl, Submitted } from "foldkit-form";
-import { Metadata } from "foldkit-metadata";
 import { MutationDescriptor, MutationStatus, Page, QueryDescriptor, RemoteClient, RemoteData, RemoteError, RemoteMessage } from "foldkit-remote";
 import { ActiveSurface, ModelRef, Projection } from "foldkit-surface";
 import { Command } from "foldkit/command";
 import * as Submodel from "foldkit/submodel";
 import * as Update from "foldkit/update";
-/**
- * How one selected member shows: the primitive every kind of Display is a value
- * of. `Display.text()` and `Display.flag()` are values of it, made by
- * `Display.kind`, which is what an application calls for a badge or a relative
- * date. The kinds here are a collection, not a special case.
- */
-export interface Display<Data = unknown> {
-  /** The name a renderer is found by. */
-  readonly kind: string;
-  /** Whether a view draws it. A member read and not shown, usually the id, is `false`. */
-  readonly shown: boolean;
-  /** What this kind needs: a format, a relation's target. */
-  readonly data: Data;
-  /**
-   * The value as text: what a cell says when nothing draws it specially. It is
-   * never given `null` or `undefined`; `Display.show` says `nothing` for those.
-   */
-  readonly text: (value: unknown, words: DisplayWords) => string;
-}
-/** A kind of Display: how its values are made, and how one is told from another. */
-interface DisplayKind<Data> {
-  readonly kind: string;
-  readonly of: (data: Data) => Display<Data>;
-  readonly is: (display: Display) => display is Display<Data>;
-}
-/** A selected member with its words and its Display. A list's column, a detail's line. */
-interface DisplayColumn<Key extends string = string> {
-  readonly key: Key;
-  readonly label: string;
-  readonly member: EntityMember;
-  readonly display: Display;
-}
-/** The words a Display needs that are not the value's own. */
-interface DisplayWords {
-  /** Default `yes`. */
-  readonly yes?: string;
-  /** Default `no`. */
-  readonly no?: string;
-  /** What stands for nothing: `null`, `undefined`, an empty list. Default the empty string. */
-  readonly nothing?: string;
-  /** Between the items of a list, and between the members of a nested value. Default `, `. */
-  readonly separator?: string;
-}
-/** A kind of Display. The kinds below are made with it, and so is an application's. */
-declare const kind: <Data = Record<string, never>>(name: string, spec: {
-  readonly shown?: boolean;
-  readonly text: (data: Data, value: unknown, words: DisplayWords) => string;
-}) => DisplayKind<Data>;
-declare const show: (display: Display, value: unknown, words?: DisplayWords) => string;
-export declare const Display: {
-  /**
-   * A kind of Display. `Display.kind<{ tone: string }>('Badge', { text: (_, value) => String(value) })`
-   * gives `.of(data)` to make one and `.is(display)` to tell one, exactly as the
-   * kinds below were made. `text` is the floor; a view draws it specially once
-   * it is given a renderer for `Badge`.
-   */
-  kind: typeof kind;
-  Text: DisplayKind<{
-    readonly format?: ((value: unknown) => string) | undefined;
-  }>;
-  Number: DisplayKind<{
-    readonly format?: ((value: number) => string) | undefined;
-  }>;
-  Flag: DisplayKind<Record<string, never>>;
-  Hidden: DisplayKind<Record<string, never>>;
-  Ref: DisplayKind<{
-    readonly target: AnyEntity;
-    readonly many: boolean;
-  }>;
-  Nested: DisplayKind<{
-    readonly target: AnyEntity;
-    readonly shape: 'one' | 'many' | 'page';
-    readonly columns: ReadonlyArray<DisplayColumn>;
-  }>;
-  text: (format?: (value: unknown) => string) => Display;
-  number: (format?: (value: number) => string) => Display;
-  flag: () => Display;
-  /** Read, so a row can be opened or keyed by it, and not shown: usually the id. */
-  hidden: () => Display;
-  /**
-   * Entity metadata: how a member shows wherever it is listed, e.g.
-   * `Entity.annotateMembers({ price: Display.of(Display.number(cents => ...)) })`.
-   */
-  of: (display: Display) => Metadata;
-  /**
-   * The Display of one selected member, from the most to the least explicit
-   * source: the member's `Display.of` metadata, how the relation was selected,
-   * then the shape of its schema. `nested` is the columns of a nested Selection,
-   * with `shape` saying how many the relation yields.
-   */
-  resolve: (member: EntityMember, nested?: {
-    readonly shape: 'one' | 'many' | 'page';
-    readonly columns: ReadonlyArray<DisplayColumn>;
-  }) => Display;
-  /**
-   * A value as the text its Display calls for: what a cell says when nothing
-   * draws it specially. A view that wants a link or a badge reads the Display
-   * and the value itself; this is the floor every view can stand on.
-   */
-  show: typeof show;
-};
-/** The four Messages a screen answers, named after it: `OpenedPost`, `CreatedPost`, … */
-type ScreenCases<Name extends string, Id extends Schema.Top> = { readonly [K in `Opened${Name}`]: {
-  readonly id: Id;
-}; } & { readonly [K in `Created${Name}`]: {}; } & { readonly [K in `Closed${Name}`]: {}; } & { readonly [K in `AskedToRemove${Name}`]: {
-  readonly id: Id;
-}; };
-/**
- * What the screen asks of the page's placed pieces. `Out` and `Asked` are what
- * the editor's and the remover's helpers return, the page's own Model and
- * Commands, which the screen hands back.
- */
-interface ScreenPieces<Root, Id, Out extends {
-  readonly model: Root;
-}, Asked extends {
-  readonly model: Root;
-}> {
-  /** The placed editor (`Editor.at(...)`), whose sync runs after every Message. */
-  readonly editor: {
-    readonly after: <M, R extends {
-      readonly model: Root;
-    }>(update: (model: Root, message: M) => R) => (model: Root, message: M) => R;
-  };
-  /**
-   * The editor's placement (`Page.children.editor`): its `open`, `blank` and
-   * `close`, and its link, which reads the form's Messages out of the page's.
-   */
-  readonly editing: {
-    readonly helpers: {
-      readonly open: (id: Id) => (model: Root) => Out;
-      readonly blank: () => (model: Root) => Out;
-      readonly close: () => (model: Root) => Out;
-    };
-    readonly link: {
-      readonly fromParentMessage: (message: never) => Option.Option<unknown>;
-    };
-  };
-  /** The remover's placement, when the screen can delete: its `ask`. */
-  readonly removing?: {
-    readonly helpers: {
-      readonly ask: (id: Id) => (model: Root) => Asked;
-    };
-  } | undefined;
-  /**
-   * The form's pickers (`Crud.options`), when they page: a picker's
-   * `AskedForMore` shows one more page of its list, and still reaches the form.
-   */
-  readonly pickers?: {
-    readonly ask: (root: NoInfer<Root>, key: never) => NoInfer<Root>;
-  } | undefined;
-}
-declare const screen: <const Name extends string, Id extends Schema.Top>(name: Name, config: {
-  readonly id: Id;
-}) => {
-  /** For `Bundle.withMessages`, beside the page's own. */
-  messages: ScreenCases<Name, Id>;
-  /**
-   * Wraps the page's `update`: the screen's Messages are answered here, and
-   * every other goes to `update`; the editor's sync runs after each, so the
-   * loaded value is shown whichever Message brings it.
-   */
-  update: <Root, Message extends {
-    readonly _tag: string;
-  }, Result extends {
-    readonly model: Root;
-  }, Out extends {
-    readonly model: Root;
-  }, Asked extends {
-    readonly model: Root;
-  } = never>(pieces: ScreenPieces<Root, Id['Type'], Out, Asked>, update: (model: Root, message: Message) => Result) => (model: Root, message: Message) => Asked | Out | Result;
-};
-/** How a list is sorted: by which of its orders, which way; `null` for the server's own order. */
-type SortState<Column extends string> = {
-  readonly by: Column;
-  readonly direction: 'asc' | 'desc';
-} | null;
-/** How one column is sorted now, and the Message a click on its header sends. */
-interface SortedColumn<Message> {
-  readonly direction?: 'asc' | 'desc' | undefined;
-  readonly message: Message;
-}
-export declare const Sort: {
-  /**
-   * The orders a list offers, by name. A name is an order the server knows, not
-   * a column: which columns may sort, and what `title` means in SQL, stay the
-   * server's to decide.
-   */
-  make: <const Columns extends readonly [string, ...string[]]>(columns: Columns) => {
-    columns: Columns;
-    /** For the Model field, and for the query's input. */
-    Schema: Schema.Codec<SortState<Columns[number]>, SortState<Columns[number]>>;
-    /** The server's own order. */
-    none: SortState<Columns[number]>;
-    toggle: (current: SortState<Columns[number]>, column: Columns[number]) => SortState<Columns[number]>;
-    /**
-     * What a drawn table takes as `sort`: every order with how it is sorted now
-     * and the Message a click sends, made from the state the click leads to and
-     * the column clicked. A click meets the state last drawn, so two clicks
-     * inside one frame both send the same `next`; send the column instead
-     * (`(_, column) => Sorted({ column })`) and `toggle` it in `update`, from
-     * the Model as it is then.
-     */
-    inputs: <Message>(current: SortState<Columns[number]>, message: (next: SortState<Columns[number]>, column: Columns[number]) => Message) => { readonly [K in Columns[number]]: SortedColumn<Message>; };
-  };
-};
 /** The parts of a `Form.make` result an editor wraps. */
 export interface EditableForm<Name extends string, FormModel, FormMessage, Value, E extends AnyEntity, Fields extends Schema.Struct.Fields, Members, R = never> {
   readonly bundle: {
@@ -232,6 +29,7 @@ export interface EditableForm<Name extends string, FormModel, FormMessage, Value
     Refused(fields: {
       readonly key: string;
       readonly error: string;
+      readonly value: unknown;
     }): FormMessage;
   };
 }
@@ -308,13 +106,17 @@ export interface DomainLike<Root> {
     readonly command: Command<RemoteMessage, never, RemoteClient>;
   };
   get(selection: any, id: string): Projection<Root, RemoteData<any>>;
-  query(query: any, input: any, options: any): Projection<Root, RemoteData<Page<any>>>;
+  query(query: any, input: any, options: any): Projection<Root, RemoteData<Page<any>>> & {
+    readonly ref: {
+      readonly identity: string;
+    };
+  };
   more(model: Root, projection: any): Option.Option<Root>;
   refresh(model: Root, target: any): Root;
   mutation(model: Root, requestId: string): MutationStatus;
   refusal(model: Root, requestId: string, mutation: any): Option.Option<unknown>;
   /** `Data.active`: a read of the domain as an active Surface of its application. */
-  active(name: string, projectionOf: (model: Root) => Option.Option<Projection<Root, any>>): ActiveSurface<Root>;
+  active<Value>(name: string, projectionOf: (model: Root) => Option.Option<Projection<Root, Value>>): ActiveSurface<Root, Value>;
 }
 type Step<Root> = Update.Step<Root, RemoteMessage, RemoteClient>;
 /** One thing a relation picker offers. */
@@ -348,7 +150,7 @@ export declare const Crud: {
       readonly id: (root: Root) => Option.Option<string>;
     }) => {
       /** For `Data.subscriptions`: the value is fetched and retained while an id is shown. */
-      active: ActiveSurface<Root, unknown>;
+      active: ActiveSurface<Root, RemoteData<any>>;
       value: (root: Root) => RemoteData<Row>;
       /**
        * Asks for the value again: `Data.refresh` over this detail, for a retry
@@ -435,6 +237,8 @@ export declare const Crud: {
     readonly selection: Selection<EntityName, Members, S>;
     /** How many rows a page holds. Default 25. */
     readonly pageSize?: number;
+    /** Watch the list live while it is shown (`Data.query`'s `live`). */
+    readonly live?: boolean;
     /**
      * How a row reads as a choice in a relation picker: its id, and the words
      * that identify it to a person. Give it to a list that feeds pickers.
@@ -459,8 +263,17 @@ export declare const Crud: {
       readonly input: (root: Root) => Option.Option<Input>;
     }) => {
       /** For `Data.subscriptions`: the page and its rows are fetched and retained while shown. */
-      active: ActiveSurface<Root, unknown>;
+      active: ActiveSurface<Root, RemoteData<Page<any>>>;
       page: (root: Root) => RemoteData<Page<S['Type']>>;
+      /**
+       * The connection the list reads while it is shown, for a write's
+       * optimistic insert or remove (`ConnectionChange.prepend(list, ref)`):
+       * the list's own key, so a change cannot name one rebuilt from its
+       * input that nothing reads. None while the list is not shown.
+       */
+      connection: (root: Root) => Option.Option<{
+        readonly identity: string;
+      }>;
       /**
        * "Load more": the Model with the list showing one page more, for the
        * read entry to fetch; none when it shows every row there is.
@@ -487,12 +300,13 @@ export declare const Crud: {
       /** Whether the list was given a `choice`, so its rows can be a picker's choices. */
       offersChoices: boolean;
       /**
-       * The loaded rows as a picker's choices, read through `choice`. Listing a
+       * The loaded rows as a picker's choices, read through `choice`; after a
+       * failed refresh, the rows last read, as the list still shows them. Listing a
        * relation's target is this query, which the application chose and the
        * server authorizes; nothing is read because a relation exists.
        */
       choices: (root: Root) => ReadonlyArray<Choice>;
-      /** That row as a choice, once it is read. */
+      /** That row as a choice, once it is read, or as last read when a refresh failed. */
       choiceOf: (root: Root, id: string) => Choice | undefined;
     };
   };
@@ -615,7 +429,18 @@ export declare const Crud: {
       };
     }>;
     /** What the editor loads before it shows the form: every member the form writes. */
-    selection: Selection<E["name"], import("foldkit-entity").WrittenSpec<Members>, Schema.Struct<{ readonly [K in keyof import("foldkit-entity").WrittenSpec<Members> & keyof E["members"]]: E["members"][K] extends (infer T) ? T extends E["members"][K] ? T extends import("foldkit-entity").EntityDerived<any, any, infer S extends Schema.Constraint> | import("foldkit-entity").EntityField<any, any, infer S extends Schema.Constraint> ? S : T extends import("foldkit-entity").EntityRelation<any, any, infer Target extends AnyEntity, infer C extends import("foldkit-entity").Cardinality, infer Optional extends boolean> ? import("foldkit-entity").WrittenSpec<Members>[K] extends (infer T_1) ? T_1 extends import("foldkit-entity").WrittenSpec<Members>[K] ? T_1 extends SelectionPage<any, infer S_1 extends Schema.Constraint> ? Schema.Struct<{
+    selection: Selection<E["name"], import("foldkit-entity").WrittenSpec<Members>, Schema.Struct<{ readonly [K in keyof import("foldkit-entity").WrittenSpec<Members> & keyof E["members"]]: E["members"][K] extends (infer T) ? T extends E["members"][K] ? T extends import("foldkit-entity").EntityDerived<any, any, infer S extends Schema.Constraint, {
+      readonly _tag: "Count";
+      readonly relation: import("foldkit-entity").EntityRelation<string, string, AnyEntity, "one", boolean>;
+    } | {
+      readonly _tag: "Exists";
+      readonly relation: import("foldkit-entity").EntityRelation<string, string, AnyEntity, "one", boolean>;
+      readonly viewer: import("foldkit-entity").EntityRelation<string, string, AnyEntity, "one", boolean>;
+    } | {
+      readonly _tag: "Supplied";
+      readonly predict: Option.Option<import("foldkit-entity").Predict>;
+      readonly forbids: Option.Option<import("foldkit-entity").Forbids>;
+    }> | import("foldkit-entity").EntityField<any, any, infer S extends Schema.Constraint> ? S : T extends import("foldkit-entity").EntityRelation<any, any, infer Target extends AnyEntity, infer C extends import("foldkit-entity").Cardinality, infer Optional extends boolean> ? import("foldkit-entity").WrittenSpec<Members>[K] extends (infer T_1) ? T_1 extends import("foldkit-entity").WrittenSpec<Members>[K] ? T_1 extends SelectionPage<any, infer S_1 extends Schema.Constraint> ? Schema.Struct<{
       readonly items: Schema.$Array<S_1>;
       readonly hasNext: Schema.Boolean;
       readonly hasPrevious: Schema.Boolean;
@@ -644,7 +469,79 @@ export declare const Crud: {
        * For `Data.subscriptions`: while an id is being edited, what it loads is
        * a requirement like any Surface's, so Remote fetches and retains it.
        */
-      active: ActiveSurface<Root, unknown>;
+      active: ActiveSurface<Root, RemoteData<Schema.Struct.View<{ readonly [K in keyof import("foldkit-entity").WrittenSpec<Members> & keyof E["members"]]: E["members"][K] extends (infer T) ? T extends E["members"][K] ? T extends import("foldkit-entity").EntityDerived<any, any, infer S extends Schema.Constraint, {
+        readonly _tag: "Count";
+        readonly relation: import("foldkit-entity").EntityRelation<string, string, AnyEntity, "one", boolean>;
+      } | {
+        readonly _tag: "Exists";
+        readonly relation: import("foldkit-entity").EntityRelation<string, string, AnyEntity, "one", boolean>;
+        readonly viewer: import("foldkit-entity").EntityRelation<string, string, AnyEntity, "one", boolean>;
+      } | {
+        readonly _tag: "Supplied";
+        readonly predict: Option.Option<import("foldkit-entity").Predict>;
+        readonly forbids: Option.Option<import("foldkit-entity").Forbids>;
+      }> | import("foldkit-entity").EntityField<any, any, infer S extends Schema.Constraint> ? S : T extends import("foldkit-entity").EntityRelation<any, any, infer Target extends AnyEntity, infer C extends import("foldkit-entity").Cardinality, infer Optional extends boolean> ? import("foldkit-entity").WrittenSpec<Members>[K] extends (infer T_1) ? T_1 extends import("foldkit-entity").WrittenSpec<Members>[K] ? T_1 extends SelectionPage<any, infer S_1 extends Schema.Constraint> ? Schema.Struct<{
+        readonly items: Schema.$Array<S_1>;
+        readonly hasNext: Schema.Boolean;
+        readonly hasPrevious: Schema.Boolean;
+      }> : C extends "many" ? Schema.$Array<T_1 extends Selection<any, any, infer S_2 extends Schema.Constraint, string> ? S_2 : Schema.Struct<{
+        readonly entity: Schema.Literal<Target["name"]>;
+        readonly id: import("foldkit-entity").IdSchemaOf<Target>;
+      }>> : Optional extends true ? Schema.NullOr<T_1 extends Selection<any, any, infer S_2 extends Schema.Constraint, string> ? S_2 : Schema.Struct<{
+        readonly entity: Schema.Literal<Target["name"]>;
+        readonly id: import("foldkit-entity").IdSchemaOf<Target>;
+      }>> : T_1 extends Selection<any, any, infer S_2 extends Schema.Constraint, string> ? S_2 : Schema.Struct<{
+        readonly entity: Schema.Literal<Target["name"]>;
+        readonly id: import("foldkit-entity").IdSchemaOf<Target>;
+      }> : never : never : never : never : never; }, "Type", Schema.Struct.TypeOptionalKeys<{ readonly [K in keyof import("foldkit-entity").WrittenSpec<Members> & keyof E["members"]]: E["members"][K] extends (infer T) ? T extends E["members"][K] ? T extends import("foldkit-entity").EntityDerived<any, any, infer S extends Schema.Constraint, {
+        readonly _tag: "Count";
+        readonly relation: import("foldkit-entity").EntityRelation<string, string, AnyEntity, "one", boolean>;
+      } | {
+        readonly _tag: "Exists";
+        readonly relation: import("foldkit-entity").EntityRelation<string, string, AnyEntity, "one", boolean>;
+        readonly viewer: import("foldkit-entity").EntityRelation<string, string, AnyEntity, "one", boolean>;
+      } | {
+        readonly _tag: "Supplied";
+        readonly predict: Option.Option<import("foldkit-entity").Predict>;
+        readonly forbids: Option.Option<import("foldkit-entity").Forbids>;
+      }> | import("foldkit-entity").EntityField<any, any, infer S extends Schema.Constraint> ? S : T extends import("foldkit-entity").EntityRelation<any, any, infer Target extends AnyEntity, infer C extends import("foldkit-entity").Cardinality, infer Optional extends boolean> ? import("foldkit-entity").WrittenSpec<Members>[K] extends (infer T_1) ? T_1 extends import("foldkit-entity").WrittenSpec<Members>[K] ? T_1 extends SelectionPage<any, infer S_1 extends Schema.Constraint> ? Schema.Struct<{
+        readonly items: Schema.$Array<S_1>;
+        readonly hasNext: Schema.Boolean;
+        readonly hasPrevious: Schema.Boolean;
+      }> : C extends "many" ? Schema.$Array<T_1 extends Selection<any, any, infer S_2 extends Schema.Constraint, string> ? S_2 : Schema.Struct<{
+        readonly entity: Schema.Literal<Target["name"]>;
+        readonly id: import("foldkit-entity").IdSchemaOf<Target>;
+      }>> : Optional extends true ? Schema.NullOr<T_1 extends Selection<any, any, infer S_2 extends Schema.Constraint, string> ? S_2 : Schema.Struct<{
+        readonly entity: Schema.Literal<Target["name"]>;
+        readonly id: import("foldkit-entity").IdSchemaOf<Target>;
+      }>> : T_1 extends Selection<any, any, infer S_2 extends Schema.Constraint, string> ? S_2 : Schema.Struct<{
+        readonly entity: Schema.Literal<Target["name"]>;
+        readonly id: import("foldkit-entity").IdSchemaOf<Target>;
+      }> : never : never : never : never : never; }>, Schema.Struct.TypeMutableKeys<{ readonly [K in keyof import("foldkit-entity").WrittenSpec<Members> & keyof E["members"]]: E["members"][K] extends (infer T) ? T extends E["members"][K] ? T extends import("foldkit-entity").EntityDerived<any, any, infer S extends Schema.Constraint, {
+        readonly _tag: "Count";
+        readonly relation: import("foldkit-entity").EntityRelation<string, string, AnyEntity, "one", boolean>;
+      } | {
+        readonly _tag: "Exists";
+        readonly relation: import("foldkit-entity").EntityRelation<string, string, AnyEntity, "one", boolean>;
+        readonly viewer: import("foldkit-entity").EntityRelation<string, string, AnyEntity, "one", boolean>;
+      } | {
+        readonly _tag: "Supplied";
+        readonly predict: Option.Option<import("foldkit-entity").Predict>;
+        readonly forbids: Option.Option<import("foldkit-entity").Forbids>;
+      }> | import("foldkit-entity").EntityField<any, any, infer S extends Schema.Constraint> ? S : T extends import("foldkit-entity").EntityRelation<any, any, infer Target extends AnyEntity, infer C extends import("foldkit-entity").Cardinality, infer Optional extends boolean> ? import("foldkit-entity").WrittenSpec<Members>[K] extends (infer T_1) ? T_1 extends import("foldkit-entity").WrittenSpec<Members>[K] ? T_1 extends SelectionPage<any, infer S_1 extends Schema.Constraint> ? Schema.Struct<{
+        readonly items: Schema.$Array<S_1>;
+        readonly hasNext: Schema.Boolean;
+        readonly hasPrevious: Schema.Boolean;
+      }> : C extends "many" ? Schema.$Array<T_1 extends Selection<any, any, infer S_2 extends Schema.Constraint, string> ? S_2 : Schema.Struct<{
+        readonly entity: Schema.Literal<Target["name"]>;
+        readonly id: import("foldkit-entity").IdSchemaOf<Target>;
+      }>> : Optional extends true ? Schema.NullOr<T_1 extends Selection<any, any, infer S_2 extends Schema.Constraint, string> ? S_2 : Schema.Struct<{
+        readonly entity: Schema.Literal<Target["name"]>;
+        readonly id: import("foldkit-entity").IdSchemaOf<Target>;
+      }>> : T_1 extends Selection<any, any, infer S_2 extends Schema.Constraint, string> ? S_2 : Schema.Struct<{
+        readonly entity: Schema.Literal<Target["name"]>;
+        readonly id: import("foldkit-entity").IdSchemaOf<Target>;
+      }> : never : never : never : never : never; }>>>>;
       sync: Update.Step<Root, never, never>;
       /**
        * Wraps the application's `update` so `sync` runs after every Message:
@@ -673,5 +570,5 @@ export declare const Crud: {
     };
   };
 };
-export type { DisplayColumn, DisplayKind, DisplayWords, SortState, SortedColumn };
-//# sourceMappingURL=index.d.mts.map
+export { Display, type DisplayColumn, type DisplayKind, type DisplayWords, Sort, type SortState, type SortedColumn };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"mappings":"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"}