@llmnative/react 0.1.1 → 1.1.0

package/dist/types/src/components/ui/Badge.d.ts

@@ -1,27 +1,34 @@
 import React from "react";
 import type { UIProps } from '../types';
+/** Semantic color variant for `<Badge>` and any component that accepts a badge. */
 export type BadgeType = "info" | "success" | "warning" | "danger" | "primary" | "secondary" | "light" | "dark";
 export type BadgeDescriptor = {
     content: React.ReactNode;
-    type?: BadgeType;
+    variant?: BadgeType;
     className?: string;
 };
 export type BadgeProps = React.ReactNode | BadgeDescriptor;
 export declare function isBadgeDescriptor(value: BadgeProps | undefined): value is BadgeDescriptor;
 export declare function normalizeBadgeProps(value: BadgeProps | undefined, fallbackType?: BadgeType, fallbackClassName?: string): BadgeDescriptor | undefined;
 export type BadgeOverlayProps = {
+    /** Shorthand badge descriptor (content + variant). */
     badge?: BadgeProps;
+    /** Badge content when not using the `badge` shorthand. */
     content?: React.ReactNode;
-    type?: BadgeType;
+    /** Badge color variant. */
+    variant?: BadgeType;
+    /** Fallback variant when none is specified. */
     defaultType?: BadgeType;
     className?: string;
+    /** When `true` and no badge is provided, renders children without wrapping. */
     descriptorOnly?: boolean;
     children?: React.ReactNode;
 };
-export declare const BadgeOverlay: ({ badge, content, type, defaultType, className, descriptorOnly, children }: BadgeOverlayProps) => React.ReactNode;
+export declare const BadgeOverlay: ({ badge, content, variant, defaultType, className, descriptorOnly, children }: BadgeOverlayProps) => React.ReactNode;
 export type BadgeComponentProps = {
     children: string | React.ReactNode;
-    type?: BadgeType;
+    /** Semantic color variant. */
+    variant?: BadgeType;
 } & UIProps;
-declare const Badge: ({ children, type, pre, post, wrapClass, className }: BadgeComponentProps) => React.JSX.Element;
+declare const Badge: ({ children, variant, before, after, wrapperClassName, className }: BadgeComponentProps) => React.JSX.Element;
 export default Badge;

package/dist/types/src/components/ui/Buttons.d.ts

@@ -2,14 +2,17 @@ import React from 'react';
 import type { MotionUIProps, UIProps } from '../types';
 import { BadgeProps } from './Badge';
 export interface IButton extends MotionUIProps {
-    onClick?: (e: any) => any;
+    onClick?: (e: React.MouseEvent<HTMLElement>) => unknown;
+    /** Icon name or path for a leading icon. */
     icon?: string;
     label?: string | React.ReactNode;
+    /** Badge descriptor shown as overlay on the button. */
     badge?: BadgeProps;
     title?: string;
+    /** Accessible label for screen readers. Required when the button is icon-only. */
+    ariaLabel?: string;
     disabled?: boolean;
-    showLoader?: boolean;
-    iconClass?: string;
+    iconClassName?: string;
     style?: React.CSSProperties;
     variant?: "primary" | "secondary" | "danger" | "success" | "warning" | "info" | "light" | "dark" | "outline-primary" | "outline-secondary" | "outline-danger" | "outline-success" | "link";
 }
@@ -19,7 +22,8 @@ export type SetMessagePayload = {
     totalChunks?: number;
 };
 export interface LoadingButtonProps extends Omit<IButton, "onClick"> {
-    onClick?: (e: any, setMessage?: (payload: SetMessagePayload) => any) => Promise<any>;
+    onClick?: (e: React.MouseEvent<HTMLElement>, setMessage?: (payload: SetMessagePayload) => void) => Promise<unknown>;
+    loading?: boolean;
     loadingLabel?: string | React.ReactNode;
 }
 export declare const buttonBaseClass = "btn";
@@ -36,22 +40,22 @@ export declare const buttonOutlineSecondaryClass = "btn-outline-secondary";
 export declare const buttonOutlineDangerClass = "btn-outline-danger";
 export declare const buttonOutlineSuccessClass = "btn-outline-success";
 export declare const buttonLinkClass = "btn-link";
-export declare const LoadingButton: ({ onClick, icon, label, badge, title, disabled, showLoader, pre, post, wrapClass, className, iconClass, style, loadingLabel, variant, motion: motionConfig }?: LoadingButtonProps) => React.JSX.Element;
-export declare const ActionButton: ({ onClick, icon, label, badge, title, disabled, pre, post, wrapClass, className, iconClass, style, variant, motion: motionConfig }?: IButton) => React.JSX.Element;
+export declare const LoadingButton: ({ onClick, icon, label, badge, title, ariaLabel, disabled, loading, before, after, wrapperClassName, className, iconClassName, style, loadingLabel, variant, motion: motionConfig }?: LoadingButtonProps) => React.JSX.Element;
+export declare const ActionButton: ({ onClick, icon, label, badge, title, ariaLabel, disabled, before, after, wrapperClassName, className, iconClassName, style, variant, motion: motionConfig }?: IButton) => React.JSX.Element;
 interface BackLinkProps extends UIProps {
     label?: string;
 }
-export declare const BackLink: ({ label, pre, post, wrapClass, className }: BackLinkProps) => React.JSX.Element;
+export declare const BackLink: ({ label, before, after, wrapperClassName, className }: BackLinkProps) => React.JSX.Element;
 interface GoSiteProps extends UIProps {
     label: string;
-    url: string;
+    href: string;
 }
-export declare const GoSite: ({ label, url, pre, post, wrapClass, className }: GoSiteProps) => React.JSX.Element;
+export declare const GoSite: ({ label, href, before, after, wrapperClassName, className }: GoSiteProps) => React.JSX.Element;
 interface ReferSiteProps extends UIProps {
     title: string;
-    url: string;
-    imageUrl: string;
+    href: string;
+    imageSrc: string;
     width?: number | string;
 }
-export declare const ReferSite: ({ title, url, imageUrl, width, pre, post, wrapClass, className }: ReferSiteProps) => React.JSX.Element;
+export declare const ReferSite: ({ title, href, imageSrc, width, before, after, wrapperClassName, className }: ReferSiteProps) => React.JSX.Element;
 export {};

package/dist/types/src/components/ui/Card.d.ts

@@ -1,15 +1,19 @@
 import React from 'react';
 import { UIProps } from '../..';
-interface CardProps extends UIProps {
+export interface CardProps extends UIProps {
     children: React.ReactNode;
+    /** Card title shown in the header area. */
     title?: string;
+    /** Custom header content (replaces the default title row). */
     header?: string | React.ReactNode;
     footer?: string | React.ReactNode;
-    headerClass?: string;
-    bodyClass?: string;
-    footerClass?: string;
-    showLoader?: boolean;
-    showArrow?: boolean;
+    headerClassName?: string;
+    bodyClassName?: string;
+    footerClassName?: string;
+    /** Show a loading skeleton instead of content. */
+    loading?: boolean;
+    before?: React.ReactNode;
+    after?: React.ReactNode;
 }
-declare const Card: ({ children, title, header, footer, showLoader, showArrow, wrapClass, className, headerClass, bodyClass, footerClass }: CardProps) => React.JSX.Element;
+declare const Card: ({ children, title, header, footer, loading, wrapperClassName, className, headerClassName, bodyClassName, footerClassName, before, after, }: CardProps) => React.JSX.Element;
 export default Card;

package/dist/types/src/components/ui/Code.d.ts

@@ -16,10 +16,14 @@ type PrismTheme = keyof typeof THEMES;
 export type PrismBackground = 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'light' | 'dark' | 'white' | 'black' | 'transparent' | 'default';
 interface CodeProps extends UIProps {
     children: string;
+    /** Syntax highlight language (e.g. `"tsx"`, `"python"`). */
     language?: PrismLanguage;
+    /** Show a copy-to-clipboard button. */
     showCopy?: boolean;
+    /** Prism color theme. */
     theme?: PrismTheme;
+    /** Background style variant. */
     background?: PrismBackground;
 }
-declare const Code: ({ language, children, pre, post, wrapClass, className, showCopy, theme, background, }: CodeProps) => React.JSX.Element;
+declare const Code: ({ language, children, before, after, wrapperClassName, className, showCopy, theme, background, }: CodeProps) => React.JSX.Element;
 export default Code;

package/dist/types/src/components/ui/Gallery.d.ts

@@ -29,27 +29,27 @@ export type GalleryOverlay = {
 };
 export type GallerySelectionState = RecordSelectionState<GalleryRecord>;
 export type GallerySelectionChangeHandler = (selection: GallerySelectionState) => void;
-interface GalleryProps extends UIProps {
-    body?: GalleryRecord[];
-    Header?: string | React.ReactNode;
-    Footer?: string | React.ReactNode;
+export interface GalleryProps extends UIProps {
+    records?: GalleryRecord[];
+    header?: string | React.ReactNode;
+    footer?: string | React.ReactNode;
+    /** Overlay badges rendered on each gallery item. */
     overlays?: GalleryOverlay[];
-    onClick?: (record: GalleryRecord) => void;
+    onRowClick?: (record: GalleryRecord) => void;
     onSelectionChange?: GallerySelectionChangeHandler;
+    /** Enable sorting, optionally with a default sort config. */
     sortable?: boolean | OrderConfig;
     pagination?: PaginationParams;
-    scrollToTopOnChange?: boolean;
-    scrollBehavior?: ScrollBehavior;
-    gutterSize?: 0 | 1 | 2 | 3 | 4 | 5;
-    rowCols?: 1 | 2 | 3 | 4 | 6;
+    /** Grid gap size (Tailwind spacing scale). */
+    gap?: 0 | 1 | 2 | 3 | 4 | 5;
+    columns?: 1 | 2 | 3 | 4 | 6;
     groupBy?: string | string[];
     selectedKeys?: string[];
-    selectedRowKeys?: string[];
-    scrollClass?: string;
-    headerClass?: string;
-    bodyClass?: string;
-    footerClass?: string;
-    selectedClass?: string;
+    scrollClassName?: string;
+    headerClassName?: string;
+    bodyClassName?: string;
+    footerClassName?: string;
+    selectedClassName?: string;
 }
-declare const Gallery: ({ body, Header, Footer, overlays, onClick, onSelectionChange, sortable, pagination, gutterSize, rowCols, groupBy, selectedKeys, selectedRowKeys, pre, post, wrapClass, className, headerClass, scrollClass, bodyClass, footerClass, selectedClass }: GalleryProps) => React.JSX.Element;
+declare const Gallery: ({ records, header, footer, overlays, onRowClick, onSelectionChange, sortable, pagination, gap, columns, groupBy, selectedKeys, before, after, wrapperClassName, className, headerClassName, scrollClassName, bodyClassName, footerClassName, selectedClassName }: GalleryProps) => React.JSX.Element;
 export default Gallery;

package/dist/types/src/components/ui/GridSystem.d.ts

@@ -5,7 +5,10 @@ type ContainerProps = {
     style?: CSSProperties;
     onClick?: () => void;
 };
-type ColProps = ContainerProps & {
+type ColProps = {
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
     defaultSize?: number;
     xxl?: number | 'auto';
     xl?: number | 'auto';
@@ -17,5 +20,5 @@ type ColProps = ContainerProps & {
 export declare const Wrapper: ({ children, className, style, onClick, }: ContainerProps) => React.JSX.Element;
 export declare const Container: ({ children, className, style }: ContainerProps) => React.JSX.Element;
 export declare const Row: ({ children, className, style }: ContainerProps) => React.JSX.Element;
-export declare const Col: ({ children, className, style, xxl, xl, lg, md, sm, xs }: ColProps) => React.JSX.Element;
+export declare const Col: ({ children, className, style, defaultSize, xxl, xl, lg, md, sm, xs }: ColProps) => React.JSX.Element;
 export {};

package/dist/types/src/components/ui/Icon.d.ts

@@ -1,13 +1,18 @@
 import React from 'react';
 import type { IconProviderAdapter } from '../../providers/icon/IconProvider';
 interface IconProps {
+    /** Icon name (provider-specific identifier). */
     name?: string;
+    /** Icon size in px. Defaults to `16`. */
     size?: number;
     className?: string;
     style?: React.CSSProperties;
     /** Override the global icon provider for this instance only */
     provider?: IconProviderAdapter;
+    /** Accessible label for screen readers. */
     label?: string;
+    /** Provider-specific variant — e.g. PhosphorWeight: 'thin'|'light'|'regular'|'bold'|'fill'|'duotone'. Ignored by providers that don't support it. */
+    weight?: string;
 }
-declare const Icon: ({ name, size, className, style, provider: overrideProvider, label }: IconProps) => React.JSX.Element | null;
+declare const Icon: ({ name, size, className, style, provider: overrideProvider, label, weight }: IconProps) => React.JSX.Element | null;
 export default Icon;

package/dist/types/src/components/ui/Image.d.ts

@@ -3,17 +3,23 @@ import { UIProps } from '../..';
 export type ImageFit = 'cover' | 'contain' | 'fill' | 'scale-down' | 'none';
 export type ImagePosition = 'center' | 'top' | 'bottom' | 'left' | 'right' | 'top left' | 'top right' | 'bottom left' | 'bottom right';
 type ImageProps = {
+    /** Image source URL. */
     src: string;
+    /** Placeholder image URL shown while loading. */
     placeholder?: string;
     label?: string;
     title?: string;
+    /** Object-fit style for the image. */
     fit?: ImageFit;
+    /** Object-position for the image. */
     position?: ImagePosition;
+    /** Feedback element shown below the image (e.g. caption, error). */
     feedback?: React.ReactNode;
     width?: number;
     height?: number;
+    /** Responsive srcset attribute. */
     srcset?: string;
     sizes?: string;
 } & UIProps;
-declare const Image: ({ src, placeholder, label, title, fit, position, feedback, width, height, srcset, sizes, pre, post, wrapClass, className }: ImageProps) => React.JSX.Element;
+declare const Image: ({ src, placeholder, label, title, fit, position, feedback, width, height, srcset, sizes, before, after, wrapperClassName, className }: ImageProps) => React.JSX.Element;
 export default Image;

package/dist/types/src/components/ui/ImageAvatar.d.ts

@@ -3,14 +3,17 @@ import type { UIProps } from '../types';
 import type { BadgeDescriptor } from './Badge';
 export type AvatarFit = 'cover' | 'contain' | 'fill' | 'scale-down' | 'none';
 interface ImageAvatarProps extends UIProps {
+    /** Avatar image URL. */
     src: string;
     width?: number;
     height?: number;
     title?: string;
     alt?: string;
+    /** Object-fit style for the avatar image. */
     fit?: AvatarFit;
+    /** Badge descriptor shown as an overlay on the avatar. */
     badge?: BadgeDescriptor;
     feedback?: React.ReactNode;
 }
-declare const ImageAvatar: ({ src, width, height, title, alt, fit, badge, feedback, pre, post, wrapClass, className, }: ImageAvatarProps) => React.JSX.Element;
+declare const ImageAvatar: ({ src, width, height, title, alt, fit, badge, feedback, before, after, wrapperClassName, className, }: ImageAvatarProps) => React.JSX.Element;
 export default ImageAvatar;

package/dist/types/src/components/ui/Loader.d.ts

@@ -1,11 +1,13 @@
 import React from 'react';
 import { UIProps } from '../..';
 interface LoaderProps extends UIProps {
+    /** When `true`, renders the loading indicator instead of children. */
     show?: boolean;
     children: React.ReactNode;
+    /** Icon name for the loading indicator. */
     icon?: string;
     title?: string;
     description?: string;
 }
-declare function Loader({ children, show, icon, title, description, pre, post, wrapClass, className }: LoaderProps): string | number | boolean | Iterable<React.ReactNode> | React.JSX.Element | null | undefined;
+declare function Loader({ children, show, icon, title, description, before, after, wrapperClassName, className }: LoaderProps): string | number | boolean | Iterable<React.ReactNode> | React.JSX.Element | null | undefined;
 export default Loader;

package/dist/types/src/components/ui/LocaleSwitcher.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+export interface LocaleSwitcherProps {
+    /** Icon name passed to the Icon component. Default: 'Globe'. */
+    icon?: string;
+    /** Optional visible label rendered before the select. */
+    label?: string;
+    /** Override display names for locale codes. Merged with built-in defaults. */
+    labels?: Record<string, string>;
+    /** 'code' shows abbreviated codes (EN, IT). 'full' shows the full language name. Default: 'code'. */
+    appearance?: 'code' | 'full';
+    className?: string;
+}
+declare const LocaleSwitcher: ({ icon, label, labels, appearance, className }: LocaleSwitcherProps) => React.JSX.Element | null;
+export default LocaleSwitcher;

package/dist/types/src/components/ui/Modal.d.ts

@@ -1,34 +1,65 @@
 import React from 'react';
 import type { MotionUIProps } from '../types';
-export type ModalSaveHandler = (e: React.MouseEvent<HTMLButtonElement>) => Promise<boolean>;
-export type ModalDeleteHandler = (e: React.MouseEvent<HTMLButtonElement>) => Promise<boolean>;
-interface ModalProps extends MotionUIProps {
+export type ModalSaveHandler = (e: React.MouseEvent<HTMLElement>) => Promise<boolean>;
+export type ModalDeleteHandler = (e: React.MouseEvent<HTMLElement>) => Promise<boolean>;
+/** Props for the `<Modal>` component. */
+export interface ModalProps extends MotionUIProps {
+    /** Modal body content. */
     children: React.ReactNode;
+    /** Text or element rendered as the modal title in the header. */
     title?: React.ReactNode;
+    /** Fully custom header content (replaces the default title row). */
     header?: React.ReactNode;
+    /** Fully custom footer content. Pass `false` to hide the footer bar entirely. */
     footer?: React.ReactNode | false;
+    /** Called when the modal should close (×, backdrop click, Cancel). */
     onClose?: () => void;
+    /** Async save handler wired to the Save button. Return `true` to close. */
     onSave?: ModalSaveHandler;
+    /** Async delete handler wired to the Delete button. Return `true` to close. */
     onDelete?: ModalDeleteHandler;
-    size?: "sm" | "md" | "lg" | "xl" | "fullscreen";
+    /** Modal width: `"sm"` · `"md"` · `"lg"` · `"xl"` · `"2xl"` · `"fullscreen"`. */
+    size?: "sm" | "md" | "lg" | "xl" | "2xl" | "fullscreen";
+    /** Anchor position: `"center"` (default) · `"top"` · `"left"` · `"right"` · `"bottom"`. */
     position?: "center" | "top" | "left" | "right" | "bottom";
-    buttonFullscreen?: boolean;
-    buttonCancel?: boolean;
-    headerClass?: string;
-    titleClass?: string;
-    subTitleClass?: string;
-    bodyClass?: string;
-    footerClass?: string;
+    /** Show a fullscreen toggle button in the header. Defaults to `false`. */
+    allowFullscreen?: boolean;
+    /** Show the Cancel button in the footer. Defaults to `true`. */
+    showCancel?: boolean;
+    /** Extra CSS classes on the header container. */
+    headerClassName?: string;
+    /** Extra CSS classes on the title element. */
+    titleClassName?: string;
+    /** Extra CSS classes on the subtitle element. */
+    subtitleClassName?: string;
+    /** Extra CSS classes on the body container. */
+    bodyClassName?: string;
+    /** Extra CSS classes on the footer container. */
+    footerClassName?: string;
+    /** Close the modal when the user clicks the backdrop. Defaults to `true`. */
     closeOnBackdrop?: boolean;
+    /** CSS `z-index` override (useful when stacking modals). */
+    zIndex?: number;
+    /**
+     * When `true` this modal is visually "behind" another modal stacked on top.
+     * The panel becomes 10% wider (so its edge peeks out from behind the upper modal),
+     * gains a semi-transparent dimming overlay, its backdrop is suppressed (the upper
+     * modal's backdrop handles interaction blocking), and its cover becomes non-interactive.
+     */
+    stackedBehind?: boolean;
 }
-interface ModalYesNoProps {
+/** Props for a confirm/deny modal dialog with Yes/No buttons. */
+export interface ModalYesNoProps {
     title?: React.ReactNode;
     children: React.ReactNode;
-    onYes?: (e: React.MouseEvent<HTMLButtonElement>) => Promise<boolean>;
-    onNo?: (e: React.MouseEvent<HTMLButtonElement>) => Promise<boolean>;
+    /** Async handler for the Yes button. Return `true` to close. */
+    onYes?: (e: React.MouseEvent<HTMLElement>) => Promise<boolean>;
+    /** Async handler for the No button. Return `true` to close. */
+    onNo?: (e: React.MouseEvent<HTMLElement>) => Promise<boolean>;
     onClose?: () => void;
 }
-interface ModalOkProps {
+/** Props for a simple acknowledgment modal with an OK button. */
+export interface ModalOkProps {
     children: React.ReactNode;
     title?: React.ReactNode;
     onClose?: () => void;

package/dist/types/src/components/ui/Pagination.d.ts

@@ -1,18 +1,31 @@
 import React from 'react';
 import { UIProps } from "../index";
+/**
+ * Pagination configuration shared between `<Pagination>` and `<Grid pagination={...}>`.
+ * All fields are optional — omit `limit` to disable pagination entirely.
+ */
 export type PaginationParams = {
+    /** Initial page (1-based). Defaults to `1`. */
     page?: number;
+    /** Records per page. Omit to show all records unpaginated. */
     limit?: number;
-    navLimit?: number;
+    /** Maximum page-number buttons to render before collapsing to ellipsis. */
+    maxPageButtons?: number;
+    /** Scroll the page back to the top on page change. */
     scrollToTopOnChange?: boolean;
+    /** `scrollIntoView` scroll behavior when `scrollToTopOnChange` is enabled. */
     scrollBehavior?: ScrollBehavior;
+    /** Horizontal alignment of the page-button bar: `"start"`, `"center"`, or `"end"`. */
     align?: "start" | "center" | "end";
+    /** Stick the pagination bar to the bottom of the viewport while scrolling. */
     sticky?: boolean;
 };
 interface PaginationProps<T> extends UIProps, PaginationParams {
-    recordSet: T[];
+    records: T[];
+    /** Render function receiving paginated records and current page offset. */
     children: (pageRecords: T[], pageOffset: number) => React.ReactNode;
+    /** Portal target element — renders pagination bar outside the normal flow. */
     appendTo?: HTMLElement | null;
 }
-declare const Pagination: <T>({ recordSet, children, limit, page, navLimit, appendTo, pre, post, className, wrapClass, scrollToTopOnChange, scrollBehavior, align, sticky }: PaginationProps<T>) => React.JSX.Element;
+declare const Pagination: <T>({ records, children, limit, page, maxPageButtons, appendTo, before, after, className, wrapperClassName, scrollToTopOnChange, scrollBehavior, align, sticky }: PaginationProps<T>) => React.JSX.Element;
 export default Pagination;

package/dist/types/src/components/ui/Percentage.d.ts

@@ -3,17 +3,26 @@ import { UIProps } from '../..';
 type ColorType = "info" | "success" | "warning" | "danger" | "primary" | "secondary" | "light" | "dark";
 type ShapeType = "bar" | "circle";
 interface PercentageProps extends UIProps {
-    val?: number;
+    /** Current value. */
+    value?: number;
+    /** Maximum value (defaults to `100`). */
     max?: number;
+    /** Minimum value. */
     min?: number;
-    shape?: ShapeType;
-    type?: ColorType;
-    background?: ColorType;
+    /** Visual shape: `"bar"` (default) or `"circle"`. */
+    appearance?: ShapeType;
+    /** Progress bar color. */
+    variant?: ColorType;
+    /** Track (background) color. */
+    trackVariant?: ColorType;
+    /** Bar/circle thickness in px. */
     thickness?: number;
+    /** Show percentage text label. */
     showText?: boolean;
+    /** Circle diameter in px (circle mode only). */
     size?: number;
     fontSize?: number;
     label?: string;
 }
-declare const Percentage: ({ val, max, min, shape, type, background, thickness, showText, size, fontSize, label, pre, post, wrapClass, className }: PercentageProps) => React.JSX.Element;
+declare const Percentage: ({ value, max, min, appearance, variant, trackVariant, thickness, showText, size, fontSize, label, before, after, wrapperClassName, className }: PercentageProps) => React.JSX.Element;
 export default Percentage;

package/dist/types/src/components/ui/Repeat.d.ts

@@ -1,18 +1,26 @@
 import React from 'react';
 import { FieldOnChange } from '../widgets/Form';
+import { RecordProps } from '../../providers/data/DataProvider';
+export interface RepeatCallbackArgs {
+    record: RecordProps;
+    records: RecordProps[];
+    index: number;
+    remove: () => void;
+}
 interface RepeatProps {
     name: string;
-    children: React.ReactNode | ((record: any) => React.ReactNode);
-    value?: any[];
+    children: React.ReactNode | ((args: RepeatCallbackArgs) => React.ReactNode);
     onChange?: FieldOnChange;
-    onAdd?: (value: any[]) => void;
+    onAdd?: (value: RecordProps[]) => void;
     onRemove?: (index: number) => void;
     className?: string;
     layout?: 'vertical' | 'horizontal' | 'inline';
-    min?: number;
-    max?: number;
+    minItems?: number;
+    maxItems?: number;
     label?: string;
+    labelPosition?: 'top' | 'bottom';
+    hideRemoveButton?: boolean;
     readOnly?: boolean;
 }
-declare const Repeat: ({ name, children, onChange, onAdd, onRemove, className, layout, min, max, label, readOnly, }: RepeatProps) => React.JSX.Element;
+declare const Repeat: ({ name, children, onChange, onAdd, onRemove, className, layout, minItems, maxItems, label, labelPosition, hideRemoveButton, readOnly, }: RepeatProps) => React.JSX.Element;
 export default Repeat;

package/dist/types/src/components/ui/Tab.d.ts

@@ -1,19 +1,46 @@
 import React from 'react';
 import type { MotionUIProps } from '../types';
 export type TabPosition = "default" | "top" | "left" | "right" | "bottom";
+/** Props for a single `<TabItem>` inside a `<Tab>`. */
 interface TabItemProps {
+    /** Tab header label (text or ReactNode). */
     label: React.ReactNode;
+    /** Tab panel content. */
     children: React.ReactNode;
 }
 interface TabLayoutProps {
     menu: React.ReactNode;
     content: React.ReactNode;
+    menuClassName?: string;
+    contentClassName?: string;
 }
+type TabLayoutConfig = {
+    shellClassName: string;
+    menuClassName: string;
+    contentClassName: string;
+    itemClassName: string;
+    triggerClassName: string;
+    activeTriggerClassName: string;
+    inactiveTriggerClassName: string;
+};
+/** Props for the `<Tab>` container. */
 interface TabProps extends MotionUIProps {
+    /** `<TabItem>` children that define the tabs. */
     children: React.ReactNode;
-    defaultTab?: number;
-    tabPosition?: TabPosition;
+    /** 0-based index of the initially selected tab. Defaults to `0`. */
+    defaultIndex?: number;
+    /** Called with the new index whenever the active tab changes. */
+    onChange?: (index: number) => void;
+    /** Spatial layout of the tab bar: `"default"` (underline top), `"top"`, `"left"`, `"right"`, `"bottom"`. */
+    layout?: TabPosition;
+    /** Additional classes applied to the tablist container. */
+    menuClassName?: string;
+    /** Additional classes applied to the active pane wrapper. */
+    contentClassName?: string;
 }
+export declare function getTabLayoutConfig(layout: TabPosition): TabLayoutConfig;
+export declare function getTabTriggerClassName(layout: TabPosition, active: boolean, className?: string): string;
+export declare function getTabPaneClassName(className?: string): string;
 export declare const TabLayouts: Record<TabPosition, (props: TabLayoutProps) => JSX.Element>;
 export declare const TabItem: React.FC<TabItemProps>;
 declare const Tab: React.FC<TabProps>;

package/dist/types/src/components/ui/TabDynamic.d.ts

@@ -1,13 +1,14 @@
 import React from 'react';
 import { TabPosition } from './Tab';
 import { FieldOnChange } from '../widgets/Form';
+import { RecordProps } from '../../providers/data/DataProvider';
 interface TabDynamicProps {
-    children: React.ReactNode | ((record: any) => React.ReactNode);
+    children: React.ReactNode | ((record: RecordProps) => React.ReactNode);
     name: string;
     onChange?: FieldOnChange;
-    onAdd?: (value: any[]) => void;
+    onAdd?: (value: RecordProps[]) => void;
     onRemove?: (index: number) => void;
-    value?: any[];
+    value?: RecordProps[];
     label?: string;
     min?: number;
     max?: number;

package/dist/types/src/components/ui/Table.d.ts

@@ -19,25 +19,29 @@ export type TableSelectionState = RecordSelectionState<RecordProps>;
 export type TableSelectionMode = 'single' | 'multiple';
 export type TableSelectionChangeHandler = (selection: TableSelectionState) => void;
 export type TableReorderHandler = (reorderedRecords: RecordArray, meta: TableReorderMeta) => void;
-interface TableProps extends UIProps {
-    header?: TableHeaderProp[];
-    body?: RecordArray;
-    Footer?: string | React.ReactNode;
-    onClick?: (record: RecordProps) => void;
+export interface TableProps extends UIProps {
+    columns?: TableHeaderProp[];
+    records?: RecordArray;
+    footer?: string | React.ReactNode;
+    onRowClick?: (record: RecordProps) => void;
     onReorder?: TableReorderHandler;
     onSelectionChange?: TableSelectionChangeHandler;
-    selectionMode?: TableSelectionMode;
+    /** Selection mode: `"single"` or `"multiple"`. */
+    selection?: TableSelectionMode;
+    /** Enable sorting, optionally with a default sort config. */
     sortable?: boolean | OrderConfig;
     pagination?: PaginationParams;
     activeKey?: string | null;
     selectedKeys?: string[];
-    selectedRowKeys?: string[];
-    headerClass?: string;
-    bodyClass?: string;
-    footerClass?: string;
-    heightClass?: string;
-    scrollClass?: string;
-    selectedClass?: string;
+    groupBy?: string | string[];
+    headerClassName?: string;
+    bodyClassName?: string;
+    footerClassName?: string;
+    heightClassName?: string;
+    scrollClassName?: string;
+    selectedClassName?: string;
+    /** Custom cell renderer. Receives the record, column key, and absolute row index. */
+    renderCell?: (record: RecordProps, key: string, absoluteIndex: number) => React.ReactNode;
 }
-declare function Table({ header, body, Footer, onClick, onReorder, onSelectionChange, selectionMode, sortable, pagination, activeKey, selectedKeys, selectedRowKeys, pre, post, wrapClass, className, headerClass, bodyClass, footerClass, heightClass, scrollClass, selectedClass }: TableProps): React.JSX.Element;
+declare function Table({ columns, records, footer, onRowClick, onReorder, onSelectionChange, selection, sortable, pagination, activeKey, selectedKeys, groupBy, before, after, wrapperClassName, className, headerClassName, bodyClassName, footerClassName, heightClassName, scrollClassName, selectedClassName, renderCell }: TableProps): React.JSX.Element;
 export default Table;