@llmnative/react 0.1.1 → 1.0.0

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

@@ -2,14 +2,15 @@ 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?: string;
     label?: string | React.ReactNode;
     badge?: BadgeProps;
     title?: string;
+    ariaLabel?: string;
     disabled?: boolean;
-    showLoader?: boolean;
-    iconClass?: string;
+    loading?: boolean;
+    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 +20,7 @@ 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>;
     loadingLabel?: string | React.ReactNode;
 }
 export declare const buttonBaseClass = "btn";
@@ -36,22 +37,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, 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,16 @@
 import React from 'react';
 import { UIProps } from '../..';
-interface CardProps extends UIProps {
+export interface CardProps extends UIProps {
     children: React.ReactNode;
     title?: string;
     header?: string | React.ReactNode;
     footer?: string | React.ReactNode;
-    headerClass?: string;
-    bodyClass?: string;
-    footerClass?: string;
-    showLoader?: boolean;
-    showArrow?: boolean;
+    headerClassName?: string;
+    bodyClassName?: string;
+    footerClassName?: string;
+    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

@@ -21,5 +21,5 @@ interface CodeProps extends UIProps {
     theme?: PrismTheme;
     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,26 @@ 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;
     overlays?: GalleryOverlay[];
-    onClick?: (record: GalleryRecord) => void;
+    onRowClick?: (record: GalleryRecord) => void;
     onSelectionChange?: GallerySelectionChangeHandler;
     sortable?: boolean | OrderConfig;
     pagination?: PaginationParams;
     scrollToTopOnChange?: boolean;
     scrollBehavior?: ScrollBehavior;
-    gutterSize?: 0 | 1 | 2 | 3 | 4 | 5;
-    rowCols?: 1 | 2 | 3 | 4 | 6;
+    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

@@ -17,5 +17,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

@@ -8,6 +8,8 @@ interface IconProps {
     /** Override the global icon provider for this instance only */
     provider?: IconProviderAdapter;
     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

@@ -15,5 +15,5 @@ type ImageProps = {
     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

@@ -12,5 +12,5 @@ interface ImageAvatarProps extends UIProps {
     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

@@ -7,5 +7,5 @@ interface LoaderProps extends UIProps {
     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,61 @@
 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 {
+export interface ModalYesNoProps {
     title?: React.ReactNode;
     children: React.ReactNode;
-    onYes?: (e: React.MouseEvent<HTMLButtonElement>) => Promise<boolean>;
-    onNo?: (e: React.MouseEvent<HTMLButtonElement>) => Promise<boolean>;
+    onYes?: (e: React.MouseEvent<HTMLElement>) => Promise<boolean>;
+    onNo?: (e: React.MouseEvent<HTMLElement>) => Promise<boolean>;
     onClose?: () => void;
 }
-interface ModalOkProps {
+export interface ModalOkProps {
     children: React.ReactNode;
     title?: React.ReactNode;
     onClose?: () => void;

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

@@ -1,18 +1,29 @@
 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[];
     children: (pageRecords: T[], pageOffset: number) => React.ReactNode;
     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,17 @@ import { UIProps } from '../..';
 type ColorType = "info" | "success" | "warning" | "danger" | "primary" | "secondary" | "light" | "dark";
 type ShapeType = "bar" | "circle";
 interface PercentageProps extends UIProps {
-    val?: number;
+    value?: number;
     max?: number;
     min?: number;
-    shape?: ShapeType;
-    type?: ColorType;
-    background?: ColorType;
+    appearance?: ShapeType;
+    variant?: ColorType;
+    trackVariant?: ColorType;
     thickness?: number;
     showText?: boolean;
     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,27 @@
 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);
+    value?: RecordProps[];
     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,26 @@ 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?: TableSelectionMode;
     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;
+    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;

package/dist/types/src/components/ui/fields/CodeEditor.d.ts

@@ -0,0 +1,43 @@
+import React from 'react';
+import { FormFieldProps } from '../../widgets/Form';
+import type { FieldValue } from '../../../providers/data/DataProvider';
+export type CodeEditorLanguage = 'liquid' | 'html' | 'json' | 'js' | 'ts' | 'css';
+export interface CodeSyntaxErrorDetails {
+    language: CodeEditorLanguage;
+    from: number;
+    to: number;
+    line: number;
+    column: number;
+    nodeName?: string;
+}
+export declare class CodeSyntaxError extends Error {
+    readonly language: CodeEditorLanguage;
+    readonly from: number;
+    readonly to: number;
+    readonly line: number;
+    readonly column: number;
+    readonly nodeName?: string;
+    constructor(message: string, details: CodeSyntaxErrorDetails);
+}
+export interface CodeValidationResult {
+    valid: boolean;
+    error?: CodeSyntaxError;
+}
+export declare const validateCodeSyntax: (code: string, language: CodeEditorLanguage) => Promise<void>;
+export declare const getCodeValidationResult: (code: string, language: CodeEditorLanguage) => Promise<CodeValidationResult>;
+export interface CodeEditorProps extends FormFieldProps {
+    language?: CodeEditorLanguage;
+    placeholder?: string;
+    minHeight?: number;
+    maxHeight?: number;
+    label?: string;
+    required?: boolean;
+    disabled?: boolean;
+    feedback?: string;
+    labelClassName?: string;
+    validateSyntax?: boolean;
+    validator?: (value: FieldValue) => string | undefined | Promise<string | undefined>;
+    extensions?: unknown[];
+}
+export declare const CodeEditor: React.FC<CodeEditorProps>;
+export default CodeEditor;

package/dist/types/src/components/ui/fields/ContextMenu.d.ts

@@ -0,0 +1,38 @@
+import React from 'react';
+import type { UIProps } from '../../types';
+export interface ContextMenuItem {
+    label: string;
+    value: string;
+    icon?: string;
+}
+export interface EditorContext {
+    textBeforeCaret: string;
+    textAfterCaret: string;
+    insert: (text: string) => void;
+    replace: (start: number, end: number, text: string) => void;
+}
+interface ContextMenuProps extends UIProps {
+    trigger: string;
+    searchable?: boolean;
+    onSelect?: (item: ContextMenuItem, context: EditorContext) => void;
+    children: React.ReactNode;
+}
+interface ContextMenuItemProps extends UIProps {
+    label: string;
+    value: string;
+    icon?: string;
+}
+interface ContextMenuHeadingProps {
+    children: React.ReactNode;
+    className?: string;
+}
+interface ContextMenuSeparatorProps {
+    className?: string;
+}
+type ContextMenuComponent = React.FC<ContextMenuProps> & {
+    Item: React.FC<ContextMenuItemProps>;
+    Heading: React.FC<ContextMenuHeadingProps>;
+    Separator: React.FC<ContextMenuSeparatorProps>;
+};
+declare const ContextMenu: ContextMenuComponent;
+export { ContextMenu };

package/dist/types/src/components/ui/fields/Crop.d.ts

@@ -1,6 +1,6 @@
 import React from "react";
 import { FileProps } from "./Upload";
-interface CropProps {
+export interface CropProps {
     fileName: string;
     type: string;
     scale: string;
@@ -16,6 +16,8 @@ interface ImageProps extends FileProps {
 export declare const CropImage: React.ForwardRefExoticComponent<{
     img: ImageProps;
     title?: string;
+    /** Custom aspect ratios. Defaults to { "1:1": 1, "3:4": 0.75, "4:3": 1.33 }. */
+    scales?: Record<string, number>;
 } & React.RefAttributes<unknown>>;
 interface FileNameEditorProps {
     value: string;
@@ -23,5 +25,5 @@ interface FileNameEditorProps {
     scale?: string;
     label?: string;
 }
-export declare const FileNameEditor: ({ value, onChange, label, scale, }: FileNameEditorProps) => React.JSX.Element;
+export declare const FileNameEditor: ({ value, onChange, label, scale }: FileNameEditorProps) => React.JSX.Element;
 export {};

package/dist/types/src/components/ui/fields/ImageField.d.ts

@@ -0,0 +1,31 @@
+import React from 'react';
+import { FormFieldProps } from '../../widgets/Form';
+export interface ImageFieldValue {
+    src: string;
+    alt: string;
+    srcset?: string;
+    sizes?: string;
+}
+export interface ImageFieldProps extends FormFieldProps {
+    /**
+     * Pixel widths to generate as responsive srcset variants.
+     * Each width produces a canvas-resized copy.
+     * Default: [] (no variants).
+     * Example: [400, 800]
+     */
+    srcsetWidths?: number[];
+    /**
+     * Storage path prefix for uploading resized variants.
+     * Requires a StorageProvider ancestor.
+     * If omitted, variants are kept as local blob URLs.
+     * Example: "/content/posts/images"
+     */
+    uploadPath?: string;
+    label?: string;
+    required?: boolean;
+    disabled?: boolean;
+    feedback?: string;
+    id?: string;
+    labelClassName?: string;
+}
+export declare const ImageField: ({ name, onChange, defaultValue, label, required, disabled, feedback, srcsetWidths, uploadPath, id, labelClassName, inheritWrapperClassName, wrapperClassName, className, before, after, }: ImageFieldProps) => React.JSX.Element;