@platform-blocks/ui 0.1.1

package/lib/components/CopyButton/index.d.ts

@@ -0,0 +1,2 @@
+export { CopyButton } from './CopyButton';
+export type { CopyButtonProps } from './types';

package/lib/components/CopyButton/types.d.ts

@@ -0,0 +1,37 @@
+import { ViewStyle } from 'react-native';
+export interface CopyButtonProps {
+    /** The text to copy to clipboard */
+    value: string;
+    /** Callback fired after copy action */
+    onCopy?: (value: string) => void;
+    /** If true, only the icon is shown (no button chrome or label) */
+    iconOnly?: boolean;
+    /** Accessible label for the button */
+    label?: string;
+    /** Title for the toast */
+    toastTitle?: string;
+    /** Detailed message for the toast */
+    toastMessage?: string;
+    /** Size of the button */
+    size?: 'xs' | 'sm' | 'md';
+    /** Style overrides for the button container */
+    style?: ViewStyle;
+    /** Disable the "copied to clipboard" toast */
+    disableToast?: boolean;
+    /** Tooltip text */
+    tooltip?: string;
+    /** Tooltip position */
+    tooltipPosition?: 'top' | 'bottom' | 'left' | 'right';
+    /** Presentation mode: default button (legacy) or bare icon */
+    mode?: 'button' | 'icon';
+    /** Button variant override when in button mode */
+    buttonVariant?: 'none' | 'secondary' | 'ghost' | 'filled' | 'outline' | 'gradient' | undefined;
+    /** Icon name to display (defaults to copy) when in icon mode */
+    iconName?: string;
+    /** Icon name to display after copy (default check) in icon mode */
+    copiedIconName?: string;
+    /** Base icon color (icon mode) */
+    iconColor?: string;
+    /** Copied state icon color (icon mode) */
+    copiedIconColor?: string;
+}

package/lib/components/DataTable/AdvancedFilterControl.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import type { DataTableColumn, DataTableFilter } from './types';
+interface AdvancedFilterControlProps<T = any> {
+    column: DataTableColumn<T>;
+    currentFilter?: DataTableFilter;
+    onFilterChange: (filter: DataTableFilter | null) => void;
+    data?: T[];
+}
+export declare function AdvancedFilterControl<T = any>({ column, currentFilter, onFilterChange, data }: AdvancedFilterControlProps<T>): React.JSX.Element;
+export {};

package/lib/components/DataTable/ColumnSettings.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import type { DataTableColumn } from './types';
+interface ColumnSettingsProps<T = any> {
+    column: DataTableColumn<T>;
+    onClose: () => void;
+    onColumnUpdate?: (columnKey: string, updates: Partial<DataTableColumn<T>>) => void;
+    onHideColumn?: (columnKey: string) => void;
+    anchorRect?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}
+export declare function ColumnSettings<T = any>({ column, onClose, onColumnUpdate, onHideColumn, anchorRect }: ColumnSettingsProps<T>): React.JSX.Element;
+export {};

package/lib/components/DataTable/DataTable.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { DataTableProps } from './types';
+export type { DataTableProps, DataTableColumn, DataTableFilter, DataTableSort, DataTablePagination, SortDirection, FilterType, ColumnDataType } from './types';
+export declare const DataTable: <T>({ id, data, columns, loading, error, emptyMessage, searchable, searchPlaceholder, searchValue: controlledSearchValue, onSearchChange, sortBy, onSortChange, filters, onFilterChange, pagination, onPaginationChange, selectable, selectedRows, onSelectionChange, getRowId, onRowClick, editMode, onEditModeChange, onCellEdit, bulkActions, variant, density, height, virtual, style, hoverHighlight, enableColumnResizing, rowFeatureToggle, initialHiddenColumns, onColumnVisibilityChange, onColumnSettings, showColumnVisibilityManager, rowsPerPageOptions, showRowsPerPageControl, rowActions, actionsColumnWidth, fullWidth, rowBorderWidth, rowBorderColor, rowBorderStyle, columnBorderWidth, columnBorderColor, columnBorderStyle, showOuterBorder, outerBorderWidth, outerBorderColor, expandableRowRender, initialExpandedRows, expandedRows: controlledExpandedRows, onExpandedRowsChange, allowMultipleExpanded, expandIcon, collapseIcon, ...props }: DataTableProps<T>) => React.JSX.Element;
+export default DataTable;

package/lib/components/DataTable/hooks/useColumnSettings.d.ts

@@ -0,0 +1,12 @@
+import type { DataTableColumn } from '../types';
+interface UseColumnSettingsProps<T = any> {
+    columns: DataTableColumn<T>[];
+    onColumnUpdate?: (columnKey: string, updates: Partial<DataTableColumn<T>>) => void;
+    onHideColumn?: (columnKey: string) => void;
+}
+interface UseColumnSettingsReturn {
+    openColumnSettings: (columnKey: string, anchorElement: any) => void;
+    closeColumnSettings: () => void;
+}
+export declare function useColumnSettings<T = any>({ columns, onColumnUpdate, onHideColumn }: UseColumnSettingsProps<T>): UseColumnSettingsReturn;
+export {};

package/lib/components/DataTable/hooks/useDataTableState.d.ts

@@ -0,0 +1,41 @@
+import type { DataTableFilter, DataTableSort, DataTablePagination, DataTableColumn, DataTableProps } from '../types';
+interface UseDataTableStateProps<T> {
+    data: T[];
+    columns: DataTableColumn<T>[];
+    initialSortBy?: DataTableSort[];
+    initialFilters?: DataTableFilter[];
+    initialPagination?: DataTablePagination;
+    initialSelectedRows?: (string | number)[];
+    initialExpandedRows?: (string | number)[];
+    initialHiddenColumns?: string[];
+    getRowId?: (row: T, index: number) => string | number;
+    rowFeatureToggle?: DataTableProps<T>['rowFeatureToggle'];
+}
+interface UseDataTableStateReturn<T> {
+    processedData: T[];
+    totalFiltered: number;
+    searchValue: string;
+    setSearchValue: (value: string) => void;
+    sortBy: DataTableSort[];
+    setSortBy: (sorts: DataTableSort[]) => void;
+    handleSort: (columnKey: string) => void;
+    filters: DataTableFilter[];
+    setFilters: (filters: DataTableFilter[]) => void;
+    activeFilters: DataTableFilter[];
+    pagination?: DataTablePagination;
+    setPagination?: (pagination: DataTablePagination) => void;
+    selectedRows: (string | number)[];
+    setSelectedRows: (rows: (string | number)[]) => void;
+    isAllSelected: boolean;
+    isIndeterminate: boolean;
+    handleRowSelect: (rowId: string | number) => void;
+    handleSelectAll: () => void;
+    expandedRows: (string | number)[];
+    setExpandedRows: (rows: (string | number)[]) => void;
+    handleRowExpand: (rowId: string | number) => void;
+    hiddenColumns: string[];
+    setHiddenColumns: (columns: string[]) => void;
+    visibleColumns: DataTableColumn<T>[];
+}
+export declare function useDataTableState<T>({ data, columns, initialSortBy, initialFilters, initialPagination, initialSelectedRows, initialExpandedRows, initialHiddenColumns, getRowId, rowFeatureToggle }: UseDataTableStateProps<T>): UseDataTableStateReturn<T>;
+export {};

package/lib/components/DataTable/hooks/useRowSelection.d.ts

@@ -0,0 +1,40 @@
+interface UseRowSelectionProps {
+    /** All row IDs in current view (after filtering/pagination) */
+    allRowIds: (string | number)[];
+    /** Initial selected rows */
+    initialSelectedRows?: (string | number)[];
+    /** Controlled selected rows */
+    selectedRows?: (string | number)[];
+    /** Selection change handler */
+    onSelectionChange?: (selectedRows: (string | number)[]) => void;
+    /** Whether to persist selection across pagination */
+    persistAcrossPagination?: boolean;
+}
+interface UseRowSelectionReturn {
+    /** Currently selected row IDs */
+    selectedRows: (string | number)[];
+    /** Whether all visible rows are selected */
+    isAllSelected: boolean;
+    /** Whether some (but not all) visible rows are selected */
+    isIndeterminate: boolean;
+    /** Toggle selection for a single row */
+    toggleRow: (rowId: string | number, event?: {
+        shiftKey?: boolean;
+        ctrlKey?: boolean;
+        metaKey?: boolean;
+    }) => void;
+    /** Toggle selection for all visible rows */
+    toggleAll: () => void;
+    /** Select a range of rows (for shift+click) */
+    selectRange: (fromId: string | number, toId: string | number) => void;
+    /** Clear all selections */
+    clearSelection: () => void;
+    /** Select all rows (including those not currently visible if persistAcrossPagination is true) */
+    selectAll: (allPossibleIds?: (string | number)[]) => void;
+    /** Get number of selected rows */
+    selectionCount: number;
+    /** Check if a specific row is selected */
+    isRowSelected: (rowId: string | number) => boolean;
+}
+export declare function useRowSelection({ allRowIds, initialSelectedRows, selectedRows: controlledSelectedRows, onSelectionChange, persistAcrossPagination }: UseRowSelectionProps): UseRowSelectionReturn;
+export {};

package/lib/components/DataTable/index.d.ts

@@ -0,0 +1 @@
+export { DataTable, type DataTableProps, type DataTableColumn, type DataTableFilter, type DataTableSort, type DataTablePagination } from './DataTable';

package/lib/components/DataTable/types.d.ts

@@ -0,0 +1,223 @@
+import React from 'react';
+import { SpacingProps } from '../../core/utils';
+export type SortDirection = 'asc' | 'desc' | null;
+export type FilterType = 'text' | 'number' | 'select' | 'date' | 'boolean';
+export type ColumnDataType = 'text' | 'number' | 'date' | 'boolean' | 'currency' | 'percentage';
+export interface DataTableColumn<T = any> {
+    /** Unique identifier for the column */
+    key: string;
+    /** Display header for the column */
+    header: React.ReactNode;
+    /** Accessor function or key path */
+    accessor: keyof T | ((row: T) => any);
+    /** Custom cell renderer */
+    cell?: (value: any, row: T, index: number) => React.ReactNode;
+    /** Whether column is sortable */
+    sortable?: boolean;
+    /** Optional custom comparison function overriding default sorting */
+    compare?: (a: any, b: any, rowA: T, rowB: T) => number;
+    /** Whether column is filterable */
+    filterable?: boolean;
+    /** Filter type for this column */
+    filterType?: FilterType;
+    /** Filter options for select filter type */
+    filterOptions?: Array<{
+        label: string;
+        value: any;
+    }>;
+    /** Preferred width */
+    width?: number | string;
+    /** Minimum width */
+    minWidth?: number;
+    /** Maximum width */
+    maxWidth?: number;
+    /** Whether the user can resize this column */
+    resizable?: boolean;
+    /** Whether cells in this column are editable (when table in edit mode) */
+    editable?: boolean;
+    /** Validation function returning an error message or null */
+    validate?: (value: any) => string | null;
+    /** Data type for formatting & validation */
+    dataType?: ColumnDataType;
+    /** Text alignment */
+    align?: 'left' | 'center' | 'right';
+    /** Sticky positioning */
+    sticky?: 'left' | 'right';
+}
+export interface DataTableFilter {
+    column: string;
+    value: any;
+    operator: 'eq' | 'ne' | 'lt' | 'lte' | 'gt' | 'gte' | 'contains' | 'startsWith' | 'endsWith';
+}
+export interface DataTableSort {
+    column: string;
+    direction: SortDirection;
+}
+export interface DataTablePagination {
+    page: number;
+    pageSize: number;
+    total: number;
+}
+export interface DataTableProps<T = any> extends SpacingProps {
+    /** Stable id for user preference persistence */
+    id?: string;
+    /** Data rows */
+    data: T[];
+    /** Column definitions */
+    columns: DataTableColumn<T>[];
+    /** Loading state */
+    loading?: boolean;
+    /** Error message (when defined overrides table body) */
+    error?: string | null;
+    /** Message to display when there is no data */
+    emptyMessage?: string;
+    /** Enable global search input */
+    searchable?: boolean;
+    /** Placeholder text for global search */
+    searchPlaceholder?: string;
+    /** Controlled global search value */
+    searchValue?: string;
+    /** Global search change handler */
+    onSearchChange?: (value: string) => void;
+    /** Current sorting state */
+    sortBy?: DataTableSort[];
+    /** Sorting change callback */
+    onSortChange?: (sort: DataTableSort[]) => void;
+    /** Active column filters */
+    filters?: DataTableFilter[];
+    /** Filter change callback */
+    onFilterChange?: (filters: DataTableFilter[]) => void;
+    /** Pagination state */
+    pagination?: DataTablePagination;
+    /** Pagination change handler */
+    onPaginationChange?: (pagination: DataTablePagination) => void;
+    /** Enable row selection */
+    selectable?: boolean;
+    /** Selected row identifiers */
+    selectedRows?: (string | number)[];
+    /** Selection change handler */
+    onSelectionChange?: (selected: (string | number)[]) => void;
+    /** Function to extract a stable id for each row */
+    getRowId?: (row: T, index: number) => string | number;
+    /** Row click handler */
+    onRowClick?: (row: T, index: number) => void;
+    /** Whether table is in edit mode */
+    editMode?: boolean;
+    /** Edit mode toggle callback */
+    onEditModeChange?: (editMode: boolean) => void;
+    /** Commit cell edit */
+    onCellEdit?: (rowIndex: number, columnKey: string, newValue: any) => void;
+    /** Bulk action definitions */
+    bulkActions?: Array<{
+        /** Unique key */
+        key: string;
+        /** Button label */
+        label: string;
+        /** Optional icon */
+        icon?: React.ReactNode;
+        /** Action invoked with selected row ids & full data */
+        action: (selectedRows: (string | number)[], data: T[]) => void;
+    }>;
+    /** Visual table variant */
+    variant?: 'default' | 'striped' | 'bordered';
+    /** Row density */
+    density?: 'compact' | 'normal' | 'comfortable';
+    /** Fixed table height (enables internal scroll) */
+    height?: number;
+    /** Enable FlashList-powered virtualization for large datasets */
+    virtual?: boolean;
+    /** Container style override */
+    style?: any;
+    /** Enable interactive column resizing */
+    enableColumnResizing?: boolean;
+    /** Per-row feature overrides */
+    rowFeatureToggle?: (row: T, index: number) => ({
+        selectable?: boolean;
+        editable?: boolean;
+        sortable?: boolean;
+        filterable?: boolean;
+        searchable?: boolean;
+    } | null | undefined);
+    /** Initially hidden column keys */
+    initialHiddenColumns?: string[];
+    /** Hidden column change callback */
+    onColumnVisibilityChange?: (hidden: string[]) => void;
+    /** Column settings action callback */
+    onColumnSettings?: (columnKey: string) => void;
+    /** Show built-in column visibility manager button */
+    showColumnVisibilityManager?: boolean;
+    /** Pagination size choices */
+    rowsPerPageOptions?: number[];
+    /** Show rows-per-page selector */
+    showRowsPerPageControl?: boolean;
+    /** Per-row action icon buttons (renders trailing actions column when provided) */
+    rowActions?: (row: T, index: number) => Array<{
+        /** Unique action key */
+        key: string;
+        /** Icon to display (icon-only buttons recommended) */
+        icon?: React.ReactNode;
+        /** Optional text label (not typically shown in compact cell) */
+        label?: string;
+        /** Action handler */
+        onPress?: (row: T, index: number) => void;
+        /** Disable this action */
+        disabled?: boolean;
+        /** Whether to hide this action */
+        hidden?: boolean;
+        /** Optional tooltip text (future enhancement; currently ignored) */
+        tooltip?: string;
+    }>;
+    /** Width of the actions column */
+    actionsColumnWidth?: number;
+    /** Custom header background color */
+    headerBackgroundColor?: string;
+    /** Show enhanced loading skeletons instead of basic loading text */
+    enhancedLoading?: boolean;
+    /** Show enhanced empty state with icon and description */
+    enhancedEmptyState?: boolean;
+    /** Enable enhanced hover effects */
+    enhancedHover?: boolean;
+    /** Custom row hover color */
+    hoverColor?: string;
+    /** Enable enhanced selection styling */
+    enhancedSelection?: boolean;
+    /** Show row dividers */
+    showRowDividers?: boolean;
+    /** Custom border color for enhanced styling */
+    borderColor?: string;
+    /** Enable simple row background hover highlight */
+    hoverHighlight?: boolean;
+    /** Make table take full width of container */
+    fullWidth?: boolean;
+    /** Custom row border width */
+    rowBorderWidth?: number;
+    /** Custom row border color */
+    rowBorderColor?: string;
+    /** Row border style */
+    rowBorderStyle?: 'solid' | 'dashed' | 'dotted';
+    /** Custom column border width */
+    columnBorderWidth?: number;
+    /** Custom column border color */
+    columnBorderColor?: string;
+    /** Column border style */
+    columnBorderStyle?: 'solid' | 'dashed' | 'dotted';
+    /** Whether to show outer border around entire table */
+    showOuterBorder?: boolean;
+    /** Outer border width */
+    outerBorderWidth?: number;
+    /** Outer border color */
+    outerBorderColor?: string;
+    /** Function to render expanded row content */
+    expandableRowRender?: (row: T, index: number) => React.ReactNode;
+    /** Initially expanded row identifiers */
+    initialExpandedRows?: (string | number)[];
+    /** Controlled expanded rows */
+    expandedRows?: (string | number)[];
+    /** Expanded rows change handler */
+    onExpandedRowsChange?: (expanded: (string | number)[]) => void;
+    /** Allow multiple rows to be expanded at once */
+    allowMultipleExpanded?: boolean;
+    /** Custom expand/collapse icons */
+    expandIcon?: React.ReactNode;
+    collapseIcon?: React.ReactNode;
+}

package/lib/components/DatePicker/DatePicker.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { View } from 'react-native';
+import type { DatePickerProps } from './types';
+export declare const DatePicker: React.ForwardRefExoticComponent<DatePickerProps & React.RefAttributes<View>>;

package/lib/components/DatePicker/index.d.ts

@@ -0,0 +1,8 @@
+export { DatePicker } from './DatePicker';
+export { Calendar } from '../Calendar/Calendar';
+export { MiniCalendar } from '../MiniCalendar/MiniCalendar';
+export { Month } from '../Calendar/Month';
+export { Day } from '../Calendar/Day';
+export { dateUtils, extractFirstDate } from './utils';
+export type { DatePickerProps, DateTimePickerProps, CalendarType, CalendarValue, CalendarLevel, } from './types';
+export type { CalendarProps, MiniCalendarProps, MonthProps, DayProps, } from '../Calendar/types';

package/lib/components/DatePicker/types.d.ts

@@ -0,0 +1,47 @@
+import { ViewStyle } from 'react-native';
+import { BaseInputProps } from '../Input/types';
+import { SizeValue } from '../../core/theme/types';
+import type { CalendarProps as CoreCalendarProps, CalendarType, CalendarValue, CalendarLevel } from '../Calendar/types';
+export interface DatePickerProps {
+    /** Selected value; type depends on `type` prop */
+    value?: CalendarValue;
+    /** Initial value for uncontrolled usage */
+    defaultValue?: CalendarValue;
+    /** Called when value changes */
+    onChange?: (value: CalendarValue) => void;
+    /** Selection behavior */
+    type?: CalendarType;
+    /** Pass-through customization for underlying Calendar */
+    calendarProps?: Partial<CoreCalendarProps>;
+    /** Optional container style for the inline calendar */
+    style?: ViewStyle;
+    /** Test identifier */
+    testID?: string;
+    /** Accessibility label for the inline calendar region */
+    accessibilityLabel?: string;
+    /** Accessibility hint for the inline calendar region */
+    accessibilityHint?: string;
+}
+/**
+ * DateTimePickerProps – combines calendar date + time selection.
+ */
+export interface DateTimePickerProps extends Omit<BaseInputProps, 'value' | 'onChangeText'> {
+    value?: Date | null;
+    defaultValue?: Date | null;
+    onChange?: (value: Date | null) => void;
+    calendarProps?: Partial<CoreCalendarProps>;
+    withTime?: boolean;
+    timeFormat?: 12 | 24;
+    withSeconds?: boolean;
+    minuteStep?: number;
+    secondStep?: number;
+    placeholder?: string;
+    displayFormat?: string;
+    clearable?: boolean;
+    dropdownType?: 'modal' | 'popover';
+    closeOnSelect?: boolean;
+    onOpen?: () => void;
+    onClose?: () => void;
+    size?: SizeValue;
+}
+export type { CalendarType, CalendarValue, CalendarLevel };

package/lib/components/DatePicker/utils.d.ts

@@ -0,0 +1,30 @@
+import type { CalendarValue } from '../Calendar/types';
+export declare const extractFirstDate: (val: CalendarValue | null | undefined) => Date | undefined;
+export declare const dateUtils: {
+    startOfDay: (date: Date) => Date;
+    endOfDay: (date: Date) => Date;
+    startOfMonth: (date: Date) => Date;
+    endOfMonth: (date: Date) => Date;
+    startOfYear: (date: Date) => Date;
+    endOfYear: (date: Date) => Date;
+    addDays: (date: Date, days: number) => Date;
+    addMonths: (date: Date, months: number) => Date;
+    addYears: (date: Date, years: number) => Date;
+    isSameDay: (date1: Date, date2: Date) => boolean;
+    isSameMonth: (date1: Date, date2: Date) => boolean;
+    isSameYear: (date1: Date, date2: Date) => boolean;
+    isToday: (date: Date) => boolean;
+    isWeekend: (date: Date, weekendDays?: number[]) => boolean;
+    isInRange: (date: Date, start: Date | null, end: Date | null) => boolean;
+    isBetween: (date: Date, start: Date | null, end: Date | null) => boolean;
+    getDaysInMonth: (date: Date) => number;
+    getMonthCalendar: (date: Date, firstDayOfWeek?: number) => Date[][];
+    getMonthNames: (locale?: string) => string[];
+    getWeekdayNames: (locale?: string, format?: "long" | "short" | "narrow") => string[];
+    formatDate: (date: Date, format: string, locale?: string) => string;
+    parseDate: (value: string) => Date | null;
+    getDecadeRange: (year: number) => [number, number];
+    getYearsInDecade: (date: Date) => number[];
+    clampDate: (date: Date, minDate?: Date, maxDate?: Date) => Date;
+    isDateDisabled: (date: Date, minDate?: Date, maxDate?: Date, excludeDate?: (date: Date) => boolean) => boolean;
+};

package/lib/components/DatePickerInput/DatePickerInput.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import { View } from 'react-native';
+import type { DatePickerInputProps } from './types';
+export declare const DatePickerInput: React.ForwardRefExoticComponent<DatePickerInputProps & React.RefAttributes<View>>;

package/lib/components/DatePickerInput/index.d.ts

@@ -0,0 +1,2 @@
+export { DatePickerInput } from './DatePickerInput';
+export type { DatePickerInputProps, CalendarType, CalendarValue, CalendarLevel } from './types';

package/lib/components/DatePickerInput/types.d.ts

@@ -0,0 +1,41 @@
+import { BaseInputProps } from '../Input/types';
+import { SizeValue } from '../../core/theme/types';
+import type { CalendarProps as CoreCalendarProps, CalendarType, CalendarValue, CalendarLevel } from '../Calendar/types';
+export interface DatePickerInputProps extends Omit<BaseInputProps, 'value' | 'onChangeText'> {
+    /** Selected value; type depends on `type` prop */
+    value?: CalendarValue;
+    /** Initial value for uncontrolled usage */
+    defaultValue?: CalendarValue;
+    /** Called when value changes */
+    onChange?: (value: CalendarValue) => void;
+    /** Selection behavior */
+    type?: CalendarType;
+    /** Pass-through customization for underlying Calendar */
+    calendarProps?: Partial<CoreCalendarProps>;
+    /** Input placeholder text */
+    placeholder?: string;
+    /** Format string for displaying value in the input */
+    displayFormat?: string;
+    /** Serialization/parsing format (reserved for future) */
+    valueFormat?: string;
+    /** Show a clear button */
+    clearable?: boolean;
+    /** Visual size */
+    size?: SizeValue;
+    /** Disable interaction */
+    disabled?: boolean;
+    /** Show required indicator */
+    withAsterisk?: boolean;
+    /** @deprecated Set to false to render inline calendar. Prefer using <DatePicker> directly. */
+    withInput?: boolean;
+    /** Presentation modality */
+    dropdownType?: 'modal' | 'popover';
+    /** Close picker after single selection (for single mode) */
+    closeOnSelect?: boolean;
+    /** Lifecycle events */
+    onOpen?: () => void;
+    onClose?: () => void;
+    onFocus?: () => void;
+    onBlur?: () => void;
+}
+export type { CalendarType, CalendarValue, CalendarLevel };

package/lib/components/Dialog/Dialog.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { DialogProps } from './types';
+export declare function Dialog({ visible, variant, title, children, closable, backdrop, backdropClosable, shouldClose, onClose, width, height, style }: DialogProps): React.JSX.Element | null;

package/lib/components/Dialog/DialogContext.d.ts

@@ -0,0 +1,11 @@
+import React, { ReactNode } from 'react';
+import { DialogConfig, DialogContextValue } from './types';
+type DialogRequestListener = () => void;
+export declare function onDialogsRequested(listener: DialogRequestListener): () => void;
+export declare function DialogProvider({ children }: {
+    children: ReactNode;
+}): React.JSX.Element;
+export declare function useDialog(): DialogContextValue;
+export declare function useDialogApi(): Pick<DialogContextValue, "openDialog" | "closeDialog" | "removeDialog" | "closeAllDialogs">;
+export declare function useDialogs(): DialogConfig[];
+export {};

package/lib/components/Dialog/DialogRenderer.d.ts

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare function DialogRenderer(): React.JSX.Element | null;

package/lib/components/Dialog/hooks/useSimpleDialog.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+export interface UseSimpleDialogOptions {
+    title?: string;
+    closable?: boolean;
+    backdrop?: boolean;
+    backdropClosable?: boolean;
+    width?: number;
+    height?: number;
+}
+/**
+ * Simple hook for opening dialogs with less boilerplate
+ */
+export declare function useSimpleDialog(): {
+    modal: (content: React.ReactNode, options?: UseSimpleDialogOptions) => string;
+    bottomSheet: (content: React.ReactNode, options?: UseSimpleDialogOptions) => string;
+    fullScreen: (content: React.ReactNode, options?: UseSimpleDialogOptions) => string;
+    confirm: (message: string, options?: UseSimpleDialogOptions & {
+        onConfirm?: () => void;
+        onCancel?: () => void;
+        confirmText?: string;
+        cancelText?: string;
+    }) => string;
+    close: (id: string) => void;
+    closeAll: () => void;
+};

package/lib/components/Dialog/index.d.ts

@@ -0,0 +1,6 @@
+export { Dialog } from './Dialog';
+export { DialogProvider, useDialog, useDialogApi, useDialogs, onDialogsRequested } from './DialogContext';
+export { DialogRenderer } from './DialogRenderer';
+export { useSimpleDialog } from './hooks/useSimpleDialog';
+export type { DialogProps, DialogConfig, DialogContextValue } from './types';
+export type { UseSimpleDialogOptions } from './hooks/useSimpleDialog';

package/lib/components/Dialog/types.d.ts

@@ -0,0 +1,35 @@
+import { ReactNode } from 'react';
+export interface DialogProps {
+    visible: boolean;
+    variant?: 'modal' | 'bottomsheet' | 'fullscreen';
+    title?: string | null;
+    children: ReactNode;
+    closable?: boolean;
+    backdrop?: boolean;
+    backdropClosable?: boolean;
+    shouldClose?: boolean;
+    onClose?: () => void;
+    width?: number;
+    height?: number;
+    style?: object;
+}
+export interface DialogConfig {
+    id: string;
+    variant: 'modal' | 'bottomsheet' | 'fullscreen';
+    content: ReactNode;
+    title?: string;
+    closable?: boolean;
+    onClose?: () => void;
+    backdrop?: boolean;
+    backdropClosable?: boolean;
+    isClosing?: boolean;
+}
+export interface DialogContextValue {
+    dialogs: DialogConfig[];
+    openDialog: (config: Omit<DialogConfig, 'id'> & {
+        id?: string;
+    }) => string;
+    closeDialog: (id: string) => void;
+    removeDialog: (id: string) => void;
+    closeAllDialogs: () => void;
+}

package/lib/components/Disclaimer/Disclaimer.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { type TextProps } from '../Text';
+import type { SpacingValue } from '../../core/theme/types';
+export interface DisclaimerProps extends Omit<TextProps, 'children'> {
+    children: React.ReactNode;
+    mt?: SpacingValue;
+}
+/**
+ * Disclaimer component for showing muted helper text below components
+ */
+export declare const Disclaimer: React.FC<DisclaimerProps>;