@dcs-tech/ui 0.2.0 → 0.4.0

package/dist/types/shared-web-ui/src/ArrowKeyFocus/useArrowKeyFocus.d.ts

@@ -1,29 +0,0 @@
-export interface ArrowKeyFocusOptions {
-    /**
-     * Which arrows move. `both` (default) suits a button row: it wraps to a second line on a
-     * narrow screen, and there the user reaches for Up/Down.
-     */
-    orientation?: 'horizontal' | 'vertical' | 'both';
-    /** Stepping past the last item lands on the first, and vice versa. Default true. */
-    wrap?: boolean;
-    /** Home / End jump to the first / last item. Default true. */
-    homeEnd?: boolean;
-}
-export interface ArrowKeyFocusHandlers {
-    /** Spread onto the element that CONTAINS the group (not onto each item). */
-    onKeyDown: (e: React.KeyboardEvent<HTMLElement>) => void;
-}
-/**
- * Arrow keys move focus between the focusable items inside one container — a dialog's
- * button row, a toolbar, a segmented control. Tab and Shift+Tab are untouched: every item
- * stays an ordinary tab stop, the arrows are an addition, not a roving-tabindex replacement.
- *
- * Reads the items from the DOM on each key, so nothing per item has to be registered and
- * the group can be any mix of components (a client `SmartButton` next to a library `Button`).
- * A disabled or hidden item is skipped; a text field inside the group keeps its arrows.
- *
- *     const { onKeyDown } = useArrowKeyFocus();
- *     <div onKeyDown={onKeyDown}>{buttons}</div>
- */
-export declare function useArrowKeyFocus({ orientation, wrap, homeEnd, }?: ArrowKeyFocusOptions): ArrowKeyFocusHandlers;
-export default useArrowKeyFocus;

package/dist/types/shared-web-ui/src/Avatar/Avatar.d.ts

@@ -1,36 +0,0 @@
-import React from 'react';
-export type AvatarSize = 'xs' | 'small' | 'medium' | 'large';
-export type AvatarShape = 'circle' | 'rounded' | 'square';
-export interface AvatarProps {
-    /** Image URL. Falls back to initials, then to `children`. */
-    src?: string;
-    /** Used for the image's alt text and to derive initials when there is no `src`. */
-    name?: string;
-    /** Override the derived initials. */
-    initials?: string;
-    size?: AvatarSize;
-    shape?: AvatarShape;
-    /**
-     * Give the avatar a stable tint derived from `name`. Two people rarely collide, and the
-     * same person is always the same colour across screens.
-     */
-    tinted?: boolean;
-    children?: React.ReactNode;
-    className?: string;
-    style?: React.CSSProperties;
-}
-/**
- * A person or entity marker: image, initials, or custom content.
- *
- * Hookless, so it renders identically on a server. Sizes track the field heights, which is
- * what makes an avatar line up with an input or button placed beside it.
- */
-declare const Avatar: React.FC<AvatarProps>;
-export interface AvatarGroupProps {
-    children?: React.ReactNode;
-    className?: string;
-    style?: React.CSSProperties;
-}
-/** Overlapping stack. Each disc is ringed in the page ground so they stay distinct. */
-export declare const AvatarGroup: React.FC<AvatarGroupProps>;
-export default Avatar;

package/dist/types/shared-web-ui/src/Breadcrumbs/Breadcrumbs.d.ts

@@ -1,70 +0,0 @@
-import React from 'react';
-import type { NavItem } from '../../../published/dcs-ui/src/publicTypes';
-export interface BreadcrumbsProps {
-    /**
-     * Root → current. Pass `findNavTrail(items, activeId)` from shared-logic and the crumbs are
-     * the same path the Sidebar highlights, by construction. The home crumb is NOT part of this.
-     */
-    items: NavItem[];
-    /** Element for the linked crumbs — `Link`, `NavLink`, `a`. */
-    as?: React.ElementType;
-    onSelect?: (item: NavItem) => void;
-    /**
-     * The root crumb, rendered before the trail and never truncated. Defaults to a home icon
-     * linking to `/`; pass a `NavItem` to change the target, or `false` to drop it.
-     *
-     * It is on by DEFAULT because it does two jobs: a trail that starts mid-app has no visible
-     * way back to the top, and — since the switcher lives in the separator — without a crumb in
-     * front of it the FIRST real crumb has no separator and so no way to reach its siblings.
-     */
-    home?: NavItem | false;
-    /**
-     * Render each crumb's `icon`. **Off by default.** The same `NavItem` tree feeds the Sidebar,
-     * where an icon per row earns its place, and the trail, where a row of little glyphs beside
-     * the home icon is noise — the labels already say it. Nothing to strip from the registry:
-     * the surface decides.
-     */
-    showIcons?: boolean;
-    /** Default a chevron. */
-    separator?: React.ReactNode;
-    /**
-     * Standalone row: own padding, min-height and bottom rule. Off by default, which is the
-     * inline form that sits in an `AppBar`. Turn it on where the trail is its own strip under
-     * the bar — the layout the client uses on mobile.
-     */
-    bar?: boolean;
-    /**
-     * Collapse the middle into a menu past this many crumbs. First and last are always kept.
-     * `0` disables. Default 4.
-     */
-    maxItems?: number;
-    /**
-     * Alternatives for a crumb. Return some and the separator BEFORE that crumb becomes a
-     * button opening them, so you can move sideways at any level instead of going back up and
-     * down again. With a `NavItem` tree it is the parent's `children`.
-     *
-     * `index` is the crumb's position in `items`; the home crumb is not counted, so index 0 is
-     * the first real crumb and its siblings are the top-level sections.
-     */
-    siblingsOf?: (item: NavItem, index: number) => NavItem[];
-    className?: string;
-    style?: React.CSSProperties;
-    'aria-label'?: string;
-}
-/**
- * The path to the current page, over the shared `NavItem` shape.
- *
- * Fed by `findNavTrail` — the same function the Sidebar uses for the active trail — so the two
- * cannot disagree about where you are.
- *
- * **The separator IS the sibling switcher.** It sits BEFORE each crumb and, where that crumb
- * has alternatives, is a button that opens them. One chevron per gap doing both jobs: a
- * separate switcher control next to each label puts two arrows between every pair of crumbs,
- * and a separator rendered AFTER each crumb leaves a dangling arrow past the last one.
- *
- * Long paths collapse in the MIDDLE, never the end: the first crumb (where am I in the app)
- * and the last (where am I now) carry the meaning, and truncating the tail would hide the very
- * crumb the user is looking at.
- */
-declare const Breadcrumbs: React.FC<BreadcrumbsProps>;
-export default Breadcrumbs;

package/dist/types/shared-web-ui/src/Card/Card.d.ts

@@ -1,33 +0,0 @@
-import React from 'react';
-export type CardVariant = 'outlined' | 'elevated' | 'flat';
-export type CardPadding = 'none' | 'small' | 'medium';
-export interface CardProps {
-    children?: React.ReactNode;
-    /** Default `'outlined'`. */
-    variant?: CardVariant;
-    /** Applied to the bands, not the root — see below. Default `'medium'`. */
-    padding?: CardPadding;
-    title?: React.ReactNode;
-    subtitle?: React.ReactNode;
-    /** Trailing header content — a Badge, a menu button. */
-    action?: React.ReactNode;
-    /** Footer band, right-aligned. */
-    footer?: React.ReactNode;
-    /** Makes the whole card a button: hover, focus ring, keyboard activation. */
-    onClick?: () => void;
-    className?: string;
-    style?: React.CSSProperties;
-}
-/**
- * A surface with optional header and footer bands.
- *
- * Padding lives on the BANDS, not the root, so a full-bleed child — a table, an image, an
- * embedded report — can sit flush between a padded header and footer without fighting the
- * card's own inset. `padding="none"` gives a bare surface.
- *
- * Hookless, so it renders identically on a server. With `onClick` it becomes a real
- * `<button>` rather than a div with a handler, which is what gets it keyboard activation and
- * a focus ring for free.
- */
-declare const Card: React.FC<CardProps>;
-export default Card;

package/dist/types/shared-web-ui/src/ColorSchemeSelect/ColorSchemeSelect.d.ts

@@ -1,26 +0,0 @@
-import React from 'react';
-import { SelectProps } from '../../../published/dcs-ui/src/publicTypes';
-import { ColorScheme } from '../../../published/dcs-ui/src/publicLogic';
-export interface ColorSchemeSelectProps extends Omit<SelectProps, 'options' | 'renderOption' | 'renderSelectedValue'> {
-    /**
-     * The schemes to offer. Passed IN on purpose — this component never imports a palette.
-     * That keeps it generic (any app, any palette) and keeps domain palettes out of the
-     * published surface, since shared-web-ui is re-exported wholesale by @dcs-tech/ui.
-     */
-    schemes: ColorScheme[];
-    /** Text of the sample's title word. Default 'Title'. */
-    sampleTitle?: string;
-    /** Text inside the sample's band. Default 'Label'. */
-    sampleLabel?: string;
-    /** Row shown for "no scheme"; omit to require a choice. */
-    noneLabel?: string;
-}
-/**
- * A Select whose options preview themselves.
- *
- * Each row renders the scheme's three real roles — title colour, band, and the text on the
- * band — so the choice is judged by eye rather than read as a name. The sample is drawn on a
- * fixed light ground so every row is comparable, independent of the viewer's theme.
- */
-declare const ColorSchemeSelect: React.FC<ColorSchemeSelectProps>;
-export default ColorSchemeSelect;

package/dist/types/shared-web-ui/src/CommandPalette/CommandPalette.d.ts

@@ -1,52 +0,0 @@
-import React from 'react';
-export interface CommandPaletteItem {
-    id: string;
-    label: React.ReactNode;
-    /** Plain text used for searching — set when `label` is a node. */
-    searchText?: string;
-    /** Extra terms to match on: synonyms, the old name for a screen. */
-    keywords?: string;
-    /** Group heading. Items keep the order they arrive in within a group. */
-    section?: string;
-    icon?: React.ReactNode;
-    /** Trailing hint — a shortcut, a route. */
-    hint?: React.ReactNode;
-    disabled?: boolean;
-}
-export interface CommandPaletteProps {
-    /** Already filtered and authorised by the caller — this component renders, it does not decide. */
-    items: CommandPaletteItem[];
-    open: boolean;
-    onOpenChange: (open: boolean) => void;
-    onSelect: (item: CommandPaletteItem) => void;
-    /**
-     * Global shortcut, matched case-insensitively with ctrl OR meta. `null` disables it so the
-     * host can own the binding. Default `'k'`.
-     */
-    hotkey?: string | null;
-    placeholder?: string;
-    emptyMessage?: React.ReactNode;
-    /** Shown before anything is typed. Omit to show all items. */
-    initialItems?: CommandPaletteItem[];
-    /** Cap on rendered results. Default 50. */
-    maxResults?: number;
-    'aria-label'?: string;
-}
-/**
- * The generic half of a command palette: the shortcut, the dialog, the search box, a grouped
- * result list and its keyboard model. **It decides nothing about what is in the list** —
- * building items from a route registry and filtering them by permission is app logic and stays
- * in the app.
- *
- * Built on pieces that already exist rather than a new dependency:
- * - `Dialog` for the overlay, focus trap, Escape and top-layer stacking.
- * - `popupList.module.css` for rows and group headings, so a palette row and a Select option
- *   are the same object visually.
- * - `fuseSearch`, already used by Suggest, so fuzzy matching behaves the same across the
- *   library and `fuse.js` — already a declared dependency — is the only cost.
- *
- * This is what replaced `cmdk` in the client's version: a fourth list implementation with its
- * own dependency, its own styling and its own keyboard behaviour.
- */
-declare const CommandPalette: React.FC<CommandPaletteProps>;
-export default CommandPalette;

package/dist/types/shared-web-ui/src/Dialog/Dialog.d.ts

@@ -1,101 +0,0 @@
-import React from 'react';
-export type DialogPlacement = 'center' | 'right' | 'left' | 'top' | 'bottom';
-export type DialogSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
-export interface DialogClassNames {
-    root?: string;
-    panel?: string;
-    header?: string;
-    body?: string;
-    footer?: string;
-    closeButton?: string;
-}
-export interface DialogStyles {
-    root?: React.CSSProperties;
-    panel?: React.CSSProperties;
-    header?: React.CSSProperties;
-    body?: React.CSSProperties;
-    footer?: React.CSSProperties;
-    closeButton?: React.CSSProperties;
-}
-export interface DialogProps {
-    open: boolean;
-    /** Fired for the close button, backdrop, Escape, or a programmatic close. */
-    onClose?: () => void;
-    /**
-     * Veto a close by returning false — a dirty-form guard. Runs for EVERY route out,
-     * including Escape and the backdrop, so there is no way around it.
-     */
-    onBeforeClose?: () => boolean;
-    /** Fired when Escape is pressed, before the close is decided. */
-    onEscKeyDown?: (event: Event) => void;
-    /** Fired when the backdrop is clicked, before the close is decided. */
-    onOverlayClick?: (event: React.PointerEvent) => void;
-    /** Fired after the exit animation finishes and the dialog has left the DOM. */
-    onAnimationEnd?: () => void;
-    children?: React.ReactNode;
-    title?: React.ReactNode;
-    subtitle?: React.ReactNode;
-    /** Footer band, right-aligned. */
-    footer?: React.ReactNode;
-    /**
-     * Blocks the page behind it and dims it. **Default true** — what most people mean by
-     * "a modal". `false` opens a non-blocking panel and, because it uses `show()` rather than
-     * `showModal()`, does not trap focus.
-     */
-    modal?: boolean;
-    /** `center` is a dialog; `right` / `left` / `bottom` / `top` are what a "Sheet" is. */
-    placement?: DialogPlacement;
-    size?: DialogSize;
-    closeOnBackdrop?: boolean;
-    closeOnEscape?: boolean;
-    showCloseButton?: boolean;
-    /** Replace the built-in ✕. */
-    closeIcon?: React.ReactNode;
-    closeIconId?: string;
-    /** Lock page scroll while open. Default true. */
-    blockScroll?: boolean;
-    /**
-     * Pad the body by the scrollbar width when locking, so the page doesn't jump sideways as
-     * the scrollbar disappears. Default true. No-op where scrollbars are overlaid (macOS).
-     */
-    reserveScrollBarGap?: boolean;
-    /** Focus this when it opens, instead of the first focusable child. */
-    initialFocusRef?: React.RefObject<HTMLElement | null>;
-    /** Where to render. Defaults to `document.body`. */
-    container?: Element | null;
-    /** Enter/exit animation length in ms. Default 200. `0` disables. */
-    animationDuration?: number;
-    /** Body padding. Off for a full-bleed child — a table, an embedded report. */
-    padded?: boolean;
-    classNames?: DialogClassNames;
-    styleSlots?: DialogStyles;
-    className?: string;
-    style?: React.CSSProperties;
-    role?: string;
-    id?: string;
-    'aria-label'?: string;
-    'aria-labelledby'?: string;
-    'aria-describedby'?: string;
-}
-/**
- * A dialog, on the native `<dialog>` element.
- *
- * Why the platform element rather than a div in a portal:
- *
- * - **`showModal()` puts it in the browser's TOP LAYER**, outside the z-index system entirely.
- *   Nothing on the page can cover it — not a `z-index: 9999` loading overlay, which is the
- *   exact failure that once locked this app behind an unreachable confirm.
- * - Focus trapping, `Escape`, an inert background, `::backdrop` and correct stacking of nested
- *   dialogs come from the platform rather than being re-implemented.
- * - No dependency reaches consumers of the published package.
- *
- * The catch is the inverse of the win: because the dialog is in the top layer, a Popover
- * portalled to `<body>` would render BEHIND it. So the dialog publishes itself as the portal
- * container for its own subtree (`UIPortalContext`) — any Select, Suggest or Popover inside
- * renders into the dialog and therefore above it.
- *
- * Padding lives on the bands, not the panel, so a full-bleed child sits flush between a padded
- * header and footer. Same rule as Card.
- */
-declare const Dialog: React.FC<DialogProps>;
-export default Dialog;

package/dist/types/shared-web-ui/src/Dialog/DialogHost.d.ts

@@ -1,80 +0,0 @@
-import React from 'react';
-import type { ButtonProps } from '../../../published/dcs-ui/src/publicTypes';
-/** Everything a Button takes, minus what the host drives itself. */
-export type DialogActionProps = Omit<ButtonProps, 'onClick' | 'loading' | 'children'>;
-export interface DialogChoice extends DialogActionProps {
-    /** What `choose()` resolves to. Also the React key. */
-    value: string;
-    label: NonNullable<ButtonProps['label']>;
-    /** Run when picked. May be async — the button shows loading until it settles. */
-    action?: (...args: any[]) => unknown;
-    args?: unknown[];
-}
-interface BaseOptions {
-    title?: string;
-    /** Newlines are preserved, so a multi-line message reads as written. */
-    message: React.ReactNode;
-    /** Cancel renders LAST. `null` drops it; Escape and the backdrop still cancel. */
-    cancelLabel?: string | null;
-    cancelButton?: DialogActionProps;
-}
-export interface ConfirmOptions extends BaseOptions {
-    confirmLabel?: string;
-    /** `danger` colours the confirm button `error`. */
-    tone?: 'primary' | 'danger';
-    confirmButton?: DialogActionProps;
-    action?: (...args: any[]) => unknown;
-    args?: unknown[];
-    /**
-     * Which button holds focus when the dialog opens, so Enter answers it. Default `confirm`;
-     * pass `cancel` for a destructive question. Arrows move between the buttons either way.
-     */
-    focus?: 'confirm' | 'cancel';
-}
-export interface ChooseOptions extends BaseOptions {
-    /** Two or more, rendered left-to-right before Cancel. */
-    choices: DialogChoice[];
-    /**
-     * The `value` of the choice that holds focus when the dialog opens, or `'cancel'`.
-     * Default: the first choice. Arrows move between the buttons either way.
-     */
-    focus?: string;
-}
-export interface AlertOptions {
-    title?: string;
-    message: React.ReactNode;
-    okLabel?: string;
-    tone?: 'primary' | 'danger';
-    okButton?: DialogActionProps;
-}
-export interface DialogApi {
-    /** Yes / no. Resolves `false` on cancel, Escape or backdrop. */
-    confirm: (opts: ConfirmOptions) => Promise<boolean>;
-    /** N options. Resolves the chosen `value`, or `null` if dismissed. */
-    choose: (opts: ChooseOptions) => Promise<string | null>;
-    /** Acknowledge-only. */
-    alert: (opts: AlertOptions) => Promise<void>;
-}
-/**
- * The imperative dialog API.
- *
- * Throws outside a `UIProvider` rather than returning no-ops: an `await confirm()` that
- * silently resolved `false` would look like the user clicking Cancel, and the calling code
- * would quietly do nothing. A dialog needs a host, so this is the one place the provider is
- * genuinely required.
- */
-export declare const useDialog: () => DialogApi;
-/**
- * Rendered once by `UIProvider`. Owns the single dialog instance the imperative API drives.
- *
- * This is the reason the API is worth moving into the library: the previous hook returned a
- * `confirmHost` ELEMENT that every call site had to remember to render, with a warning in its
- * own docstring that returning a component instead remounted the subtree and broke a form
- * mid-edit. Hosting centrally removes the whole class of mistake.
- *
- * Renders through `<Dialog>` rather than beside it, so there is one dialog implementation.
- */
-export declare const DialogHost: React.FC<{
-    children?: React.ReactNode;
-}>;
-export {};

package/dist/types/shared-web-ui/src/DropdownMenu/DropdownMenu.d.ts

@@ -1,49 +0,0 @@
-import React from 'react';
-import type { PopoverPlacement } from '../../../published/dcs-ui/src/publicLogic';
-export interface DropdownMenuItem {
-    /** Returned by `onSelect`. Also the React key. */
-    value: string;
-    label: React.ReactNode;
-    /** Secondary line under the label. */
-    description?: React.ReactNode;
-    icon?: React.ReactNode;
-    /** Trailing hint — a shortcut, a count. */
-    hint?: React.ReactNode;
-    disabled?: boolean;
-    /** Renders in the destructive colour. */
-    danger?: boolean;
-    /** Non-selectable heading above this item. */
-    groupLabel?: string;
-    /** Separator line above this item. */
-    divider?: boolean;
-}
-export interface DropdownMenuProps {
-    /** Element that opens the menu. Cloned to attach the ref, click and ARIA wiring. */
-    trigger: React.ReactElement;
-    items: DropdownMenuItem[];
-    onSelect?: (value: string, item: DropdownMenuItem) => void;
-    placement?: PopoverPlacement;
-    /** Force the menu to the trigger's width. */
-    matchTriggerWidth?: boolean;
-    /**
-     * Row density. Drives the shared popup list's `size_*` class, which is what DEFINES
-     * `--popup-row-pad-y` / `--popup-pad-x` / the font steps. Without one the rows render
-     * with no padding at all, because `.row` reads custom properties nothing declared.
-     */
-    size?: 'xxs' | 'xs' | 'small' | 'medium' | 'large' | 'xl';
-    /** Keep it open after a selection — for a menu of toggles. Default false. */
-    closeOnSelect?: boolean;
-    'aria-label'?: string;
-    className?: string;
-}
-/**
- * A menu on top of `Popover` — no second positioning implementation, and the rows reuse the
- * same `popupList` module Select and Suggest render, so a menu row and an option row are the
- * same object visually.
- *
- * Keyboard follows the menu pattern rather than the listbox one: arrows move a roving cursor,
- * Home/End jump, Enter or Space activates, Escape closes and returns focus to the trigger.
- * Disabled items are skipped rather than focused-and-ignored.
- */
-declare const DropdownMenu: React.FC<DropdownMenuProps>;
-export default DropdownMenu;

package/dist/types/shared-web-ui/src/EditableTable/EditableTableRow.d.ts

@@ -1,25 +0,0 @@
-import React from 'react';
-import type { EditableTableRowProps, ResolvedColumnLayout } from '../../../published/dcs-ui/src/publicTypes';
-import type { EditableTableCellActions } from '../../../published/dcs-ui/src/publicTypes';
-import type { ResolvedRule } from '../../../published/dcs-ui/src/publicLogic';
-export interface EditableTableRowRenderProps<T> extends EditableTableRowProps<T> {
-    /** One resolved frame per column, from `resolveTableLayout`. */
-    columnLayouts: ResolvedColumnLayout[];
-    /** Per-cell validation, resolved by the table (pure `resolveColumnRules` underneath). */
-    getCellRule?: (rowIndex: number, cellindex: number) => ResolvedRule;
-    /** The table's row operations, for cells that ACT — a button column's `onClick`. */
-    cellActions?: EditableTableCellActions;
-    /** `'entering'` | `'exiting'` while this row is animating — see `useRowAnimation`. */
-    rowState?: 'entering' | 'exiting';
-    /** The column focus landed on after a row operation, flashed once so it can be seen. */
-    landedCellIndex?: number | null;
-}
-/**
- * A row is just its cells. It used to hand the whole column list to `Fields`, which
- * wrapped each field in a bare `<td>` it had no way to size, align or pin — so the
- * row could not own its frame. Each column now renders through `EditableTableCell`,
- * which does.
- */
-declare const EditableTableRow: <T extends Record<string, any>>({ defaultData, rowIndex, rowData, columnFields, columnLayouts, getCellRule, cellActions, rowState, landedCellIndex, editableTableData, onChange, onKeyDown, onSelect, onCellFocus, registerCellRef, focusedRowIndex, isFocusedRow, focusedCellIndex, tableDataKey, renderAuthorize, renderTooltip, componentRegistry, }: EditableTableRowRenderProps<T>) => React.JSX.Element;
-declare const _default: typeof EditableTableRow;
-export default _default;

package/dist/types/shared-web-ui/src/EditableTable/EditableTableSummary.d.ts

@@ -1,22 +0,0 @@
-import React from 'react';
-import type { ResolvedTableSummary } from '../../../published/dcs-ui/src/publicLogic';
-import type { EditableTableProps, EditableTableSummaryContext, SummaryLicenseConfig } from '../../../published/dcs-ui/src/publicTypes';
-/**
- * The area under the table (D4) — everything that is not a column total.
- *
- * Two forms, one prop:
- * - **config** — the client Table's `TableSummaryConfig`, unchanged, resolved by the
- *   same pure logic, so a summary written for a report table renders here as-is;
- * - **render function** — handed the rows, the resolved column totals and the row
- *   actions, for custom figures and action buttons the table knows nothing about.
- *
- * Rendered below the scroll container, so it is always visible without sticking.
- */
-interface EditableTableSummaryProps<T> {
-    summary: NonNullable<EditableTableProps<T>['summary']>;
-    resolved: ResolvedTableSummary;
-    context: EditableTableSummaryContext<T>;
-    renderLicense?: (license: SummaryLicenseConfig, children: React.ReactNode) => React.ReactNode;
-}
-declare function EditableTableSummary<T>({ summary, resolved, context, renderLicense }: EditableTableSummaryProps<T>): React.JSX.Element | null;
-export default EditableTableSummary;

package/dist/types/shared-web-ui/src/EditableTable/useRowAnimation.d.ts

@@ -1,44 +0,0 @@
-/**
- * Row enter/exit feedback for the grid.
- *
- * GK: *"on click remove, dont know it is removed or not, also dont know from where the focus
- * is shifted."* Both halves matter. A row that vanishes between two frames reads as "nothing
- * happened", and after a delete the grid focuses the row ABOVE the one that went — useful, but
- * invisible, so the cursor appears to teleport.
- *
- * Three pieces, and each is deliberately small:
- *
- * - **entering** — keys present now that were absent last render. Detected by DIFFING the keys
- *   rather than by hooking the add path, so it covers every way a row arrives: Enter at the
- *   last cell (which happens inside `useEditableTable`, out of the renderer's reach), the
- *   toolbar, a button cell's `actions.addRow`, or the consumer setting state itself.
- * - **exiting** — a delete has to be DEFERRED for the row to be animated at all; React cannot
- *   animate a row it has already unmounted. The delay is short and the focus move is not
- *   waited on, so the keyboard flow is unchanged.
- * - **landed** — the cell focus ends up in, flashed briefly, which is the half that answers
- *   "where did it go".
- *
- * `prefers-reduced-motion` switches all of it off, including the deferral: someone who asked
- * for no animation should not also get a slower delete.
- */
-/**
- * Kept in step with the durations in `EditableTable.module.css` — `etRowExitCell` and
- * `etRowEnterCell`. If this is SHORTER than the CSS, React unmounts the row mid-collapse and
- * the rows below snap up, which is the whole thing the animation exists to prevent.
- */
-export declare const ROW_EXIT_MS = 280;
-export interface RowAnimation {
-    /** `'entering' | 'exiting' | undefined` for a row key — rendered as a data attribute. */
-    rowState: (rowKey: string) => 'entering' | 'exiting' | undefined;
-    /** The cell that focus landed on after a row operation, flashed so it can be seen. */
-    landedCell: {
-        rowKey: string;
-        cellindex: number;
-    } | null;
-    /** Runs `remove` after the exit animation — immediately when animation is off. */
-    removeRow: (rowKey: string | undefined, remove: () => void) => void;
-    /** Called once focus has settled after an add or a delete. */
-    noteLanding: (rowKey: string | undefined, cellindex: number) => void;
-    enabled: boolean;
-}
-export declare function useRowAnimation(rowKeys: string[], animate?: boolean): RowAnimation;

package/dist/types/shared-web-ui/src/FieldContext/FieldContext.d.ts

@@ -1,18 +0,0 @@
-import type { FieldContextValue } from '../../../published/dcs-ui/src/publicTypes';
-/**
- * The surface settings a container hands down to every field inside it.
- *
- * Before this existed, `<Form size="large">` styled the form's own chrome and
- * its action buttons and nothing else — the fields inside kept their own
- * defaults, which were `small` for Input/Select/Suggest and `medium` for
- * Checkbox/Radio/Switch. So a form had three densities in it and no single
- * prop could change them.
- *
- * Empty by default rather than pre-filled: a context that already carried
- * `size: 'small'` would be indistinguishable from a container that had
- * deliberately asked for small, and a field could no longer tell "nobody said"
- * from "someone said small". Resolution is always
- * `own prop → context → DEFAULT_CONTROL_SIZE`.
- */
-export declare const FieldContext: import("react").Context<FieldContextValue>;
-export declare const useFieldContext: () => FieldContextValue;

package/dist/types/shared-web-ui/src/FieldContext/FieldProvider.d.ts

@@ -1,13 +0,0 @@
-import React from 'react';
-import type { FieldProviderProps } from '../../../published/dcs-ui/src/publicTypes';
-/**
- * Supplies surface defaults to every field beneath it.
- *
- * Providers nest: an inner one overrides only the settings it names, so a
- * `<FieldProvider size="xs">` inside a `<Form variant="filled">` gives dense
- * filled fields rather than dense outlined ones. That is what makes the
- * editable-table row work — the grid sets `size` per table without having to
- * know or restate the variant the surrounding form chose.
- */
-declare const FieldProvider: React.FC<FieldProviderProps>;
-export default FieldProvider;