@object-ui/components 17.6.0 → 18.0.0

package/dist/custom/filter-builder.d.ts

@@ -1,3 +1,4 @@
+import { FilterBuilderCondition as AuthoredFilterBuilderCondition, FilterGroup as AuthoredFilterGroup } from '@object-ui/types';
 /**
  * ObjectUI
  * Copyright (c) 2024-present ObjectStack Inc.
@@ -16,22 +17,53 @@ import * as React from "react";
  * and `operator` here is the builder's own dropdown vocabulary
  * (`FILTER_BUILDER_OPERATORS`), not the spec's `$`-tokens.
  *
- * `@object-ui/types` already renamed its identical concept to
- * `FilterBuilderCondition` (objectui#3068); this is the same thing, so it takes
- * the same name rather than inventing a second dialect. Note the same name is
- * NOT the right answer everywhere: `@object-ui/app-shell`'s `FilterCondition`
- * really was the spec's ObjectQL AST and was re-exported (objectui#3169).
+ * DERIVED from `@object-ui/types`' `FilterBuilderCondition` (objectui#9306).
+ * That declaration is the one name authority for the row; this one takes every
+ * member from it (`id`, required since objectui#8415, and `field`) and restates
+ * exactly two, each a named extension:
+ *
+ *   - `operator` — {@link FilterBuilderOperator}: the protocol's ids, which is
+ *     what the authority declares, plus the opt-in `exists` / `notExists` the
+ *     protocol has no member for (objectui#9559 ruling B keeps them opt-in and
+ *     unfolded). It was `string`, which let a caller hand the builder an id no
+ *     dropdown entry can hold.
+ *   - `value` — REQUIRED and narrowed to the scalar-or-list union this builder
+ *     edits, where the authority declares `value?: any`. Every exported helper
+ *     below that takes a row's value (`reshapeFilterValue`, `retypeFilterValue`,
+ *     `narrowFilterValueToOptions`, …) is typed on this member, so `any` here
+ *     would switch their checking off in silence.
+ *
+ * Its own NAME, not the authority's (objectui#6349, batch 12). Under the
+ * authority's name this was a second declaration of `FilterBuilderCondition`
+ * with a different shape: the two are assignable in neither direction (the
+ * operator blocks one way, the value's requiredness the other), so an
+ * auto-import picked one of two rows by package. `FilterBuilderCondition` now
+ * means the authored row in `@object-ui/types` only, and this specialisation
+ * is named for the builder that edits it.
  */
-export interface FilterBuilderCondition {
-    id: string;
-    field: string;
-    operator: string;
+export interface FilterBuilderRow extends Omit<AuthoredFilterBuilderCondition, "operator" | "value"> {
+    operator: FilterBuilderOperator;
     value: string | number | boolean | (string | number | boolean)[];
 }
-export interface FilterGroup {
-    id: string;
-    logic: "and" | "or";
-    conditions: FilterBuilderCondition[];
+/**
+ * The group the FilterBuilder edits: one `logic` over FLAT rows.
+ *
+ * DERIVED from `@object-ui/types`' `FilterGroup` like the row above
+ * (objectui#9306), and named apart from it for the same reason
+ * (objectui#6349, batch 12): `FilterGroup` means the authored group only. Only
+ * `conditions` is restated, to hold THIS package's row; `id` and `logic` are
+ * the authority's own. So `id` is OPTIONAL here, as it is there: nothing in
+ * this builder reads a group's `id`, `onChange` hands back whatever group the
+ * host passed (an id-less group comes back id-less), and only `EMPTY_GROUP`
+ * invents one. The `id: string` this package used to declare described a
+ * group the builder never guaranteed.
+ *
+ * `conditions` is flat because the builder is: it draws each entry as one row
+ * and has no control that creates a group. The authority retired nested
+ * sub-groups in the same change and its zod mirror refuses one by name.
+ */
+export interface FilterBuilderRowGroup extends Omit<AuthoredFilterGroup, "conditions"> {
+    conditions: FilterBuilderRow[];
 }
 export interface FilterBuilderProps {
     fields?: Array<{
@@ -49,8 +81,8 @@ export interface FilterBuilderProps {
         /** ID field on the referenced object (defaults to "id") */
         idField?: string;
     }>;
-    value?: FilterGroup;
-    onChange?: (value: FilterGroup) => void;
+    value?: FilterBuilderRowGroup;
+    onChange?: (value: FilterBuilderRowGroup) => void;
     className?: string;
     showClearAll?: boolean;
     /**
@@ -69,34 +101,34 @@ declare const defaultOperators: readonly [{
     readonly value: "equals";
     readonly label: "Equals";
 }, {
-    readonly value: "notEquals";
+    readonly value: "not_equals";
     readonly label: "Does not equal";
 }, {
     readonly value: "contains";
     readonly label: "Contains";
 }, {
-    readonly value: "containsCaseInsensitive";
+    readonly value: "icontains";
     readonly label: "Contains (ignore case)";
 }, {
-    readonly value: "notContains";
+    readonly value: "not_contains";
     readonly label: "Does not contain";
 }, {
-    readonly value: "isEmpty";
+    readonly value: "is_empty";
     readonly label: "Is empty";
 }, {
-    readonly value: "isNotEmpty";
+    readonly value: "is_not_empty";
     readonly label: "Is not empty";
 }, {
-    readonly value: "greaterThan";
+    readonly value: "greater_than";
     readonly label: "Greater than";
 }, {
-    readonly value: "lessThan";
+    readonly value: "less_than";
     readonly label: "Less than";
 }, {
-    readonly value: "greaterOrEqual";
+    readonly value: "greater_than_or_equal";
     readonly label: "Greater than or equal";
 }, {
-    readonly value: "lessOrEqual";
+    readonly value: "less_than_or_equal";
     readonly label: "Less than or equal";
 }, {
     readonly value: "before";
@@ -111,19 +143,19 @@ declare const defaultOperators: readonly [{
     readonly value: "in";
     readonly label: "In";
 }, {
-    readonly value: "notIn";
+    readonly value: "not_in";
     readonly label: "Not in";
 }, {
-    readonly value: "startsWith";
+    readonly value: "starts_with";
     readonly label: "Starts with";
 }, {
-    readonly value: "endsWith";
+    readonly value: "ends_with";
     readonly label: "Ends with";
 }, {
-    readonly value: "isNull";
+    readonly value: "is_null";
     readonly label: "Is null";
 }, {
-    readonly value: "isNotNull";
+    readonly value: "is_not_null";
     readonly label: "Is not null";
 }, {
     readonly value: "exists";
@@ -137,30 +169,79 @@ declare const defaultOperators: readonly [{
  * hold, derived from the operators it actually renders. Includes the opt-in
  * ids: they are drawable, just not offered unconditionally.
  *
- * Exported because several translation tables map an external vocabulary
- * (the spec's `VIEW_FILTER_OPERATORS`, Mongo `$`-tokens) *onto* this one, and
- * a value that is not in this list produces a condition row whose operator
- * select has nothing to select. Those tables assert against this export
- * rather than restating it, so adding an operator here is the only edit
- * needed to widen them.
+ * Since objectui#9306 these ARE the protocol's ids — the twenty members of the
+ * spec's `VIEW_FILTER_OPERATORS`, plus the opt-in `exists` / `notExists` the
+ * protocol has no member for — so a table that maps the spec's vocabulary onto
+ * this one is an identity over the twenty. It is still exported because those
+ * tables, and the parity pins over them, assert against this list rather than
+ * restating it: a value that is not in it produces a condition row whose
+ * operator select has nothing to select.
+ */
+export declare const FILTER_BUILDER_OPERATORS: ("in" | "starts_with" | "ends_with" | "contains" | "equals" | "not_equals" | "greater_than" | "greater_than_or_equal" | "less_than" | "less_than_or_equal" | "before" | "after" | "not_in" | "not_contains" | "icontains" | "between" | "is_null" | "is_not_null" | "is_empty" | "is_not_empty" | "exists" | "notExists")[];
+/**
+ * An operator id the FilterBuilder can render: the spec's `ViewFilterOperator`
+ * plus the two opt-in existence ids (objectui#9306). A type-level pin in
+ * `filter-builder-protocol-ids-9306.test.tsx` holds it EQUAL to that union, so
+ * a protocol member added upstream fails to compile there until the dropdown
+ * offers it.
  */
-export declare const FILTER_BUILDER_OPERATORS: ("endsWith" | "startsWith" | "in" | "after" | "equals" | "notEquals" | "contains" | "containsCaseInsensitive" | "notContains" | "isEmpty" | "isNotEmpty" | "greaterThan" | "lessThan" | "greaterOrEqual" | "lessOrEqual" | "before" | "between" | "notIn" | "isNull" | "isNotNull" | "exists" | "notExists")[];
-/** An operator id the FilterBuilder can render. */
 export type FilterBuilderOperator = (typeof defaultOperators)[number]['value'];
 /**
- * Operator ids for which this builder renders NO value input — so "no value"
- * is the row's FINISHED state, not an unfinished one (objectui#4744).
+ * The spelling a stored operator is READ as — the protocol id for every
+ * spelling the spec or this builder ever wrote (objectui#9306).
+ *
+ * The ruling this executes: camelCase is the deprecated alias form
+ * (objectui#7993), accepted on read and rewritten on write. So a filter stored
+ * as `{ operator: 'greaterOrEqual' }` keeps loading — it is folded here, through
+ * the spec's own `normalizeFilterOperator`, onto `greater_than_or_equal` — and
+ * the builder holds and emits that canonical id from then on, so the next write
+ * the author makes stores it. A lossless conversion on the read side, ⛔ not a
+ * second vocabulary: nothing this builder EMITS is ever a camelCase id.
+ *
+ * An id nothing folds (`exists`, `notExists`, a spelling from no vocabulary)
+ * comes back unchanged, exactly as the spec's normalizer returns it: inventing
+ * a mapping for a word the protocol does not contain would be a claim, not a
+ * repair.
+ *
+ * ⚠️ One guard on the spec's answer, and only because the builder now STORES
+ * what this returns (before objectui#9306 the fold was used for comparison
+ * only). `normalizeFilterOperator` is declared to return a string, but it
+ * looks the spelling up on a plain object, so an `Object.prototype` key comes
+ * back as whatever the prototype holds — `'constructor'` returns the `Object`
+ * function, measured on `@objectstack/spec` 17.4.0. Held in a row and written
+ * back, that would drop the row's operator on serialisation. A non-string
+ * answer is therefore treated as "nothing folds" and the spelling is kept;
+ * the defect itself belongs to the spec and is reported there, not patched
+ * around here in any other way.
+ */
+export declare function normalizeFilterBuilderOperator(operator: string): string;
+/**
+ * Operator ids — this dropdown's own ids, which are the protocol's canonical
+ * spellings since objectui#9306 — for which this builder renders no value
+ * input, so "no value" is the row's FINISHED state, not an unfinished one
+ * (objectui#4744).
  *
  * This is the source of truth for that distinction, and it lives here because
- * this component is the thing that decides it: `needsValueInput` below is
- * defined as the complement of this set, so the two cannot say different
- * things. Every consumer that has to tell a complete value-less row from a
- * half-filled one reads it FROM here rather than restating it:
+ * this component is the thing that decides it. But membership here is not the
+ * whole question: `needsValueInput` below asks it of the row's spelling AFTER
+ * {@link normalizeFilterBuilderOperator} (objectui#9302), so the gate answers
+ * "no value" for spellings that are NOT members — the deprecated camelCase ids
+ * a stored filter may still carry, and the alias rows the spec publishes for
+ * those same operators. A consumer holding a spelling that did not come from
+ * this dropdown must therefore fold it before asking, and fold this set's own
+ * members through the same normalizer too — the spec's `normalizeFilterOperator`
+ * is the identity on them, so that fold costs nothing and keeps the consumer
+ * correct whichever vocabulary this set is written in. How much wider the
+ * gate's preimage is is NOT restated here: the pin
+ * `filter-builder-valueless-canonical-spelling-9302.test.tsx` walks the
+ * spec's two published tables and names every row it measures, which is the
+ * only form of that answer that moves when those tables do (AGENTS.md #9).
+ *
+ * Every consumer that has to tell a complete value-less row from a half-filled
+ * one reads the membership FROM here rather than restating it:
  *
  *   - `plugin-list`'s `convertFilterGroupToAST` — what the live grid QUERIES;
- *   - `app-shell`'s `foldFilterGroupToSpecRules` — what a saved view PERSISTS
- *     (its `VALUELESS_FILTER_OPERATORS` is this set plus the canonical spec
- *     spellings, which only that layer sees).
+ *   - `app-shell`'s `foldFilterGroupToSpecRules` — what a saved view PERSISTS.
  *
  * Placement is forced by the dependency graph — `app-shell` depends on
  * `plugin-list` depends on this package, so this is the only module all three
@@ -168,11 +249,12 @@ export type FilterBuilderOperator = (typeof defaultOperators)[number]['value'];
  * states is a fact about what this dropdown draws.
  *
  * Why it exists at all: each consumer used to keep its own copy, and the
- * live-grid copy listed only `isEmpty`/`isNotEmpty`. A fresh row is seeded
- * `{ operator: 'equals', value: '' }` and the operator dropdown preserves
- * `value`, so picking **Is null** as the first action left `value: ''` — the
- * grid read that as an unfinished row, dropped it, and applied NO filter at
- * all while the panel showed one. Silent, and every record came back.
+ * live-grid copy listed only the two empty-string operators. A fresh row is
+ * seeded `{ operator: 'equals', value: '' }` and the operator dropdown
+ * preserves `value`, so picking **Is null** as the first action left
+ * `value: ''` — the grid read that as an unfinished row, dropped it, and
+ * applied NO filter at all while the panel showed one. Silent, and every
+ * record came back.
  *
  * `exists` / `notExists` stay listed even though `OPT_IN_OPERATORS` withholds
  * them from most consumers (objectui#4736): the builder still draws them
@@ -193,13 +275,14 @@ export declare const VALUELESS_FILTER_BUILDER_OPERATORS: ReadonlySet<string>;
  */
 export type FilterValueArity = "scalar" | "list" | "pair";
 /**
- * Which value shape `operator` takes, in EITHER dialect.
+ * Which value shape `operator` takes, whichever spelling it arrives in.
  *
- * The argument is folded through the spec's own `normalizeFilterOperator`
- * first, so the builder's camelCase dropdown ids (`notIn`) and the canonical
- * spellings a stored rule carries (`not_in`) land on the same answer. That
- * fold is the whole point: one vocabulary, declared upstream, consulted here —
- * not a second local dialect that has to be kept in sync by hand.
+ * The argument is folded through {@link normalizeFilterBuilderOperator} — the
+ * spec's own `normalizeFilterOperator` plus the builder's one unfolded legacy
+ * id — first, so the canonical id this dropdown emits (`not_in`) and the
+ * deprecated alias a stored filter may still carry (`notIn`) land on the same
+ * answer. That fold is the whole point: one vocabulary, declared upstream,
+ * consulted here — not a second local dialect kept in sync by hand.
  *
  * @internal exported for tests
  */
@@ -224,13 +307,13 @@ export declare function filterValueArity(operator: string): FilterValueArity;
  *
  * @internal exported for tests
  */
-export declare function reshapeFilterValue(value: FilterBuilderCondition["value"], nextOperator: string): FilterBuilderCondition["value"];
+export declare function reshapeFilterValue(value: FilterBuilderRow["value"], nextOperator: string): FilterBuilderRow["value"];
 /**
  * The operator a row keeps after its FIELD is changed, given the operators the
  * NEW field offers (objectui#4768).
  *
  * Each field type has its own operator bucket, and the buckets are not nested:
- * a `select` column offers `in` / `notIn`, a `text` column does not. Changing
+ * a `select` column offers `in` / `not_in`, a `text` column does not. Changing
  * the field used to write `{ field }` alone, so the row's operator survived
  * into a bucket that no longer contains it — `in` on a text column. The Radix
  * trigger then had nothing to render (its `SelectValue` matches against the
@@ -243,22 +326,80 @@ export declare function reshapeFilterValue(value: FilterBuilderCondition["value"
  * entry (`equals` for every bucket this builder draws), and the caller then
  * re-shapes the value for that operator's family.
  *
- * Membership is decided CANONICALLY, through the spec's own
- * `normalizeFilterOperator` — the same fold `filterValueArity` uses. A stored
- * rule can reach this builder spelled `not_in` while the dropdown lists the
- * alias `notIn`; those are one operator, so a select→lookup switch must not
- * silently rewrite the author's operator to `equals` just because the two
- * spellings differ. The fold is safe to compare through because it is
- * INJECTIVE over this builder's vocabulary — all 22 ids in `defaultOperators`
- * normalize to 22 distinct canonical operators, pinned in
- * `filter-builder-field-switch-operator.test.tsx` — so no two OFFERED
- * operators can ever collapse onto one another.
+ * Membership is decided CANONICALLY, through
+ * {@link normalizeFilterBuilderOperator} — the same fold `filterValueArity`
+ * uses. A caller can hand this helper a row spelled with the deprecated alias
+ * `notIn` while the dropdown lists the protocol id `not_in`; those are one
+ * operator, so a select→lookup switch must not silently rewrite the author's
+ * operator to `equals` just because the two spellings differ. The fold is safe
+ * to compare through because it is INJECTIVE over this builder's vocabulary —
+ * all 22 ids in `defaultOperators` normalize to 22 distinct canonical
+ * operators, pinned in `filter-builder-field-switch-operator.test.tsx` — so no
+ * two OFFERED operators can ever collapse onto one another.
  *
  * @internal exported for tests
  */
 export declare function reconcileOperatorForField(operator: string, offeredOperators: ReadonlyArray<{
     value: string;
 }>): string;
+/**
+ * The offered id the operator trigger COMPARES against — the last site in this
+ * component that read the operator literally instead of through the spec's
+ * fold (objectui#7561).
+ *
+ * Radix matches `SelectValue` against the `SelectItem`s actually MOUNTED, and
+ * the mounted ids are this builder's own vocabulary — the protocol's canonical
+ * ids since objectui#9306 (they were camelCase when this helper was written). A
+ * row can hold the operator under another spelling of the SAME operator and
+ * still be perfectly valid:
+ *
+ *   - a deprecated camelCase alias such as `greaterThan`, which a filter saved
+ *     before objectui#9306 still carries;
+ *   - the spec's alias table `gt` / `lt` / `eq`, which three schema-catalog
+ *     entries author today.
+ *
+ * When this helper was written the mounted id was `greaterThan` and the stored
+ * spelling `greater_than`; neither matched the other literally, so the trigger
+ * drew BLANK over a row that filtered correctly — the user's own operator,
+ * invisible and unreachable.
+ * Everywhere the operator's MEANING matters this component already folds first
+ * ({@link filterValueArity}, {@link reconcileOperatorForField}); this was the
+ * one place it did not, and that omission — not the vocabulary divergence — is
+ * what produced the blank.
+ *
+ * So the comparison is made canonically and the MOUNTED spelling is handed to
+ * the trigger. Three things this deliberately does NOT do, each of them a
+ * separate ruling (objectui#7561):
+ *
+ *   1. it does not rewrite `condition.operator` — the row keeps the spelling it
+ *      arrived with, exactly as {@link reconcileOperatorForField} keeps it, and
+ *      nothing is written back on render. (Since objectui#9306 the BUILDER
+ *      folds a row's spelling once, at its read boundary — see
+ *      {@link normalizeFilterBuilderOperator} — so the rows it renders already
+ *      hold protocol ids. This helper still folds both sides, because it is
+ *      exported and its caller's rows need not have come through that
+ *      boundary.)
+ *   2. it does not mount a new `SelectItem`, so the vocabulary the dropdown
+ *      EMITS is byte-identical — contrast the value select above, where
+ *      objectui#4874 ruling C mounts the outside-options value as its own
+ *      option. That answer is right there and wrong here: the value's domain is
+ *      the author's data, while the operator's domain is a declared vocabulary,
+ *      and mounting a foreign spelling would admit a second one;
+ *   3. it does not widen what any schema ACCEPTS.
+ *
+ * Safe to compare through because the fold is INJECTIVE over this builder's
+ * vocabulary — all 22 ids in `defaultOperators` normalize to 22 distinct
+ * canonical operators, pinned in `filter-builder-field-switch-operator.test.tsx`
+ * — so no two OFFERED operators can collapse onto one another and the match is
+ * unambiguous. An operator no offered id folds onto falls through to the row's
+ * own spelling and still draws blank: inventing a label for a word this
+ * vocabulary does not contain would be a claim, not a repair.
+ *
+ * @internal exported for tests
+ */
+export declare function mountedOperatorValue(operator: string, offeredOperators: ReadonlyArray<{
+    value: string;
+}>): string;
 /**
  * Re-TYPE a row's `value` for the field it is being changed TO — the type
  * question, standing beside {@link reshapeFilterValue}'s shape question
@@ -285,7 +426,7 @@ export declare function reconcileOperatorForField(operator: string, offeredOpera
  *   - `scalar` — converted, or `""`.
  *   - `list` — converted ENTRY BY ENTRY, keeping the ones that carry:
  *     `["42", "acme"]` → `[42]`, and `[]` when none do. Reachable today only
- *     between the two buckets that offer `in`/`notIn` (`select` ↔ `lookup`),
+ *     between the two buckets that offer `in`/`not_in` (`select` ↔ `lookup`),
  *     which are both text-family, so the conversion is the identity there; it
  *     is written for the family the operator lands in rather than for today's
  *     buckets, and pinned directly on this helper.
@@ -296,7 +437,7 @@ export declare function reconcileOperatorForField(operator: string, offeredOpera
  *
  * @internal exported for tests
  */
-export declare function retypeFilterValue(value: FilterBuilderCondition["value"], fieldType: string | undefined, operator: string): FilterBuilderCondition["value"];
+export declare function retypeFilterValue(value: FilterBuilderRow["value"], fieldType: string | undefined, operator: string): FilterBuilderRow["value"];
 /** The shape of a `fields` entry that the option-domain helpers below read. */
 type OptionBearingField = {
     type?: string;
@@ -344,7 +485,7 @@ type OptionBearingField = {
  *
  * @internal exported for tests
  */
-export declare function narrowFilterValueToOptions(value: FilterBuilderCondition["value"], field: OptionBearingField | undefined, operator: string): FilterBuilderCondition["value"];
+export declare function narrowFilterValueToOptions(value: FilterBuilderRow["value"], field: OptionBearingField | undefined, operator: string): FilterBuilderRow["value"];
 /**
  * Is this row's value FINISHED for the operator it carries — the arity-aware
  * reading of "the user has filled this in" (objectstack#8815).
@@ -396,10 +537,17 @@ export declare function narrowFilterValueToOptions(value: FilterBuilderCondition
  *
  * @internal exported for tests
  */
-export declare function isFilterValueComplete(operator: string, value: FilterBuilderCondition["value"] | undefined | null): boolean;
+export declare function isFilterValueComplete(operator: string, value: FilterBuilderRow["value"] | undefined | null): boolean;
 /**
- * The operators the dropdown offers for a field of `fieldType`, given the
- * opt-in ids this instance was granted.
+ * The operators a row on a field of `fieldType` can HOLD, given the opt-in ids
+ * this instance was granted — every operator the dropdown can draw for it.
+ *
+ * What the dropdown OFFERS a fresh choice is this set minus the nullness pair
+ * on a type that cannot tell "empty" from "null" (objectui#11810, see
+ * {@link offeredOperatorsForRow}). That narrowing is deliberately NOT applied
+ * here: callers outside this file (`app-shell`'s dataset read-back,
+ * `plugin-list`'s parity pin) ask "can the builder hold this row", and a
+ * stored `is_null` on a `select` column still can.
  *
  * A pure function rather than a closure so the selection rule — and above all
  * the {@link OPT_IN_OPERATORS} gate, whose whole job is to keep an operator OFF
@@ -425,9 +573,9 @@ interface LookupValuePickerProps {
         displayField?: string;
         idField?: string;
     };
-    value: FilterBuilderCondition["value"];
+    value: FilterBuilderRow["value"];
     multiple: boolean;
-    onChange: (value: FilterBuilderCondition["value"]) => void;
+    onChange: (value: FilterBuilderRow["value"]) => void;
 }
 declare function LookupValuePicker({ field, value, multiple, onChange }: LookupValuePickerProps): React.JSX.Element;
 export { FilterBuilder, LookupValuePicker };

package/dist/custom/grouping-editor.d.ts

@@ -47,5 +47,9 @@ export interface GroupingEditorProps {
  * Field options are filtered per row so a field can only appear in one level
  * at a time. The current row's selected field stays in its own dropdown so the
  * user sees the active selection.
+ *
+ * The field selector is the shared `Select` primitive, the control the Filter
+ * and Sort panels beside this one pick a field with, so the three panels look
+ * and behave alike (objectui#11865). It used to be a browser-native `<select>`.
  */
 export declare function GroupingEditor({ value, onChange, fieldOptions, maxLevels, className, labels, }: GroupingEditorProps): React.JSX.Element;

package/dist/custom/horizontal-overflow.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+export interface HorizontalOverflowBoxProps extends React.HTMLAttributes<HTMLDivElement> {
+    /**
+     * Where the shadow is drawn: `edge` (default) overlays the box's right edge;
+     * `pinned` leaves it to the right-pinned cells inside, which carry
+     * `PINNED_RIGHT_SEAM_SHADOW_CLASSES` (`./use-horizontal-overflow`).
+     */
+    seam?: 'edge' | 'pinned';
+    /** Classes for the positioned wrapper around the scrolling box. */
+    outerClassName?: string;
+}
+/**
+ * A horizontally scrolling box with the shared overflow affordance. The
+ * scrolling element is the inner `div` (`className`, the ref and every other
+ * prop land on it); the edge shadow is its sibling, so it never scrolls away
+ * with the content.
+ */
+export declare const HorizontalOverflowBox: React.ForwardRefExoticComponent<HorizontalOverflowBoxProps & React.RefAttributes<HTMLDivElement>>;

package/dist/custom/index.d.ts

@@ -24,5 +24,8 @@ export * from './shimmer-skeleton.js';
 export * from './RecordTitleChip.js';
 export * from './refresh-indicator.js';
 export * from './view-states.js';
+export * from './empty-state-link.js';
 export * from './mobile-dialog-content.js';
-export * from './export-progress-dialog.js';
+export * from './dialog-viewport-gutter.js';
+export { HorizontalOverflowBox, type HorizontalOverflowBoxProps } from './horizontal-overflow.js';
+export { PINNED_RIGHT_SEAM_SHADOW_CLASSES } from './use-horizontal-overflow.js';

package/dist/custom/item.d.ts

@@ -18,7 +18,7 @@ declare function Item({ className, variant, size, asChild, ...props }: React.Com
     asChild?: boolean;
 }): React.JSX.Element;
 declare const itemMediaVariants: (props?: ({
-    variant?: "image" | "default" | "icon" | null | undefined;
+    variant?: "default" | "icon" | "image" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
 declare function ItemMedia({ className, variant, ...props }: React.ComponentProps<"div"> & VariantProps<typeof itemMediaVariants>): React.JSX.Element;
 declare function ItemContent({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;

package/dist/custom/kbd.d.ts

@@ -6,5 +6,5 @@
  * LICENSE file in the root directory of this source tree.
  */
 declare function Kbd({ className, ...props }: React.ComponentProps<"kbd">): import("react").JSX.Element;
-declare function KbdGroup({ className, ...props }: React.ComponentProps<"div">): import("react").JSX.Element;
+declare function KbdGroup({ className, ...props }: React.ComponentProps<"kbd">): import("react").JSX.Element;
 export { Kbd, KbdGroup };

package/dist/custom/mobile-dialog-content.d.ts

@@ -43,5 +43,26 @@ type InteractOutsideHandler = NonNullable<React.ComponentPropsWithoutRef<typeof
  * plain backdrop click with no flyout open.
  */
 export declare function usePopperAwareInteractOutside(onInteractOutside?: InteractOutsideHandler): InteractOutsideHandler;
-export declare const MobileDialogContent: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export type MobileDialogContentProps = React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content> & {
+    /**
+     * Whether the dialog draws its own close (X) button. Defaults to `true`;
+     * `false` leaves it out of the DOM entirely (objectui#11061), the same
+     * switch upstream Shadcn's `DialogContent` names `showCloseButton`. The
+     * dialog stays dismissable without it: Escape and a backdrop click still
+     * reach the `Dialog`'s `onOpenChange(false)` through Radix, so a caller that
+     * hides the X only has to keep whatever explicit way out its body offers.
+     */
+    showCloseButton?: boolean;
+};
+export declare const MobileDialogContent: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    /**
+     * Whether the dialog draws its own close (X) button. Defaults to `true`;
+     * `false` leaves it out of the DOM entirely (objectui#11061), the same
+     * switch upstream Shadcn's `DialogContent` names `showCloseButton`. The
+     * dialog stays dismissable without it: Escape and a backdrop click still
+     * reach the `Dialog`'s `onOpenChange(false)` through Radix, so a caller that
+     * hides the X only has to keep whatever explicit way out its body offers.
+     */
+    showCloseButton?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
 export {};