@object-ui/core 17.3.0 → 17.6.0

package/dist/evaluator/rowPredicateCanon.js

@@ -0,0 +1,208 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * The row-predicate spelling CANON, and the Phase-1 deprecation warning for the
+ * two spellings that are not it (objectui#5330).
+ *
+ * ## The canon (maintainer ruling, 2026-08-20 — option B)
+ *
+ * A row predicate — `visible` / `disabled` / `enabled` on an action renderer, a
+ * row scope, a `record:alert` — binds the row THREE ways today: canonical
+ * `record.status`, bare shorthand `status`, and legacy `data.status`
+ * (objectui#4075 / PR #4079 bound all four action renderers all three ways to
+ * restore consistency, deliberately without deciding which of them is
+ * CONTRACT). This module is where that decision now lives:
+ *
+ * > **The canon is `record.*`.** The bare shorthand and `data.*` are
+ * > client-side tolerances in a deprecation window, kept because stored
+ * > metadata carries them, warned about here, and removable only after a
+ * > stored-metadata survey sizes the window (⛔ no removal before the survey).
+ *
+ * It mirrors the objectstack#7917 option-② precedent for the identical shape (a
+ * renderer tolerance quietly becoming a second de-facto contract — AGENTS.md
+ * #0.1), whose objectui half is `utils/dashboard-filters.ts`' bare-string
+ * `options` shorthand: same three phases, same reason the warning is not
+ * decoration (ADR-0078 — nothing silently inert; a tolerance nothing ever
+ * reports can never be retired, because nothing would ever show that the last
+ * document carrying it is gone).
+ *
+ * ## The canon states the SERVER's accept set, not this client's
+ *
+ * The ruling made that the dev's first measurement, because a canon that only
+ * describes the renderer would be the very thing it exists to end. Measured
+ * against `@objectstack/formula@17.1.0` — the engine the server evaluates with,
+ * and the one `fieldRules.ts` already delegates to:
+ *
+ * | spelling | server runtime (`buildScope` + `celEngine`) | server authoring oracle |
+ * |---|---|---|
+ * | `record.status` | ✅ `{ ok: true, value: true }` | ✅ accepted |
+ * | bare `status`   | ❌ `Unknown variable: status` | ❌ refused (`'status'`) |
+ * | `data.status`   | ❌ `Unknown variable: data`   | ⚠️ **silently accepted** |
+ *
+ * `buildScope({ record })` mounts exactly `['record']` — `data` is never bound
+ * and the row's fields are never flattened to top level. So **the server
+ * accepts `record.*` and nothing else**; both other spellings fault there. The
+ * three-way binding is a client tolerance with no server counterpart, which is
+ * precisely why it is the client's job to warn.
+ *
+ * ⚠️ The `data.*` row is the dangerous one and the reason this warning exists
+ * at all. `data` IS in `@objectstack/formula`'s `SCOPE_ROOTS`, so the server's
+ * bare-identifier oracle waves `data.status` through — that list is a
+ * deliberately generous "never faults" LINT BASELINE, not the runtime accept
+ * set. A `data.*` row predicate therefore passes every authoring gate the
+ * platform has and then binds nothing at runtime: it is not an error, it is a
+ * constant `false`, and a `visible` that is constantly false is a button that
+ * silently never appears. That is the #4075 fail-closed family's exact
+ * signature, and this client is the only layer positioned to catch it.
+ *
+ * ## `data.*` is DEPRECATED HERE, not everywhere — the canon is layer-scoped
+ *
+ * `data` is the CANONICAL root one layer over, in a metadata-editing form (the
+ * row under edit): objectstack's `CANONICAL_ROOT_BY_LAYER` reads
+ * `{ runtime: 'record', metadata: 'data' }` (ADR-0089 D3), and objectui's own
+ * `app-shell` metadata-admin `SchemaForm` binds `{ data: row }` on purpose. So
+ * `data.*` is not a legacy alias to be deprecated platform-wide — it is a
+ * WRONG-LAYER paste on a runtime record surface, and only that is what this
+ * module reports. Stating the deprecation unqualified would contradict
+ * ADR-0089 D3 and break the metadata-editing layer's own contract.
+ *
+ * ## Why the detection reuses the server's oracle instead of a regex
+ *
+ * `collectCelRootIdentifiers` and `firstUndeclaredReference` are
+ * `@objectstack/formula` exports — the same two oracles objectstack's
+ * `visibility-bare-identifier` gate uses. Reading roots off the canonical AST
+ * rather than pattern-matching the source is what keeps this from inventing a
+ * second dialect judgement client-side: a string this module cannot parse is
+ * NOT this module's verdict to give (syntax belongs to the gates that own it),
+ * and it stands down rather than guessing.
+ */
+import { collectCelRootIdentifiers, firstUndeclaredReference } from '@objectstack/formula';
+/** The one canonical row-predicate root. */
+export const ROW_PREDICATE_CANONICAL_ROOT = 'record';
+/**
+ * The metadata-editing-form root (ADR-0089 D3). Canonical on THAT layer, and a
+ * wrong-layer paste on a runtime record surface — see the module note.
+ */
+const METADATA_LAYER_ROOT = 'data';
+/**
+ * Detect a non-canonical spelling in ONE row predicate, or `null` when the
+ * predicate is already canonical (or is not this module's verdict to give).
+ *
+ * Deliberately conservative in both arms — every condition below can only
+ * REMOVE a finding, never invent one, because a false deprecation warning sends
+ * an author to rewrite a predicate that was correct:
+ *
+ * - **Unparseable source** → `null`. Syntax is another gate's verdict.
+ * - **Bare shorthand** is reported only when the undeclared identifier is an own
+ *   key of THIS row. That is what makes it unambiguously the #4075 shorthand
+ *   rather than a host-scope global this module cannot see (a deployment key
+ *   that is simply not in `SCOPE_ROOTS` would otherwise read as a bare field).
+ * - **`data.*`** is reported only when the caller confirms `data` names the row
+ *   (`dataNamesRow`). A surface whose `data` is the host scope's own — a
+ *   `rowless` dialog, a metadata-editing form — is a legitimate `data.*` site
+ *   and is left alone.
+ *
+ * Only the FIRST finding is returned, and the bare-shorthand arm is checked
+ * first: it is the arm the server refuses outright (`visibility-bare-identifier`
+ * is an `error` there, while a mis-layered root is a `warning`), so when a
+ * predicate manages both it is the one the author must fix to have anything
+ * evaluate at all.
+ *
+ * @param source       The predicate's CEL text. Callers must have already
+ *                     routed legacy `${…}`-dialect strings elsewhere — in that
+ *                     dialect `data.*` is the NORMAL spelling, and reporting it
+ *                     here would be a false positive on every legacy predicate.
+ * @param row          The row the predicate is bound against.
+ * @param dataNamesRow Whether `data` is bound to that same row on this surface.
+ */
+export function detectNonCanonicalRowSpelling(source, row, dataNamesRow) {
+    if (typeof source !== 'string' || !source.trim())
+        return null;
+    const roots = collectCelRootIdentifiers(source);
+    // Not parseable through the canonical front end — not our verdict.
+    if (!roots || roots.ok !== true)
+        return null;
+    // (1) Bare shorthand — the arm the server refuses outright.
+    const bare = firstUndeclaredReference(source);
+    if (typeof bare === 'string' &&
+        row != null &&
+        typeof row === 'object' &&
+        Object.prototype.hasOwnProperty.call(row, bare)) {
+        return {
+            kind: 'bare-shorthand',
+            identifier: bare,
+            canonical: `${ROW_PREDICATE_CANONICAL_ROOT}.${bare}`,
+        };
+    }
+    // (2) Wrong-layer `data.*` root — silent at runtime on the server.
+    if (dataNamesRow && Array.isArray(roots.roots) && roots.roots.includes(METADATA_LAYER_ROOT)) {
+        return {
+            kind: 'metadata-layer-root',
+            identifier: METADATA_LAYER_ROOT,
+            canonical: ROW_PREDICATE_CANONICAL_ROOT,
+        };
+    }
+    return null;
+}
+/**
+ * Dev-mode gate, matching `utils/dashboard-filters.ts` and `actions/actionKeys.ts`
+ * — a deprecation warning that floods a production console is a warning that
+ * gets muted.
+ */
+const isDev = () => globalThis.process?.env
+    ?.NODE_ENV !== 'production';
+/**
+ * Warn-once memo, keyed by the `(label, predicate source)` pair — the same
+ * identity `warnEvalError` uses, and JSON-encoded for the same reason: the
+ * separator that boundary once used was a raw U+0000, which made the file
+ * carrying it binary to grep (objectstack#5450). Keying on the source alone
+ * would report the first surface carrying a shorthand `status` predicate and
+ * stay silent about every other one; the label is what sends the author to the
+ * right screen.
+ *
+ * Module scope, not per-call: these predicates are re-evaluated on every row of
+ * every render, so per-call state would warn once per frame — the flood the
+ * dedupe exists to prevent.
+ */
+const warnedSpellings = new Set();
+/** Reset the row-predicate spelling warn-once memo. Exported for tests. */
+export function resetRowPredicateCanonWarnings() {
+    warnedSpellings.clear();
+}
+/**
+ * Report a non-canonical row-predicate spelling once, in dev.
+ *
+ * Phase 1 of the objectui#5330 window: the binding is UNCHANGED and every
+ * spelling still resolves — this only says so out loud, so the stored
+ * population stops growing and a later survey has something to count. It is a
+ * warning and deliberately not a refusal: turning it into one would move the
+ * accept/reject set, which this card is explicitly not entitled to do.
+ */
+export function warnNonCanonicalRowSpelling(source, row, dataNamesRow, label) {
+    if (!isDev())
+        return;
+    const finding = detectNonCanonicalRowSpelling(source, row, dataNamesRow);
+    if (!finding)
+        return;
+    const key = JSON.stringify([label ?? '', source, finding.kind]);
+    if (warnedSpellings.has(key))
+        return;
+    warnedSpellings.add(key);
+    const where = label ? ` (${label})` : '';
+    const detail = finding.kind === 'bare-shorthand'
+        ? `it references the bare field ${JSON.stringify(finding.identifier)}; ` +
+            `the server refuses that spelling outright ("Unknown variable: ${finding.identifier}")`
+        : 'it is rooted at `data.`, which is the metadata-editing-form root — on a ' +
+            'record surface the server binds no `data` at all, so the predicate is a ' +
+            'constant false there rather than an error';
+    console.warn(`[object-ui] A row predicate${where} uses a DEPRECATED spelling: ` +
+        `${JSON.stringify(source)} — ${detail}. The canon is \`record.*\` ` +
+        `(objectui#5330, ruled 2026-08-20): write \`${finding.canonical}\`. ` +
+        'This still evaluates here for now; the tolerance retires after a ' +
+        'stored-metadata survey.');
+}

package/dist/index.d.ts

@@ -13,12 +13,17 @@ export * from './registry/PluginScopeImpl.js';
 export * from './registry/WidgetRegistry.js';
 export * from './validation/index.js';
 export * from './builder/schema-builder.js';
+export * from './utils/dom-props.js';
 export * from './utils/filter-converter.js';
 export * from './utils/managedBy.js';
 export * from './utils/extract-records.js';
 export * from './utils/expand-fields.js';
+export * from './utils/retired-field-types.js';
+export * from './utils/unmaterialized-fields.js';
 export * from './utils/column-identity.js';
 export * from './utils/sort-values.js';
+export * from './utils/sort-query.js';
+export * from './utils/resolve-view-id.js';
 export * from './evaluator/index.js';
 export * from './actions/index.js';
 export * from './query/index.js';
@@ -28,7 +33,6 @@ export * from './data-scope/index.js';
 export * from './errors/index.js';
 export * from './utils/debug.js';
 export * from './utils/debug-collector.js';
-export * from './utils/merge-views-into-objects.js';
 export * from './utils/freeze-schema.js';
 export * from './protocols/index.js';
 export * from './styling/scoped-styles.js';
@@ -47,6 +51,8 @@ export * from './utils/dashboard-filters.js';
 export * from './utils/merge-filters.js';
 export * from './utils/compare-to.js';
 export * from './utils/chart-series.js';
+export * from './utils/chart-presentation.js';
+export * from './utils/number-display.js';
 export * from './utils/dataset-format.js';
 export * from './utils/dataset-pivot.js';
 export * from './utils/record-title.js';
@@ -55,3 +61,4 @@ export * from './utils/reference-keys.js';
 export * from './utils/predicate-record.js';
 export * from './utils/predicate-fields.js';
 export * from './utils/normalize-list-view.js';
+export * from './utils/humanize-label.js';

package/dist/index.js

@@ -12,12 +12,27 @@ export * from './registry/PluginScopeImpl.js';
 export * from './registry/WidgetRegistry.js';
 export * from './validation/index.js';
 export * from './builder/schema-builder.js';
+// The DOM pass-through whitelist of the SDUI widget prop contract
+// (objectui#4425 phase 2): a registered widget's host element receives only
+// what `toDomProps` passes — everything else is consumed or dropped.
+// `@object-ui/fields` executes the SAME mechanism against its own declared key
+// list (`pickDomProps`), so there is one judge, not two.
+export * from './utils/dom-props.js';
 export * from './utils/filter-converter.js';
 export * from './utils/managedBy.js';
 export * from './utils/extract-records.js';
 export * from './utils/expand-fields.js';
+// The RETIREMENT gate (objectui#4914, maintainer ruling B). Homed here rather
+// than in `@object-ui/fields` because `@object-ui/components` is one of its six
+// consumers and `fields` depends on `components` — see the module's docblock
+// for why a second copy was not an option. `@object-ui/fields` re-exports every
+// name, so its published surface is unchanged.
+export * from './utils/retired-field-types.js';
+export * from './utils/unmaterialized-fields.js';
 export * from './utils/column-identity.js';
 export * from './utils/sort-values.js';
+export * from './utils/sort-query.js';
+export * from './utils/resolve-view-id.js';
 export * from './evaluator/index.js';
 export * from './actions/index.js';
 export * from './query/index.js';
@@ -27,7 +42,6 @@ export * from './data-scope/index.js';
 export * from './errors/index.js';
 export * from './utils/debug.js';
 export * from './utils/debug-collector.js';
-export * from './utils/merge-views-into-objects.js';
 export * from './utils/freeze-schema.js';
 export * from './protocols/index.js';
 export * from './styling/scoped-styles.js';
@@ -49,6 +63,16 @@ export * from './utils/dashboard-filters.js';
 export * from './utils/merge-filters.js';
 export * from './utils/compare-to.js';
 export * from './utils/chart-series.js';
+// The AUTHORED half of a dataset-bound chart (objectui#4229's data/presentation
+// split), shared by the dashboard widget and the report's embedded chart so the
+// same spec keys are lowered identically on both (objectui#4877).
+export * from './utils/chart-presentation.js';
+// The ONE number-display formatter (objectui#4033) — grouping policy, display
+// locale and the percent convention. It lived in `@object-ui/i18n` until
+// objectui#4576; it is pure, and living above `core` was what kept
+// `dataset-format` below from reaching it (so the two drifted). `@object-ui/i18n`
+// re-exports these names unchanged, so both import paths name the same symbol.
+export * from './utils/number-display.js';
 export * from './utils/dataset-format.js';
 // Pivot lookup-key encoders, shared by every cross-tab renderer so the
 // dashboard widget and the report renderer key their buckets identically
@@ -66,3 +90,9 @@ export * from './utils/predicate-record.js';
 // which the column-derived `$select` never asked the server for.
 export * from './utils/predicate-fields.js';
 export * from './utils/normalize-list-view.js';
+// The single home for the VALUE fallback prettifier (a stored value becomes a
+// display string when nothing resolves it). `@object-ui/fields` and
+// `@object-ui/plugin-charts` each carried a byte-identical private copy;
+// both now re-export this one (objectui#5444). Its docstring also records why
+// it stays distinct from `humanizeFieldKey`, the KEY fallback.
+export * from './utils/humanize-label.js';

package/dist/protocols/DndProtocol.d.ts

@@ -14,7 +14,48 @@
  * @module protocols/DndProtocol
  * @packageDocumentation
  */
-import type { DndConfig, DragItem, DropZone, DragConstraint } from '@object-ui/types';
+/** How a drag is initiated. */
+export type DragHandle = 'element' | 'handle' | 'grip_icon';
+/** The `dropEffect` advertised to assistive technology and DnD libraries. */
+export type DropEffect = 'none' | 'link' | 'move' | 'copy';
+/** Movement constraints applied to a drag. */
+export interface DragConstraint {
+    axis: 'x' | 'y' | 'both';
+    bounds: 'none' | 'parent' | 'viewport';
+    grid?: [number, number];
+}
+/** A draggable item's declaration. */
+export interface DragItem {
+    type: string;
+    label?: string;
+    handle: DragHandle;
+    constraint?: DragConstraint;
+    preview: 'custom' | 'none' | 'element';
+    disabled: boolean;
+    ariaLabel?: string;
+    ariaDescribedBy?: string;
+    role?: string;
+}
+/** A drop target's declaration. */
+export interface DropZone {
+    label?: string;
+    accept: string[];
+    maxItems?: number;
+    highlightOnDragOver: boolean;
+    dropEffect: DropEffect;
+    ariaLabel?: string;
+    ariaDescribedBy?: string;
+    role?: string;
+}
+/** Top-level drag-and-drop configuration. */
+export interface DndConfig {
+    enabled: boolean;
+    dragItem?: DragItem;
+    dropZone?: DropZone;
+    sortable: boolean;
+    autoScroll: boolean;
+    touchDelay: number;
+}
 /** Fully resolved DnD configuration with all defaults applied. */
 export interface ResolvedDndConfig {
     enabled: boolean;

package/dist/protocols/KeyboardProtocol.d.ts

@@ -15,7 +15,37 @@
  * @module protocols/KeyboardProtocol
  * @packageDocumentation
  */
-import type { KeyboardNavigationConfig, KeyboardShortcut, FocusTrapConfig } from '@object-ui/types';
+/** A single keyboard shortcut binding. */
+export interface KeyboardShortcut {
+    key: string;
+    action: string;
+    description?: string;
+    scope: 'global' | 'form' | 'modal' | 'view' | 'list';
+}
+/** Focus trap declaration for a modal-like region. */
+export interface FocusTrapConfig {
+    enabled: boolean;
+    initialFocus?: string;
+    returnFocus: boolean;
+    escapeDeactivates: boolean;
+}
+/** Focus management declaration. */
+export interface FocusManagement {
+    tabOrder: 'manual' | 'auto';
+    skipLinks: boolean;
+    focusVisible: boolean;
+    focusTrap?: FocusTrapConfig;
+    arrowNavigation: boolean;
+}
+/** Top-level keyboard navigation configuration. */
+export interface KeyboardNavigationConfig {
+    shortcuts?: KeyboardShortcut[];
+    focusManagement?: FocusManagement;
+    rovingTabindex: boolean;
+    ariaLabel?: string;
+    ariaDescribedBy?: string;
+    role?: string;
+}
 /** Fully resolved keyboard navigation configuration. */
 export interface ResolvedKeyboardConfig {
     shortcuts: KeyboardShortcut[];

package/dist/protocols/SharingProtocol.d.ts

@@ -15,7 +15,17 @@
  * @module protocols/SharingProtocol
  * @packageDocumentation
  */
-import type { SharingConfig, EmbedConfig } from '@object-ui/types';
+import type { SharingConfig } from '@object-ui/types';
+/** An iframe embed declaration. */
+export interface EmbedConfig {
+    enabled: boolean;
+    allowedOrigins?: string[];
+    width?: string;
+    height?: string;
+    showHeader?: boolean;
+    showNavigation?: boolean;
+    responsive?: boolean;
+}
 /** Fully resolved sharing configuration. */
 export interface ResolvedSharingConfig {
     enabled: boolean;

package/dist/registry/Registry.d.ts

@@ -5,22 +5,30 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-import type { SchemaNode } from '../types/index.js';
+import type { ComponentInput } from '@object-ui/types';
 export type ComponentRenderer<T = any> = T;
-export type ComponentInput = {
-    name: string;
-    type: 'string' | 'number' | 'boolean' | 'enum' | 'array' | 'object' | 'color' | 'date' | 'code' | 'file' | 'slot';
-    label?: string;
-    defaultValue?: any;
-    required?: boolean;
-    enum?: string[] | {
-        label: string;
-        value: any;
-    }[];
-    description?: string;
-    advanced?: boolean;
-    inputType?: string;
-};
+/**
+ * What a registration DECLARES about one authorable prop.
+ *
+ * This is the declaration the component registrations themselves import, so it
+ * is the one an author's manifest is ultimately built from — and it is now
+ * RE-EXPORTED from `@object-ui/types` rather than restated here
+ * (objectui#4972), the disposition objectui#4580 ruled for the identical
+ * shape: *a structural copy would reproduce the defect the moment either side
+ * moved.* This package already depends on `@object-ui/types`, so the edge
+ * exists and adds no cycle, and `src/types/index.ts` re-exports `SchemaNode`
+ * from there the same way.
+ *
+ * The copy this replaces had ALREADY moved, which is why the card is not
+ * hypothetical: it carried nine keys while `base.ts` carried thirteen, so
+ * `min` / `max` / `step` / `placeholder` were missing from *the copy every
+ * registration actually imports*. Those four keys were therefore unwritable at
+ * any real registration — a plain TS error — while `ComponentInputSchema` (the
+ * zod schema) and `ComponentMeta.inputs` both accepted them. The publication
+ * face advertised four keys the authoring face rejected; the divergence was
+ * dormant only because no registration had tried to write one yet.
+ */
+export type { ComponentInput } from '@object-ui/types';
 export type ComponentMeta = {
     label?: string;
     icon?: string;
@@ -43,9 +51,47 @@ export type ComponentMeta = {
      * registry.register('form', FormView, { namespace: 'view', skipFallback: true });
      */
     skipFallback?: boolean;
+    /**
+     * How a HOST must associate its own visible label with what this component
+     * renders (objectui#3961, extended by objectui#4857). Read by the form
+     * renderer; absent ⇒ `'control'`. This closed three-value vocabulary is the
+     * single repo-wide answer to "how does a host learn what a widget will
+     * render" (maintainer ruling of 2026-08-17, joint with objectui#4871) — no
+     * host may keep a local variant of it.
+     *
+     * - `'control'` — the component's outermost rendered element is a LABELABLE
+     *   HTML element (`input` / `textarea` / `select` / `button` / …), so the host
+     *   associates its label the plain way: `<label for>` → the id the host handed
+     *   down. This is the default and covers every single-control widget.
+     * - `'group'` — it is NOT labelable: either a real composite (several inputs
+     *   under one container, e.g. `address`) or a single control that is not a
+     *   labelable element (a `div[role="button"]` dropzone, e.g. `file`). A
+     *   `<label for>` pointing at such an element is inert in HTML — it activates
+     *   nothing and contributes no accessible name (`HTMLLabelElement.control` is
+     *   `null`) — so the host must instead give its label an `id` and hand the
+     *   component `aria-labelledby`, which associates by IDREF and works on any
+     *   element. The COMPONENT consumes those keys on its own surface.
+     * - `'display'` — the rendered surface is a pure display in EVERY state:
+     *   there is no focusable control and the component itself spreads nothing
+     *   (computed / system-generated values such as `formula` / `summary` /
+     *   `auto_number` / `vector`). The host must not emit a `<label for>` at all
+     *   — no labelable element will ever exist for it to reach, in the editable
+     *   state as much as the readonly one — and instead wraps the component's
+     *   output in the host's own container carrying the field id,
+     *   `aria-labelledby`, `aria-describedby` and `role="group"` (the
+     *   objectui#4788 channel, driven by this declaration rather than by
+     *   `readonly` alone). Unlike `'group'`, the WIDGET is not expected to
+     *   consume anything: the host's wrapper is the named surface.
+     *
+     * This is a DECLARATION, not a guess: the host cannot infer it from the DOM a
+     * widget happens to render, and a widget that fails to declare it falls back
+     * to the `'control'` path where the dangling/inert `for` is caught by the
+     * label-association tests (objectui#3952) instead of silently producing an
+     * unlabelled group.
+     */
+    labelling?: 'control' | 'group' | 'display';
     inputs?: ComponentInput[];
     defaultProps?: Record<string, any>;
-    defaultChildren?: SchemaNode[];
     examples?: Record<string, any>;
     isContainer?: boolean;
     resizable?: boolean;

package/dist/theme/ThemeEngine.d.ts

@@ -43,14 +43,6 @@ export declare function generateBorderRadiusVars(borderRadius: NonNullable<Theme
  * Generate CSS custom properties from a Theme's shadow config.
  */
 export declare function generateShadowVars(shadows: NonNullable<Theme['shadows']>): Record<string, string>;
-/**
- * Generate CSS custom properties from a Theme's animation config.
- */
-export declare function generateAnimationVars(animation: NonNullable<Theme['animation']>): Record<string, string>;
-/**
- * Generate CSS custom properties from a Theme's z-index config.
- */
-export declare function generateZIndexVars(zIndex: NonNullable<Theme['zIndex']>): Record<string, string>;
 /**
  * Generate ALL CSS custom properties from a complete Theme.
  * This is the main entry point for theme → CSS conversion.