tekivex-ui 3.5.0 → 3.18.1

package/dist/src/components/TkxDataGrid.d.ts

@@ -1,4 +1,10 @@
 import { type ReactNode } from 'react';
+export interface CellEditorRenderArgs<T = any> {
+    value: any;
+    row: T;
+    onCommit: (v: any) => void;
+    onCancel: () => void;
+}
 export interface DataGridColumn<T = any> {
     key: string;
     header: string;
@@ -10,6 +16,16 @@ export interface DataGridColumn<T = any> {
     renderHeader?: (col: DataGridColumn<T>) => ReactNode;
     align?: 'left' | 'center' | 'right';
     pinned?: 'left' | 'right';
+    aggregate?: 'sum' | 'avg' | 'count' | 'min' | 'max' | ((rows: T[]) => string | number);
+    editable?: boolean | ((row: T) => boolean);
+    editor?: 'text' | 'number' | 'select' | ((args: CellEditorRenderArgs<T>) => ReactNode);
+    editorOptions?: {
+        options?: Array<{
+            value: any;
+            label: string;
+        }>;
+    };
+    validateCell?: (value: any, row: T) => string | null;
 }
 export interface TkxDataGridProps<T = any> {
     columns: DataGridColumn<T>[];
@@ -40,5 +56,25 @@ export interface TkxDataGridProps<T = any> {
     hasMore?: boolean;
     loadingMore?: boolean;
     loadMoreThreshold?: number;
+    groupBy?: string;
+    defaultExpandedGroups?: 'all' | 'none' | string[];
+    onGroupToggle?: (groupKey: string, expanded: boolean) => void;
+    onCellEdit?: (params: {
+        rowId: string | number;
+        columnKey: string;
+        newValue: any;
+        oldValue: any;
+        row: T;
+    }) => void | Promise<void>;
+    onCellEditStart?: (params: {
+        rowId: string | number;
+        columnKey: string;
+        row: T;
+    }) => void;
+    onCellEditCancel?: (params: {
+        rowId: string | number;
+        columnKey: string;
+        row: T;
+    }) => void;
 }
-export declare function TkxDataGrid<T = any>({ columns, data, rowKey, selectable, selectedRows, onSelectionChange, sortable, onSort, loading, emptyMessage, stickyHeader, striped, bordered, compact, maxHeight, onRowClick, virtualScroll, rowHeight, showFilters, filterValues: externalFilterValues, onFilterChange, pageSize, showExport, exportFileName, onLoadMore, hasMore, loadingMore, loadMoreThreshold, }: TkxDataGridProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare function TkxDataGrid<T = any>({ columns, data, rowKey, selectable, selectedRows, onSelectionChange, sortable, onSort, loading, emptyMessage, stickyHeader, striped, bordered, compact, maxHeight, onRowClick, virtualScroll, rowHeight, showFilters, filterValues: externalFilterValues, onFilterChange, pageSize, showExport, exportFileName, onLoadMore, hasMore, loadingMore, loadMoreThreshold, groupBy, defaultExpandedGroups, onGroupToggle, onCellEdit, onCellEditStart, onCellEditCancel, }: TkxDataGridProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/src/components/TkxFlowChart.d.ts

@@ -0,0 +1,52 @@
+import * as React from 'react';
+import { type CSSProperties, type ReactNode } from 'react';
+export interface FlowNode {
+    id: string;
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+    label: string;
+    color?: string;
+    data?: unknown;
+}
+export interface FlowEdge {
+    id: string;
+    from: string;
+    to: string;
+    label?: string;
+    color?: string;
+}
+export interface FlowChartData {
+    nodes: FlowNode[];
+    edges: FlowEdge[];
+}
+export interface Viewport {
+    x: number;
+    y: number;
+    scale: number;
+}
+export interface TkxFlowChartProps {
+    data: FlowChartData;
+    onChange: (next: FlowChartData) => void;
+    selectedId?: string | null;
+    onSelect?: (id: string | null) => void;
+    initialViewport?: Viewport;
+    draggable?: boolean;
+    pannable?: boolean;
+    zoomable?: boolean;
+    minZoom?: number;
+    maxZoom?: number;
+    height?: number;
+    showGrid?: boolean;
+    showControls?: boolean;
+    renderNode?: (node: FlowNode, isSelected: boolean) => ReactNode;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function nodeAnchors(n: FlowNode): {
+    out: [number, number];
+    in: [number, number];
+};
+export declare function edgePath(from: FlowNode, to: FlowNode): string;
+export declare const TkxFlowChart: React.ForwardRefExoticComponent<TkxFlowChartProps & React.RefAttributes<HTMLDivElement>>;

package/dist/src/components/TkxFormBuilder.d.ts

@@ -0,0 +1,34 @@
+import { type CSSProperties } from 'react';
+export type FormFieldType = 'text' | 'email' | 'number' | 'textarea' | 'select' | 'radio' | 'checkbox' | 'date';
+export interface FormFieldOption {
+    label: string;
+    value: string;
+}
+export interface FormField {
+    id: string;
+    type: FormFieldType;
+    name: string;
+    label: string;
+    placeholder?: string;
+    helpText?: string;
+    required?: boolean;
+    options?: FormFieldOption[];
+    min?: number;
+    max?: number;
+    pattern?: string;
+}
+export interface FormSchema {
+    title?: string;
+    description?: string;
+    fields: FormField[];
+}
+export interface TkxFormBuilderProps {
+    schema: FormSchema;
+    onChange: (next: FormSchema) => void;
+    allowedTypes?: FormFieldType[];
+    defaultTab?: 'design' | 'preview' | 'json';
+    style?: CSSProperties;
+    className?: string;
+}
+export declare function validateField(field: FormField, value: unknown): string | null;
+export declare function TkxFormBuilder({ schema, onChange, allowedTypes, defaultTab, style, className, }: TkxFormBuilderProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/components/TkxFormulaBar.d.ts

@@ -0,0 +1,19 @@
+import { type CSSProperties } from 'react';
+import { type SpreadsheetData } from './TkxSpreadsheet';
+export interface TkxFormulaBarProps {
+    data: SpreadsheetData;
+    active: {
+        col: number;
+        row: number;
+    };
+    onChange: (next: SpreadsheetData) => void;
+    onActiveChange?: (next: {
+        col: number;
+        row: number;
+    }) => void;
+    showResult?: boolean;
+    height?: number;
+    style?: CSSProperties;
+    className?: string;
+}
+export declare function TkxFormulaBar({ data, active, onChange, onActiveChange, showResult, height, style, className, }: TkxFormulaBarProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/components/TkxFunnelChart.d.ts

@@ -0,0 +1,21 @@
+import { type HTMLAttributes } from 'react';
+export interface TkxFunnelStage {
+    label: string;
+    value: number;
+    color?: string;
+}
+export interface TkxFunnelChartProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'onClick'> {
+    data: TkxFunnelStage[];
+    width?: number;
+    height?: number;
+    orientation?: 'vertical' | 'horizontal';
+    colors?: string[];
+    showValues?: boolean;
+    showPercentages?: boolean;
+    formatValue?: (v: number) => string;
+    gap?: number;
+    ariaLabel?: string;
+    onStageClick?: (stage: TkxFunnelStage, index: number) => void;
+    className?: string;
+}
+export declare const TkxFunnelChart: import("react").ForwardRefExoticComponent<TkxFunnelChartProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/src/components/TkxGantt.d.ts

@@ -0,0 +1,29 @@
+import { type CSSProperties } from 'react';
+export interface GanttTask {
+    id: string;
+    label: string;
+    start: string | Date;
+    end: string | Date;
+    progress?: number;
+    dependencies?: string[];
+    color?: string;
+    data?: unknown;
+}
+export interface TkxGanttProps {
+    tasks: GanttTask[];
+    dayWidth?: number;
+    rowHeight?: number;
+    labelColumnWidth?: number;
+    selectedId?: string | null;
+    onSelect?: (id: string, task: GanttTask) => void;
+    onTaskChange?: (id: string, next: {
+        start: string;
+        end: string;
+    }, task: GanttTask) => void;
+    style?: CSSProperties;
+    className?: string;
+}
+export declare function parseDay(input: string | Date): Date;
+export declare function formatDay(d: Date): string;
+export declare function dayDiff(a: Date, b: Date): number;
+export declare function TkxGantt({ tasks, dayWidth, rowHeight, labelColumnWidth, selectedId: controlledSelected, onSelect, onTaskChange, style, className, }: TkxGanttProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/components/TkxGauge.d.ts

@@ -0,0 +1,21 @@
+import { type HTMLAttributes } from 'react';
+export type GaugeVariant = 'arc' | 'speedometer';
+export interface GaugeThreshold {
+    at: number;
+    color: string;
+}
+export interface TkxGaugeProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    value: number;
+    min?: number;
+    max?: number;
+    size?: number;
+    thickness?: number;
+    variant?: GaugeVariant;
+    thresholds?: GaugeThreshold[];
+    label?: string;
+    showValue?: boolean;
+    showTicks?: boolean;
+    formatValue?: (v: number) => string;
+    ariaLabel?: string;
+}
+export declare const TkxGauge: import("react").ForwardRefExoticComponent<TkxGaugeProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/src/components/TkxHeatmap.d.ts

@@ -0,0 +1,25 @@
+import { type HTMLAttributes } from 'react';
+export interface TkxHeatmapCell {
+    x: string | number;
+    y: string | number;
+    value: number;
+    label?: string;
+}
+export interface TkxHeatmapProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'onClick'> {
+    data: TkxHeatmapCell[];
+    xLabels?: Array<string | number>;
+    yLabels?: Array<string | number>;
+    cellSize?: number;
+    gap?: number;
+    colorScale?: 'sequential' | 'diverging' | string[];
+    domain?: [number, number];
+    showValues?: boolean;
+    showLegend?: boolean;
+    legendPosition?: 'right' | 'bottom';
+    formatValue?: (v: number) => string;
+    emptyCellColor?: string;
+    ariaLabel?: string;
+    onCellClick?: (cell: TkxHeatmapCell) => void;
+    className?: string;
+}
+export declare const TkxHeatmap: import("react").ForwardRefExoticComponent<TkxHeatmapProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/src/components/TkxHolographic.d.ts

@@ -1,4 +1,5 @@
 import { type HTMLAttributes, type ReactNode } from 'react';
+export declare function injectHolographicStyles(): void;
 export interface TkxHolographicSurfaceProps extends HTMLAttributes<HTMLDivElement> {
     children: ReactNode;
     maxTilt?: number;
@@ -26,6 +27,7 @@ export declare const TkxHolographicAvatar: import("react").ForwardRefExoticCompo
 export interface TkxHolographicBadgeProps extends Omit<TkxHolographicSurfaceProps, 'children' | 'radius' | 'maxTilt'> {
     children: ReactNode;
     size?: 'sm' | 'md' | 'lg';
+    tone?: 'neutral' | 'success' | 'info' | 'warning' | 'danger';
 }
 export declare const TkxHolographicBadge: import("react").ForwardRefExoticComponent<TkxHolographicBadgeProps & import("react").RefAttributes<HTMLDivElement>>;
 export interface TkxHolographicButtonProps extends Omit<TkxHolographicSurfaceProps, 'children' | 'radius' | 'onClick'> {

package/dist/src/components/TkxHolographicAdvanced.d.ts

@@ -0,0 +1,48 @@
+import { type CSSProperties, type HTMLAttributes, type ReactNode } from 'react';
+export interface TkxHolographicPanelProps extends HTMLAttributes<HTMLDivElement> {
+    header?: ReactNode;
+    footer?: ReactNode;
+    tabs?: {
+        id: string;
+        label: string;
+    }[];
+    activeTabId?: string;
+    onTabChange?: (id: string) => void;
+    accent?: string;
+    children?: ReactNode;
+}
+export declare const TkxHolographicPanel: import("react").ForwardRefExoticComponent<TkxHolographicPanelProps & import("react").RefAttributes<HTMLDivElement>>;
+export interface TkxHolographicGaugeProps {
+    value: number;
+    size?: number;
+    thickness?: number;
+    accent?: string;
+    label?: ReactNode;
+    caption?: ReactNode;
+    ariaValueText?: string;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function TkxHolographicGauge({ value, size, thickness, accent, label, caption, ariaValueText, className, style, }: TkxHolographicGaugeProps): import("react/jsx-runtime").JSX.Element;
+export interface TkxHolographicProgressProps {
+    value: number;
+    label?: ReactNode;
+    valueLabel?: ReactNode;
+    height?: number;
+    accent?: string;
+    shimmer?: boolean;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function TkxHolographicProgress({ value, label, valueLabel, height, accent, shimmer, className, style, }: TkxHolographicProgressProps): import("react/jsx-runtime").JSX.Element;
+export interface TkxHolographicTerminalProps {
+    lines: string[];
+    typeSpeed?: number;
+    prompt?: string;
+    maxLines?: number;
+    height?: number;
+    accent?: string;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare function TkxHolographicTerminal({ lines, typeSpeed, prompt, maxLines, height, accent, className, style, }: TkxHolographicTerminalProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/components/TkxMindMap.d.ts

@@ -0,0 +1,22 @@
+import { type CSSProperties } from 'react';
+export interface MindMapNode {
+    id: string;
+    label: string;
+    children?: MindMapNode[];
+    color?: string;
+    collapsed?: boolean;
+    data?: unknown;
+}
+export interface TkxMindMapProps {
+    root: MindMapNode;
+    selectedId?: string | null;
+    collapsedIds?: Set<string>;
+    onSelect?: (id: string, node: MindMapNode) => void;
+    onToggle?: (id: string, nextCollapsed: boolean) => void;
+    leafHeight?: number;
+    levelWidth?: number;
+    nodeWidth?: number;
+    style?: CSSProperties;
+    className?: string;
+}
+export declare function TkxMindMap({ root, selectedId: controlledSelected, collapsedIds: controlledCollapsed, onSelect, onToggle, leafHeight, levelWidth, nodeWidth, style, className, }: TkxMindMapProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/components/TkxPivotTable.d.ts

@@ -0,0 +1,21 @@
+import { type CSSProperties } from 'react';
+export type PivotAggregator = 'sum' | 'avg' | 'min' | 'max' | 'count';
+export interface PivotValue {
+    field?: string;
+    agg: PivotAggregator;
+    label?: string;
+}
+export type PivotRecord = Record<string, unknown>;
+export interface TkxPivotTableProps {
+    data: PivotRecord[];
+    rows: string[];
+    cols?: string[];
+    values: PivotValue[];
+    sortRows?: (a: string, b: string, level: number) => number;
+    sortCols?: (a: string, b: string, level: number) => number;
+    showTotals?: boolean;
+    formatNumber?: (n: number) => string;
+    style?: CSSProperties;
+    className?: string;
+}
+export declare function TkxPivotTable({ data, rows, cols, values, sortRows, sortCols, showTotals, formatNumber, style, className, }: TkxPivotTableProps): import("react/jsx-runtime").JSX.Element;

package/dist/src/components/TkxSparkline.d.ts

@@ -0,0 +1,15 @@
+import { type HTMLAttributes } from 'react';
+export type SparklineVariant = 'line' | 'area' | 'bar';
+export interface TkxSparklineProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'children'> {
+    data: number[];
+    variant?: SparklineVariant;
+    width?: number;
+    height?: number;
+    color?: string;
+    showPoints?: boolean;
+    showLastPoint?: boolean;
+    showValue?: boolean;
+    smooth?: boolean;
+    ariaLabel?: string;
+}
+export declare const TkxSparkline: import("react").ForwardRefExoticComponent<TkxSparklineProps & import("react").RefAttributes<HTMLSpanElement>>;

package/dist/src/components/TkxSpreadsheet.d.ts

@@ -0,0 +1,33 @@
+import { type CSSProperties } from 'react';
+export interface SpreadsheetData {
+    cells: Record<string, string>;
+}
+export interface TkxSpreadsheetProps {
+    cols?: number;
+    rows?: number;
+    data: SpreadsheetData;
+    onChange: (next: SpreadsheetData) => void;
+    colWidth?: number;
+    rowHeight?: number;
+    style?: CSSProperties;
+    className?: string;
+}
+export declare function colLetter(i: number): string;
+export declare function colIndex(letters: string): number;
+export declare function addr(col: number, row: number): string;
+export declare function parseAddr(a: string): {
+    col: number;
+    row: number;
+} | null;
+export declare function spreadsheetToRecords(data: SpreadsheetData, bounds: {
+    cols: number;
+    rows: number;
+}): Array<Record<string, string | number | null>>;
+export declare function recordsToSpreadsheet(records: Array<Record<string, string | number | null | boolean | undefined>>, options?: {
+    base?: SpreadsheetData;
+    preserveExtraCells?: boolean;
+}): SpreadsheetData;
+type CellValue = number | string;
+export declare function evaluate(addr: string, cells: Record<string, string>): CellValue;
+export declare function TkxSpreadsheet({ cols, rows, data, onChange, colWidth, rowHeight, style, className, }: TkxSpreadsheetProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/components/TkxTreemap.d.ts

@@ -0,0 +1,21 @@
+import { type HTMLAttributes } from 'react';
+export interface TkxTreemapNode {
+    label: string;
+    value: number;
+    color?: string;
+    children?: TkxTreemapNode[];
+}
+export interface TkxTreemapProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'onClick'> {
+    data: TkxTreemapNode[];
+    width?: number;
+    height?: number;
+    colors?: string[];
+    showLabels?: boolean;
+    showValues?: boolean;
+    minLabelSize?: number;
+    formatValue?: (v: number) => string;
+    ariaLabel?: string;
+    onNodeClick?: (node: TkxTreemapNode, path: number[]) => void;
+    className?: string;
+}
+export declare const TkxTreemap: import("react").ForwardRefExoticComponent<TkxTreemapProps & import("react").RefAttributes<HTMLDivElement>>;

package/dist/src/components/TkxTypography.d.ts

@@ -187,7 +187,7 @@ export declare function TkxTitle({ level, children, copyable, type, style, }: Tk
         fontVariantNumeric?: import("csstype").Property.FontVariantNumeric | undefined;
         fontVariantPosition?: import("csstype").Property.FontVariantPosition | undefined;
         fontVariationSettings?: import("csstype").Property.FontVariationSettings | undefined;
-        fontWeight: number | "bold" | (string & {}) | "inherit" | "initial" | "normal" | "-moz-initial" | "revert" | "revert-layer" | "unset" | "bolder" | "lighter";
+        fontWeight: number | "bold" | (string & {}) | "inherit" | "initial" | "-moz-initial" | "revert" | "revert-layer" | "unset" | "normal" | "bolder" | "lighter";
         fontWidth?: import("csstype").Property.FontWidth | undefined;
         forcedColorAdjust?: import("csstype").Property.ForcedColorAdjust | undefined;
         gridAutoColumns?: import("csstype").Property.GridAutoColumns<string | number> | undefined;

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

@@ -71,6 +71,8 @@ export * from './TkxCascader';
 export * from './TkxList';
 export * from './TkxOrgChart';
 export * from './TkxDropdown';
-export * from './TkxAIConfidenceBar';
-export * from './TkxAIChatBubble';
-export * from './TkxAIThinking';
+export * from './TkxSparkline';
+export * from './TkxGauge';
+export * from './TkxHeatmap';
+export * from './TkxFunnelChart';
+export * from './TkxTreemap';

package/dist/src/engine/security.d.ts

@@ -1,3 +1,4 @@
+export declare function sha256Hex(input: string): string;
 export declare function sanitizeString(input: unknown): string;
 export declare function sanitizeProps<T extends Record<string, unknown>>(props: T): T;
 export interface PropSchema {
@@ -66,7 +67,9 @@ export interface RateLimiter {
 }
 export declare function createRateLimiter(n: number, intervalMs: number): RateLimiter;
 export declare function sniffMimeType(file: File): Promise<string | null>;
+declare function luhnValid(digits: string): boolean;
 export declare function scrubPII(raw: unknown): string;
+export { luhnValid };
 export declare function deepFreeze<T>(obj: T): Readonly<T>;
 export declare const SecurityCore: Readonly<{
     sanitizeString: typeof sanitizeString;

package/dist/src/experimental/index.d.ts

@@ -0,0 +1,8 @@
+export { TkxQuantumForm } from '../components/TkxQuantumForm';
+export type { TkxQuantumFormProps, QuantumFieldConfig, } from '../components/TkxQuantumForm';
+export { TkxAIConfidenceBar } from '../components/TkxAIConfidenceBar';
+export type { TkxAIConfidenceBarProps } from '../components/TkxAIConfidenceBar';
+export { TkxAIThinking } from '../components/TkxAIThinking';
+export type { TkxAIThinkingProps } from '../components/TkxAIThinking';
+export { TkxAIChatBubble } from '../components/TkxAIChatBubble';
+export type { TkxAIChatBubbleProps, AIRole, } from '../components/TkxAIChatBubble';

package/dist/src/headless/index.d.ts

@@ -21,3 +21,9 @@ export { useSSE } from './useSSE';
 export type { SSEOptions, SSEState } from './useSSE';
 export { useInfiniteQuery } from './useInfiniteQuery';
 export type { InfiniteQueryOptions, InfiniteQueryState } from './useInfiniteQuery';
+export { zodResolver, useFormWithZod } from './zodResolver';
+export type { ZodResolverConfig, ZodSchemaLike, ZodIssueLike } from './zodResolver';
+export { valibotResolver, useFormWithValibot } from './valibotResolver';
+export type { ValibotResolverConfig, ValibotSafeParseFn, ValibotSafeParseResult, ValibotIssueLike, } from './valibotResolver';
+export { createRHFBindings } from './rhfBindings';
+export type { RHFControl, RHFFieldRenderProps, RHFBindings, RHFControllerComponent, CreateRHFBindingsConfig, } from './rhfBindings';

package/dist/src/headless/rhfBindings.d.ts

@@ -0,0 +1,59 @@
+import type { ComponentType, ReactElement } from 'react';
+import { type TkxInputProps } from '../components/TkxInput';
+import { type TkxSelectProps } from '../components/TkxSelect';
+import { type TkxCheckboxProps } from '../components/TkxCheckbox';
+import { type TkxToggleProps } from '../components/TkxToggle';
+import { type TkxRadioProps } from '../components/TkxRadio';
+import { type TkxNumberInputProps } from '../components/TkxNumberInput';
+import { type TkxDatePickerProps } from '../components/TkxDatePicker';
+export interface RHFControl {
+    _formState: {
+        errors: Record<string, {
+            message?: string;
+        } | undefined>;
+    };
+}
+export interface RHFFieldRenderProps<TValue = unknown> {
+    field: {
+        name: string;
+        value: TValue;
+        onChange: (v: TValue | unknown) => void;
+        onBlur: () => void;
+        ref: (instance: unknown) => void;
+    };
+    fieldState: {
+        error?: {
+            message?: string;
+        };
+        isTouched: boolean;
+        isDirty: boolean;
+    };
+}
+interface ControllerProps<TValue = unknown> {
+    name: string;
+    control: RHFControl;
+    rules?: object;
+    defaultValue?: TValue;
+    render: (props: RHFFieldRenderProps<TValue>) => ReactElement;
+}
+export type RHFControllerComponent = ComponentType<ControllerProps<unknown>>;
+interface RHFBaseProps<TValue> {
+    name: string;
+    control: RHFControl;
+    rules?: object;
+    defaultValue?: TValue;
+}
+export interface RHFBindings {
+    TkxRHFInput: ComponentType<RHFBaseProps<string> & Omit<TkxInputProps, 'value' | 'onChange' | 'onBlur' | 'error' | 'name'>>;
+    TkxRHFSelect: ComponentType<RHFBaseProps<string | string[]> & Omit<TkxSelectProps, 'value' | 'onChange' | 'errorMessage'>>;
+    TkxRHFCheckbox: ComponentType<RHFBaseProps<boolean> & Omit<TkxCheckboxProps, 'checked' | 'onChange' | 'errorMessage' | 'name'>>;
+    TkxRHFToggle: ComponentType<RHFBaseProps<boolean> & Omit<TkxToggleProps, 'checked' | 'onChange'>>;
+    TkxRHFRadio: ComponentType<RHFBaseProps<string> & Omit<TkxRadioProps, 'checked' | 'onChange' | 'name'>>;
+    TkxRHFNumberInput: ComponentType<RHFBaseProps<number | null> & Omit<TkxNumberInputProps, 'value' | 'onChange' | 'errorMessage'>>;
+    TkxRHFDatePicker: ComponentType<RHFBaseProps<Date | null> & Omit<TkxDatePickerProps, 'value' | 'onChange'>>;
+}
+export interface CreateRHFBindingsConfig {
+    Controller: RHFControllerComponent;
+}
+export declare function createRHFBindings(config: CreateRHFBindingsConfig): RHFBindings;
+export {};

package/dist/src/headless/useFormState.d.ts

@@ -5,13 +5,23 @@ export interface FieldState {
     touched: boolean;
     dirty: boolean;
 }
+export type ValidateResult<T> = Partial<Record<keyof T, string>> & {
+    _root?: string;
+};
 export interface UseFormStateOptions<T extends Record<string, FormFieldValue>> {
     initialValues: T;
-    validate?: (values: T) => Partial<Record<keyof T, string>>;
+    validate?: (values: T) => ValidateResult<T>;
+    validateAsync?: {
+        [K in keyof T]?: (value: T[K], values: T) => Promise<string | null>;
+    };
+    debounceMs?: number;
 }
 export interface UseFormStateReturn<T extends Record<string, FormFieldValue>> {
     values: T;
     errors: Partial<Record<keyof T, string>>;
+    asyncErrors: Partial<Record<keyof T, string>>;
+    validating: Partial<Record<keyof T, boolean>>;
+    rootError: string | undefined;
     touched: Partial<Record<keyof T, boolean>>;
     dirty: boolean;
     isValid: boolean;
@@ -28,4 +38,4 @@ export interface UseFormStateReturn<T extends Record<string, FormFieldValue>> {
         'aria-describedby': string | undefined;
     };
 }
-export declare function useFormState<T extends Record<string, FormFieldValue>>({ initialValues, validate: validateFn, }: UseFormStateOptions<T>): UseFormStateReturn<T>;
+export declare function useFormState<T extends Record<string, FormFieldValue>>({ initialValues, validate: validateFn, validateAsync, debounceMs, }: UseFormStateOptions<T>): UseFormStateReturn<T>;

package/dist/src/headless/valibotResolver.d.ts

@@ -0,0 +1,25 @@
+import { type FormFieldValue, type UseFormStateReturn } from './useFormState';
+export interface ValibotIssueLike {
+    path?: {
+        key: string | number;
+    }[];
+    message: string;
+}
+export interface ValibotSafeParseResult {
+    success: boolean;
+    output?: unknown;
+    issues?: ValibotIssueLike[];
+}
+export type ValibotSafeParseFn = (schema: unknown, value: unknown) => ValibotSafeParseResult;
+export interface ValibotResolverConfig<T extends Record<string, FormFieldValue>> {
+    safeParse: ValibotSafeParseFn;
+    schema: unknown;
+    initialValues: T;
+    onSubmit?: (values: T) => void | Promise<void>;
+}
+export declare function valibotResolver<T extends Record<string, FormFieldValue>>(safeParse: ValibotSafeParseFn, schema: unknown): (values: T) => Partial<Record<keyof T, string>>;
+export declare function useFormWithValibot<T extends Record<string, FormFieldValue>>(opts: ValibotResolverConfig<T>): UseFormStateReturn<T> & {
+    handleSubmit: (e?: {
+        preventDefault?: () => void;
+    }) => Promise<void>;
+};

package/dist/src/headless/zodResolver.d.ts

@@ -0,0 +1,25 @@
+import { type FormFieldValue, type UseFormStateReturn } from './useFormState';
+export interface ZodIssueLike {
+    path: (string | number)[];
+    message: string;
+}
+export interface ZodSchemaLike {
+    safeParse(value: unknown): {
+        success: boolean;
+        data?: unknown;
+        error?: {
+            issues: ZodIssueLike[];
+        };
+    };
+}
+export interface ZodResolverConfig<T extends Record<string, FormFieldValue>> {
+    schema: ZodSchemaLike;
+    initialValues: T;
+    onSubmit?: (values: T) => void | Promise<void>;
+}
+export declare function zodResolver<T extends Record<string, FormFieldValue>>(schema: ZodSchemaLike): (values: T) => Partial<Record<keyof T, string>>;
+export declare function useFormWithZod<T extends Record<string, FormFieldValue>>(opts: ZodResolverConfig<T>): UseFormStateReturn<T> & {
+    handleSubmit: (e?: {
+        preventDefault?: () => void;
+    }) => Promise<void>;
+};