neatkit 0.7.0 → 0.9.0

package/dist/components/Sidebar/components/SidebarOverlay.d.ts

@@ -0,0 +1,38 @@
+import { type RefObject } from "react";
+import type { SidebarState } from "../utils/state";
+import { type SidebarPanelProps } from "./SidebarPanel";
+/**
+ * A type representing properties for the mounted Sidebar overlay layer.
+ *
+ * The forwarded panel properties are derived rather than restated, so the
+ * consumer attributes the root spreads through here stay described by one
+ * declaration. The overlay supplies the presentation, open state, and
+ * identifier itself, and a top offset applies to no overlay.
+ */
+type SidebarOverlayProps = Omit<SidebarPanelProps, "top" | "open" | "panelId" | "panelReference" | "presentation" | "state"> & {
+    /** The elements treated as part of the overlay dismissal layer. */
+    boundaries: readonly RefObject<HTMLElement | null>[];
+    /** The preferred element focused when the Sidebar opens. */
+    initialFocusReference?: RefObject<HTMLElement | null>;
+    /** Whether scrolling is locked while the Sidebar is open. */
+    lockScroll: boolean;
+    /** The document owning the mounted overlay layer. */
+    ownerDocument: Document;
+    /** Assigns the mounted panel to internal and consumer references. */
+    panelReference: (element: HTMLElement | null) => void;
+    /** The visual phase exposed to transition styles. */
+    presenceState: "closing" | "open";
+    /** Whether focus returns to its prior owner when the Sidebar closes. */
+    restoreFocus: boolean;
+    /** The shared Sidebar state supplied by its provider. */
+    sidebar: SidebarState;
+};
+/**
+ * Renders and coordinates one mounted Sidebar overlay layer.
+ *
+ * @param props - The panel, document, and transition properties.
+ *
+ * @returns The open or exiting Sidebar overlay.
+ */
+export default function SidebarOverlay(props: SidebarOverlayProps): import("react").JSX.Element;
+export {};

package/dist/components/Sidebar/components/SidebarPanel.d.ts

@@ -0,0 +1,47 @@
+import type { CSSProperties, HTMLAttributes, ReactNode, Ref } from "react";
+import type { SidebarPresentationState } from "../utils/state";
+/** A type representing the edge an overlay Sidebar occupies. */
+export type SidebarSide = "end" | "start";
+/** A type representing CSS custom properties accepted by Sidebar styles. */
+type SidebarCustomProperties = {
+    [CustomProperty in `--${string}`]?: string | number;
+};
+/** A type representing native Sidebar styles and CSS custom properties. */
+export type SidebarStyle = CSSProperties & SidebarCustomProperties;
+/** A type representing properties used to implement the Sidebar panel. */
+export type SidebarPanelProps = Omit<HTMLAttributes<HTMLElement>, "children" | "style"> & {
+    /** The regions and groups composing the Sidebar. */
+    children?: ReactNode;
+    /** The distance the inline panel is pinned below its scroll container. */
+    top?: string;
+    /** The identifier associating the panel with its Trigger. */
+    panelId?: string;
+    /** The reference assigned to the rendered panel element. */
+    panelReference: Ref<HTMLElement>;
+    /** The presentation currently rendered by the Sidebar. */
+    presentation: SidebarPresentationState;
+    /** Whether the Sidebar is currently disclosed as an overlay. */
+    open: boolean;
+    /** The edge the overlay panel occupies. */
+    side: SidebarSide;
+    /** The visual phase exposed to transition styles. */
+    state?: "closing" | "open";
+    /** The styles applied to the panel. */
+    style?: SidebarStyle;
+    /** The width of the Sidebar as a CSS length. */
+    width?: string;
+};
+/**
+ * Renders the Sidebar panel shared by both of its presentations.
+ *
+ * Authoring the panel once keeps both presentations in step, though it does
+ * not preserve the element itself: an overlay is portalled into the boundary
+ * while an inline panel stays in place, so crossing the responsive breakpoint
+ * remounts the panel and restarts anything stateful inside it.
+ *
+ * @param props - The presentation, state, and native panel properties.
+ *
+ * @returns The rendered Sidebar panel.
+ */
+export default function SidebarPanel(props: SidebarPanelProps): import("react").JSX.Element;
+export {};

package/dist/components/Sidebar/components/SidebarTrigger.d.ts

@@ -0,0 +1,47 @@
+import { type MouseEvent, type ReactElement, type Ref } from "react";
+import type { SidebarVariant } from "../utils/state";
+/** A type representing the properties applied to a cloned Trigger child. */
+type SidebarTriggerChildProps = {
+    /** The panel association announced while the Sidebar is open. */
+    "aria-controls"?: string;
+    /** The disclosure state announced for the Sidebar. */
+    "aria-expanded"?: boolean;
+    /** The kind of interface the control discloses. */
+    "aria-haspopup"?: "dialog";
+    /** The class names applied to the control. */
+    className?: string;
+    /** The responsive behavior selecting stylesheet visibility. */
+    "data-sidebar-variant"?: SidebarVariant;
+    /** The callback invoked when the control is activated. */
+    onClick?: (event: MouseEvent<HTMLElement>) => void;
+    /** The reference assigned to the control. */
+    ref?: Ref<HTMLElement>;
+};
+/** A type representing properties for the Sidebar.Trigger component. */
+export type SidebarTriggerProps = {
+    /**
+     * The single control that opens the overlay Sidebar.
+     *
+     * Custom components must forward the class name, reference, click handler,
+     * and ARIA properties to their interactive root.
+     */
+    children: ReactElement;
+};
+/**
+ * Connects an existing control to the overlay Sidebar it opens.
+ *
+ * The Trigger renders no element of its own, and renders nothing at all
+ * until a Sidebar publishes to the surrounding boundary. A server render
+ * resolves no presentation, so server markup carries no control and
+ * hydration adds one rather than withdrawing one the page should never
+ * have shown. A Trigger whose boundary holds no Sidebar stays absent for
+ * the same reason: there is nothing for it to disclose, and the control
+ * returns as soon as a Sidebar publishes.
+ *
+ * @param props - The single control receiving Sidebar behavior.
+ *
+ * @returns The control extended with Sidebar disclosure behavior, or
+ * nothing while no Sidebar is connected.
+ */
+export default function SidebarTrigger(props: SidebarTriggerProps): ReactElement<SidebarTriggerChildProps, string | import("react").JSXElementConstructor<any>> | null;
+export {};

package/dist/components/Sidebar/components/SidebarUser.d.ts

@@ -0,0 +1,59 @@
+import { type HTMLAttributes, type ReactNode } from "react";
+import { type ButtonProps } from "../../Button";
+import { type IconType } from "../../Icon";
+/** A type representing one consistently styled Sidebar user action. */
+export type SidebarUserAction = Omit<ButtonProps<"button">, "as" | "children" | "className" | "fullWidth" | "icon" | "iconAlignment" | "shape" | "style" | "textAlignment" | "type" | "variant"> & {
+    /** The icon identifying the action. */
+    icon: IconType;
+    /** The short Tooltip label and base accessible name for the action. */
+    label: string;
+};
+/** A type representing properties for the Sidebar.User component. */
+export type SidebarUserProps = Omit<HTMLAttributes<HTMLDivElement>, "children" | "onClick"> & {
+    /**
+     * The controls operating on the represented person.
+     *
+     * Each action is keyed by its label, so labels must be unique.
+     */
+    actions?: readonly SidebarUserAction[];
+    /** The secondary line displayed beneath the name. */
+    description?: ReactNode;
+    /** The image displayed until loading fails. */
+    image?: string;
+    /** Whether the details are replaced by a loading indicator. */
+    loading?: boolean;
+    /** The display name shown for the represented person. */
+    name: string;
+    /** The callback invoked when the details are activated. */
+    onClick?: () => void;
+};
+/**
+ * Renders a person's avatar, name, and its consistently styled actions.
+ *
+ * The details and the actions are separately operable, so an activatable
+ * identity does not absorb the controls beside it.
+ *
+ * @param props - The identity, state, and native properties.
+ * @param forwardedReference - The reference assigned to the root element.
+ *
+ * @returns The rendered Sidebar user row.
+ */
+declare const SidebarUser: import("react").ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children" | "onClick"> & {
+    /**
+     * The controls operating on the represented person.
+     *
+     * Each action is keyed by its label, so labels must be unique.
+     */
+    actions?: readonly SidebarUserAction[];
+    /** The secondary line displayed beneath the name. */
+    description?: ReactNode;
+    /** The image displayed until loading fails. */
+    image?: string;
+    /** Whether the details are replaced by a loading indicator. */
+    loading?: boolean;
+    /** The display name shown for the represented person. */
+    name: string;
+    /** The callback invoked when the details are activated. */
+    onClick?: () => void;
+} & import("react").RefAttributes<HTMLDivElement>>;
+export default SidebarUser;

package/dist/components/Sidebar/hooks/usePresentation.d.ts

@@ -0,0 +1,14 @@
+import type { BoundaryWidthStore } from "../../Boundary/contexts/BoundaryContext";
+import type { SidebarPresentationState, SidebarVariant } from "../utils/state";
+/**
+ * Resolves the presentation a Sidebar renders inside its boundary.
+ *
+ * The boundary is measured rather than the viewport, so a narrow Boundary on a
+ * wide display still presents its Sidebar as an overlay.
+ *
+ * @param variant - The responsive behavior requested by the consumer.
+ * @param width - The boundary width store, when a boundary exists.
+ *
+ * @returns The explicit, measured, or pending Sidebar presentation.
+ */
+export declare function usePresentation(variant: SidebarVariant, width: BoundaryWidthStore | undefined): SidebarPresentationState;

package/dist/components/Sidebar/hooks/useSidebar.d.ts

@@ -0,0 +1,9 @@
+import { type SidebarState } from "../utils/state";
+/**
+ * Returns the Sidebar state published to the surrounding boundary.
+ *
+ * @param componentName - The subcomponent name reported when unconnected.
+ *
+ * @returns The published Sidebar state when one exists.
+ */
+export declare function useSidebar(componentName: string): SidebarState | undefined;

package/dist/components/Sidebar/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from "./Sidebar";
+export type { SidebarFooterProps, SidebarGroupProps, SidebarHeaderProps, SidebarItemProps, SidebarOpenChangeReason, SidebarPresentation, SidebarProps, SidebarSide, SidebarTriggerProps, SidebarUserAction, SidebarUserProps, SidebarVariant, } from "./Sidebar";

package/dist/components/Sidebar/utils/presentation.d.ts

@@ -0,0 +1,12 @@
+import type { SidebarPresentationState } from "./state";
+/** A type representing the presentations a Sidebar's content renders in. */
+export type SidebarPresentation = "both" | "inline" | "overlay";
+/**
+ * Determines whether content renders in the Sidebar's presentation.
+ *
+ * @param requested - The presentations the content is rendered in.
+ * @param current - The presentation the Sidebar currently renders.
+ *
+ * @returns Whether the content renders rather than being omitted.
+ */
+export declare function rendersInPresentation(requested: SidebarPresentation, current: SidebarPresentationState | undefined): boolean;

package/dist/components/Sidebar/utils/state.d.ts

@@ -0,0 +1,62 @@
+/** A type representing the responsive behavior of a Sidebar. */
+export type SidebarVariant = "inline" | "overlay" | "responsive";
+/**
+ * A type representing the presentation a Sidebar currently renders.
+ *
+ * The pending presentation covers server rendering and hydration, where the
+ * boundary is not yet measured and stylesheets select the presentation.
+ */
+export type SidebarPresentationState = "inline" | "overlay" | "pending";
+/** A type representing an interaction requesting a Sidebar state change. */
+export type SidebarOpenChangeReason = "escape" | "item" | "outside" | "trigger" | "variant";
+/** A type representing the state one Sidebar publishes to its boundary. */
+export type SidebarState = {
+    /** The identifier applied to the Sidebar panel. */
+    id: string;
+    /** Whether the overlay Sidebar is currently open. */
+    open: boolean;
+    /** The presentation currently rendered by the Sidebar. */
+    presentation: SidebarPresentationState;
+    /** The responsive behavior requested for the Sidebar. */
+    variant: SidebarVariant;
+    /** Adds a mounted Trigger to the overlay dismissal layer. */
+    registerTrigger: (element: HTMLElement) => void;
+    /** Removes an unmounted Trigger from the overlay dismissal layer. */
+    unregisterTrigger: (element: HTMLElement) => void;
+    /** Requests a change to the overlay open state. */
+    requestOpenChange: (open: boolean, reason: SidebarOpenChangeReason) => void;
+};
+/**
+ * Publishes a Sidebar's state while no other Sidebar holds the boundary.
+ *
+ * @param boundary - The boundary the publishing Sidebar occupies.
+ * @param owner - The token identifying the publishing Sidebar.
+ * @param state - The state shared with the boundary's descendants.
+ *
+ * @returns Whether the publishing Sidebar holds the boundary.
+ */
+export declare function publishSidebarState(boundary: Element, owner: symbol, state: SidebarState): boolean;
+/**
+ * Releases a boundary when the requesting Sidebar still holds it.
+ *
+ * @param boundary - The boundary being released.
+ * @param owner - The token identifying the releasing Sidebar.
+ */
+export declare function releaseSidebarState(boundary: Element, owner: symbol): void;
+/**
+ * Reads the Sidebar state registered for a boundary.
+ *
+ * @param boundary - The boundary whose Sidebar is read, when one exists.
+ *
+ * @returns The registered state, or undefined while none is registered.
+ */
+export declare function readSidebarState(boundary: Element | null): SidebarState | undefined;
+/**
+ * Subscribes a listener to a boundary's Sidebar registration.
+ *
+ * @param boundary - The boundary being observed, when one exists.
+ * @param listener - The listener notified after every change.
+ *
+ * @returns The teardown removing the registered listener.
+ */
+export declare function subscribeToSidebarState(boundary: Element | null, listener: () => void): () => void;

package/dist/components/Skeleton/Skeleton.d.ts

@@ -1,14 +1,22 @@
 import { type HTMLAttributes } from "react";
 import "./styles/skeleton.css";
 /** A type representing the silhouette drawn by Skeleton. */
-export type SkeletonShape = "rectangle" | "circle";
+export type SkeletonShape = "rectangle" | "ellipse";
 /** A type representing properties for the Skeleton component. */
 export type SkeletonProps = Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
     /** The silhouette drawn by the loading placeholder. */
     shape?: SkeletonShape;
-    /** The CSS-compatible width of the loading placeholder. */
+    /**
+     * The CSS-compatible width of the loading placeholder.
+     *
+     * Placeholders otherwise fill their container.
+     */
     width?: number | string;
-    /** The CSS-compatible height of the loading placeholder. */
+    /**
+     * The CSS-compatible height of the loading placeholder.
+     *
+     * Placeholders otherwise match the height of the surrounding text.
+     */
     height?: number | string;
 };
 /**
@@ -22,9 +30,17 @@ export type SkeletonProps = Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
 declare const Skeleton: import("react").ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
     /** The silhouette drawn by the loading placeholder. */
     shape?: SkeletonShape;
-    /** The CSS-compatible width of the loading placeholder. */
+    /**
+     * The CSS-compatible width of the loading placeholder.
+     *
+     * Placeholders otherwise fill their container.
+     */
     width?: number | string;
-    /** The CSS-compatible height of the loading placeholder. */
+    /**
+     * The CSS-compatible height of the loading placeholder.
+     *
+     * Placeholders otherwise match the height of the surrounding text.
+     */
     height?: number | string;
 } & import("react").RefAttributes<HTMLDivElement>>;
 export default Skeleton;

package/dist/components/Table/Table.d.ts

@@ -1,143 +1,21 @@
-import { type HTMLAttributeAnchorTarget, type HTMLAttributes, type MouseEventHandler, type ReactNode, type TableHTMLAttributes, type TdHTMLAttributes, type ThHTMLAttributes } from "react";
-import { type ButtonProps } from "../Button";
-import { type IconType } from "../Icon";
+import { type ReactNode, type TableHTMLAttributes } from "react";
+import TableBody from "./components/TableBody";
+import TableCell from "./components/TableCell";
+import TableFoot from "./components/TableFoot";
+import TableHead from "./components/TableHead";
+import TableHeaderCell from "./components/TableHeaderCell";
+import TableRow from "./components/TableRow";
 import "./styles/table.css";
-/** A value rendered directly or formatted by a Table cell. */
-export type TableCellValue = boolean | Date | number | string;
-/** The horizontal alignment applied to Table cell content. */
-export type TableCellAlignment = "left" | "center" | "right";
-/** A type representing properties for the Table component. */
-export type TableProps = TableHTMLAttributes<HTMLTableElement> & {
-    /** The table sections, rows, and cells rendered inside the Table. */
-    children: ReactNode;
-    /** The additional class name applied to the horizontal scroll container. */
-    containerClassName?: string;
-};
-/** A type representing properties for the Table.Head component. */
-export type TableHeadProps = HTMLAttributes<HTMLTableSectionElement> & {
-    /** The rows rendered inside the Table head. */
-    children: ReactNode;
-};
-/** A type representing properties for the Table.Body component. */
-export type TableBodyProps = HTMLAttributes<HTMLTableSectionElement> & {
-    /** The rows rendered inside the Table body. */
-    children?: ReactNode;
-    /** The number of columns occupied by the generated empty-state cell. */
-    emptyColumnCount?: number;
-    /** The content displayed when children contain no explicit content. */
-    emptyMessage?: ReactNode;
-};
-/** A type representing properties for the Table.Foot component. */
-export type TableFootProps = HTMLAttributes<HTMLTableSectionElement> & {
-    /** The rows rendered inside the Table foot. */
-    children: ReactNode;
-};
-/** Shared native properties for every Table.Row configuration. */
-type TableRowBaseProps = Omit<HTMLAttributes<HTMLTableRowElement>, "aria-label" | "children" | "onClick"> & {
-    /** The cells rendered inside the Table row. */
-    children: ReactNode;
-};
-/** A type representing a static Table.Row configuration. */
-type TableStaticRowProps = {
-    /** The optional accessible name applied to the static row. */
-    "aria-label"?: string;
-    /** Static rows do not expose download behavior. */
-    download?: never;
-    /** Static rows do not expose a navigation destination. */
-    href?: never;
-    /** Static rows do not describe a linked resource language. */
-    hrefLang?: never;
-    /** Static rows do not expose whole-row activation. */
-    onClick?: never;
-    /** Static rows do not expose navigation interception. */
-    onNavigate?: never;
-    /** Static rows do not target a browsing context. */
-    target?: never;
-};
-/** A type representing a button-backed Table.Row configuration. */
-type TableButtonRowProps = {
-    /** The accessible name describing the whole-row action. */
-    "aria-label": string;
-    /** Button-backed rows do not expose download behavior. */
-    download?: never;
-    /** Button-backed rows do not expose a navigation destination. */
-    href?: never;
-    /** Button-backed rows do not describe a linked resource language. */
-    hrefLang?: never;
-    /** The callback invoked when the row's button is activated. */
-    onClick: MouseEventHandler<HTMLButtonElement>;
-    /** Button-backed rows do not expose navigation interception. */
-    onNavigate?: never;
-    /** Button-backed rows do not target a browsing context. */
-    target?: never;
-};
-/** A type representing a link-backed Table.Row configuration. */
-type TableLinkRowProps = {
-    /** The accessible name describing the whole-row link. */
-    "aria-label": string;
-    /** Whether the linked resource should be downloaded. */
-    download?: boolean | string;
-    /** The destination opened by whole-row activation. */
-    href: string;
-    /** The language of the linked resource. */
-    hrefLang?: string;
-    /** Link-backed rows do not expose button activation. */
-    onClick?: never;
-    /** The callback invoked when the row's link is activated. */
-    onNavigate?: MouseEventHandler<HTMLAnchorElement>;
-    /** The relationship between the table and linked resource. */
-    rel?: string;
-    /** The browsing context used to open the linked resource. */
-    target?: HTMLAttributeAnchorTarget;
-};
-/** A type representing properties for the Table.Row component. */
-export type TableRowProps = TableRowBaseProps & (TableButtonRowProps | TableLinkRowProps | TableStaticRowProps);
-/** Shared properties configuring a Table header cell. */
-type TableHeaderCellOwnProps = {
-    /** The horizontal alignment applied to the header content. */
-    align?: TableCellAlignment;
-    /** The content rendered inside the header cell. */
-    children?: ReactNode;
-    /** Whether the header pins its supported edge column during scrolling. */
-    sticky?: boolean;
-};
-/** A type representing properties for the Table.HeaderCell component. */
-export type TableHeaderCellProps = Omit<ThHTMLAttributes<HTMLTableCellElement>, "align" | "children"> & TableHeaderCellOwnProps;
-/** A type representing properties for the Table.ActionHeaderCell component. */
-export type TableActionHeaderCellProps = Omit<TableHeaderCellProps, "align">;
-/** A type representing properties for the Table.Cell component. */
-export type TableCellProps = Omit<TdHTMLAttributes<HTMLTableCellElement>, "align" | "children"> & {
-    /** The horizontal alignment applied to the cell content. */
-    align?: TableCellAlignment;
-    /** Content rendered when no value is supplied. */
-    children?: ReactNode;
-    /** A function transforming the supplied value into displayed content. */
-    format?: (value: TableCellValue) => ReactNode;
-    /** The maximum CSS width used to truncate overflowing content. */
-    truncate?: string;
-    /** The primitive value displayed or passed to the format function. */
-    value?: TableCellValue;
-};
-/** A type representing properties for the Table.Action component. */
-export type TableActionProps = Omit<ButtonProps<"button">, "as" | "children" | "className" | "fullWidth" | "icon" | "iconAlignment" | "shape" | "style" | "textAlignment" | "type" | "variant"> & {
-    /** The icon identifying the row action. */
-    icon: IconType;
-    /** The short Tooltip label and base accessible name for the row action. */
-    label: string;
-};
-/** A type representing properties for the Table.ActionCell component. */
-export type TableActionCellProps = Omit<TdHTMLAttributes<HTMLTableCellElement>, "align" | "children"> & {
-    /** The consistently styled row actions rendered inside the cell. */
-    children?: ReactNode;
-};
+export type { TableRowAction } from "./components/TableAction";
+export type { TableBodyProps } from "./components/TableBody";
+export type { TableCellProps } from "./components/TableCell";
+export type { TableFootProps } from "./components/TableFoot";
+export type { TableHeadProps } from "./components/TableHead";
+export type { TableHeaderCellProps } from "./components/TableHeaderCell";
+export type { TableRowProps } from "./components/TableRow";
+export type { TableCellAlignment, TableCellValue } from "./utils/cell";
 /** A type representing the complete compound Table component. */
 type TableComponent = typeof TableRoot & {
-    /** A consistently styled control operating on one Table row. */
-    Action: typeof TableAction;
-    /** The cell containing persistent row-level actions. */
-    ActionCell: typeof TableActionCell;
-    /** The header cell labelling the row-actions column. */
-    ActionHeaderCell: typeof TableActionHeaderCell;
     /** The body section containing Table data rows. */
     Body: typeof TableBody;
     /** A standard Table data cell. */
@@ -151,119 +29,13 @@ type TableComponent = typeof TableRoot & {
     /** A Table row. */
     Row: typeof TableRow;
 };
-/**
- * Renders the Table head section.
- *
- * @param props - The native section properties and header rows.
- * @param forwardedReference - The reference assigned to the head element.
- *
- * @returns The rendered Table head section.
- */
-declare const TableHead: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLTableSectionElement> & {
-    /** The rows rendered inside the Table head. */
-    children: ReactNode;
-} & import("react").RefAttributes<HTMLTableSectionElement>>;
-/**
- * Renders the Table body and its optional empty state.
- *
- * @param props - The native section, row, and empty-state properties.
- * @param forwardedReference - The reference assigned to the body element.
- *
- * @returns The rendered Table body section.
- */
-declare const TableBody: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLTableSectionElement> & {
-    /** The rows rendered inside the Table body. */
-    children?: ReactNode;
-    /** The number of columns occupied by the generated empty-state cell. */
-    emptyColumnCount?: number;
-    /** The content displayed when children contain no explicit content. */
-    emptyMessage?: ReactNode;
-} & import("react").RefAttributes<HTMLTableSectionElement>>;
-/**
- * Renders the Table foot section.
- *
- * @param props - The native section properties and footer rows.
- * @param forwardedReference - The reference assigned to the foot element.
- *
- * @returns The rendered Table foot section.
- */
-declare const TableFoot: import("react").ForwardRefExoticComponent<HTMLAttributes<HTMLTableSectionElement> & {
-    /** The rows rendered inside the Table foot. */
+/** A type representing properties for the Table component. */
+export type TableProps = TableHTMLAttributes<HTMLTableElement> & {
+    /** The table sections, rows, and cells rendered inside the Table. */
     children: ReactNode;
-} & import("react").RefAttributes<HTMLTableSectionElement>>;
-/**
- * Renders a native Table row without replacing its table semantics.
- *
- * @param props - The native row properties and cells.
- * @param forwardedReference - The reference assigned to the row element.
- *
- * @returns The rendered Table row.
- */
-declare const TableRow: import("react").ForwardRefExoticComponent<TableRowProps & import("react").RefAttributes<HTMLTableRowElement>>;
-/**
- * Renders a column header cell.
- *
- * @param props - The native header properties and displayed label.
- * @param forwardedReference - The reference assigned to the header cell.
- *
- * @returns The rendered Table column header.
- */
-declare const TableHeaderCell: import("react").ForwardRefExoticComponent<Omit<ThHTMLAttributes<HTMLTableCellElement>, "children" | "align"> & TableHeaderCellOwnProps & import("react").RefAttributes<HTMLTableCellElement>>;
-/**
- * Renders the header for a row-actions column.
- *
- * @param props - The native header properties and optional visible label.
- * @param forwardedReference - The reference assigned to the header cell.
- *
- * @returns The rendered Table actions header.
- */
-declare const TableActionHeaderCell: import("react").ForwardRefExoticComponent<TableActionHeaderCellProps & import("react").RefAttributes<HTMLTableCellElement>>;
-/**
- * Renders a data cell with optional value formatting and truncation.
- *
- * @param props - The native cell, content, and display properties.
- * @param forwardedReference - The reference assigned to the data cell.
- *
- * @returns The rendered Table data cell.
- */
-declare const TableCell: import("react").ForwardRefExoticComponent<Omit<TdHTMLAttributes<HTMLTableCellElement>, "children" | "align"> & {
-    /** The horizontal alignment applied to the cell content. */
-    align?: TableCellAlignment;
-    /** Content rendered when no value is supplied. */
-    children?: ReactNode;
-    /** A function transforming the supplied value into displayed content. */
-    format?: (value: TableCellValue) => ReactNode;
-    /** The maximum CSS width used to truncate overflowing content. */
-    truncate?: string;
-    /** The primitive value displayed or passed to the format function. */
-    value?: TableCellValue;
-} & import("react").RefAttributes<HTMLTableCellElement>>;
-/**
- * Renders one consistently styled control operating on a Table row.
- *
- * @param props - The short label, icon, and native button properties.
- * @param forwardedReference - The reference assigned to the action button.
- *
- * @returns The rendered Table row action.
- */
-declare const TableAction: import("react").ForwardRefExoticComponent<Omit<ButtonProps<"button">, "className" | "style" | "children" | "icon" | "variant" | "type" | "as" | "shape" | "fullWidth" | "iconAlignment" | "textAlignment"> & {
-    /** The icon identifying the row action. */
-    icon: IconType;
-    /** The short Tooltip label and base accessible name for the row action. */
-    label: string;
-} & import("react").RefAttributes<HTMLButtonElement>>;
-/**
- * Renders the cell containing controls for one Table row.
- *
- * @param props - The native cell properties and composed Table actions.
- * @param forwardedReference - The reference assigned to the action cell.
- *
- * @returns The rendered Table action cell.
- */
-declare const TableActionCell: import("react").ForwardRefExoticComponent<Omit<TdHTMLAttributes<HTMLTableCellElement>, "children" | "align"> & {
-    /** The consistently styled row actions rendered inside the cell. */
-    children?: ReactNode;
-} & import("react").RefAttributes<HTMLTableCellElement>>;
+    /** The additional class name applied to the horizontal scroll container. */
+    containerClassName?: string;
+};
 /**
  * Renders a semantic Table inside a keyboard-scrollable surface.
  *

package/dist/components/Table/components/TableAction.d.ts

@@ -0,0 +1,18 @@
+import { type ButtonProps } from "../../Button";
+import type { IconType } from "../../Icon";
+/** A type representing one consistently styled Table row action. */
+export type TableRowAction = Omit<ButtonProps<"button">, "as" | "children" | "className" | "fullWidth" | "icon" | "iconAlignment" | "shape" | "style" | "textAlignment" | "type" | "variant"> & {
+    /** The icon identifying the row action. */
+    icon: IconType;
+    /** The short Tooltip label and base accessible name for the row action. */
+    label: string;
+};
+/**
+ * Renders one consistently styled control operating on a Table row.
+ *
+ * @param props - The short label, icon, and native button properties.
+ *
+ * @returns The rendered Table row action.
+ */
+declare function TableAction(props: TableRowAction): import("react").JSX.Element;
+export default TableAction;