@nccirtu/tablefy 0.8.3 → 0.9.0

package/dist/forms/columns/input-column.d.ts

@@ -0,0 +1,27 @@
+import { ColumnDef } from "@tanstack/react-table";
+import { BaseColumn } from "./base-column";
+import { BaseColumnConfig } from "./types";
+interface InputColumnConfig<TData> extends BaseColumnConfig<TData> {
+    placeholder?: string;
+    type?: "text" | "email" | "number" | "password" | "url";
+    disabled?: boolean | ((row: TData) => boolean);
+    onSave?: (row: TData, newValue: string) => void;
+    onChange?: (row: TData, newValue: string) => void;
+    debounce?: number;
+}
+export declare class InputColumn<TData> extends BaseColumn<TData, InputColumnConfig<TData>> {
+    constructor(accessor: keyof TData | string);
+    static make<TData>(accessor: keyof TData | string): InputColumn<TData>;
+    placeholder(placeholder: string): this;
+    type(type: "text" | "email" | "number" | "password" | "url"): this;
+    disabled(disabled: boolean | ((row: TData) => boolean)): this;
+    onSave(handler: (row: TData, newValue: string) => void): this;
+    onChange(handler: (row: TData, newValue: string) => void): this;
+    debounce(ms: number): this;
+    email(): this;
+    number(): this;
+    password(): this;
+    url(): this;
+    build(): ColumnDef<TData, unknown>;
+}
+export { InputColumn as inputColumn };

package/dist/forms/columns/link-column.d.ts

@@ -0,0 +1,27 @@
+import { ColumnDef } from "@tanstack/react-table";
+import { ReactNode } from "react";
+import { BaseColumn } from "./base-column";
+import { BaseColumnConfig } from "./types";
+interface LinkColumnConfig<TData> extends BaseColumnConfig<TData> {
+    href?: string | ((row: TData) => string);
+    external?: boolean;
+    icon?: ReactNode;
+    showExternalIcon?: boolean;
+    underline?: "always" | "hover" | "never";
+    openInNewTab?: boolean;
+    onClick?: (row: TData) => void;
+}
+export declare class LinkColumn<TData> extends BaseColumn<TData, LinkColumnConfig<TData>> {
+    constructor(accessor: keyof TData | string);
+    static make<TData>(accessor: keyof TData | string): LinkColumn<TData>;
+    href(href: string | ((row: TData) => string)): this;
+    urlFromField(field: keyof TData): this;
+    external(external?: boolean): this;
+    icon(icon: ReactNode): this;
+    showExternalIcon(show?: boolean): this;
+    underline(style: "always" | "hover" | "never"): this;
+    openInNewTab(open?: boolean): this;
+    onClick(handler: (row: TData) => void): this;
+    build(): ColumnDef<TData, unknown>;
+}
+export {};

package/dist/forms/columns/number-column.d.ts

@@ -0,0 +1,23 @@
+import { ColumnDef } from "@tanstack/react-table";
+import { BaseColumn } from "./base-column";
+import { BaseColumnConfig } from "./types";
+interface NumberColumnConfig<TData> extends BaseColumnConfig<TData> {
+    decimals?: number;
+    locale?: string;
+    currency?: string;
+    percent?: boolean;
+    prefix?: string;
+    suffix?: string;
+}
+export declare class NumberColumn<TData> extends BaseColumn<TData, NumberColumnConfig<TData>> {
+    constructor(accessor: keyof TData | string);
+    static make<TData>(accessor: keyof TData | string): NumberColumn<TData>;
+    decimals(decimals: number): this;
+    locale(locale: string): this;
+    money(currency?: string): this;
+    percent(): this;
+    prefix(prefix: string): this;
+    suffix(suffix: string): this;
+    build(): ColumnDef<TData, unknown>;
+}
+export {};

package/dist/forms/columns/progress-column.d.ts

@@ -0,0 +1,30 @@
+import { ColumnDef } from "@tanstack/react-table";
+import { BaseColumn } from "./base-column";
+import { BaseColumnConfig } from "./types";
+interface ProgressColumnConfig<TData> extends BaseColumnConfig<TData> {
+    max?: number;
+    showValue?: boolean;
+    showPercentage?: boolean;
+    size?: "sm" | "md" | "lg";
+    color?: "default" | "success" | "warning" | "danger" | ((value: number, max: number) => string);
+    thresholds?: {
+        warning?: number;
+        danger?: number;
+    };
+    format?: (value: number, max: number) => string;
+}
+export declare class ProgressColumn<TData> extends BaseColumn<TData, ProgressColumnConfig<TData>> {
+    constructor(accessor: keyof TData | string);
+    static make<TData>(accessor: keyof TData | string): ProgressColumn<TData>;
+    max(max: number): this;
+    showValue(show?: boolean): this;
+    showPercentage(show?: boolean): this;
+    hideLabel(): this;
+    size(size: "sm" | "md" | "lg"): this;
+    color(color: "default" | "success" | "warning" | "danger"): this;
+    colorByThreshold(warning?: number, danger?: number): this;
+    colorByThresholdInverse(warning?: number, danger?: number): this;
+    format(fn: (value: number, max: number) => string): this;
+    build(): ColumnDef<TData, unknown>;
+}
+export {};

package/dist/forms/columns/select-column.d.ts

@@ -0,0 +1,24 @@
+import { ColumnDef } from "@tanstack/react-table";
+import { BaseColumn } from "./base-column";
+import { BaseColumnConfig } from "./types";
+export interface SelectOption {
+    label: string;
+    value: string;
+    disabled?: boolean;
+}
+interface SelectColumnConfig<TData> extends BaseColumnConfig<TData> {
+    options?: SelectOption[];
+    placeholder?: string;
+    disabled?: boolean | ((row: TData) => boolean);
+    onValueChange?: (row: TData, newValue: string) => void;
+}
+export declare class SelectColumn<TData> extends BaseColumn<TData, SelectColumnConfig<TData>> {
+    constructor(accessor: keyof TData | string);
+    static make<TData>(accessor: keyof TData | string): SelectColumn<TData>;
+    options(options: SelectOption[]): this;
+    placeholder(placeholder: string): this;
+    disabled(disabled: boolean | ((row: TData) => boolean)): this;
+    onValueChange(handler: (row: TData, newValue: string) => void): this;
+    build(): ColumnDef<TData, unknown>;
+}
+export { SelectColumn as selectColumn };

package/dist/forms/columns/text-column.d.ts

@@ -0,0 +1,14 @@
+import { ColumnDef, Row } from "@tanstack/react-table";
+import { BaseColumn } from "./base-column";
+import { FormattedColumnConfig } from "./types";
+export declare class TextColumn<TData> extends BaseColumn<TData, FormattedColumnConfig<TData>> {
+    static make<TData>(accessor: keyof TData | string): TextColumn<TData>;
+    formatter(fn: (value: unknown, row: Row<TData>) => React.ReactNode): this;
+    prefix(prefix: string): this;
+    suffix(suffix: string): this;
+    placeholder(placeholder: string): this;
+    uppercase(): this;
+    lowercase(): this;
+    limit(chars: number): this;
+    build(): ColumnDef<TData, unknown>;
+}

package/dist/forms/columns/types.d.ts

@@ -0,0 +1,46 @@
+import { Row } from "@tanstack/react-table";
+import { ReactNode } from "react";
+export interface BaseColumnConfig<TData> {
+    accessor: keyof TData | string;
+    label?: string;
+    sortable?: boolean;
+    searchable?: boolean;
+    hidden?: boolean;
+    visibleByDefault?: boolean;
+    visibilityLabel?: string;
+    align?: "left" | "center" | "right";
+    width?: string | number;
+    className?: string;
+    headerClassName?: string;
+    cellClassName?: string;
+}
+export interface FormattedColumnConfig<TData> extends BaseColumnConfig<TData> {
+    formatter?: (value: unknown, row: Row<TData>) => ReactNode;
+    prefix?: string;
+    suffix?: string;
+    placeholder?: string;
+}
+export interface BadgeColumnConfig<TData> extends BaseColumnConfig<TData> {
+    variants?: Record<string, {
+        label?: string;
+        variant?: "default" | "secondary" | "destructive" | "outline" | "success" | "warning" | "info" | "muted";
+        className?: string;
+        icon?: ReactNode;
+    }>;
+    variantFn?: (value: unknown, row: TData) => {
+        label?: string;
+        variant?: "default" | "secondary" | "destructive" | "outline" | "success" | "warning" | "info" | "muted";
+        className?: string;
+        icon?: ReactNode;
+    };
+    classNameFn?: (value: unknown, row: TData) => string;
+}
+export interface ActionConfig<TData> {
+    label: string;
+    icon?: ReactNode;
+    onClick?: (row: TData) => void;
+    href?: (row: TData) => string;
+    variant?: "default" | "destructive" | "ghost";
+    hidden?: (row: TData) => boolean;
+    disabled?: (row: TData) => boolean;
+}

package/dist/forms/components/field-renderer.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from "react";
+import { BuiltField } from "../types/form";
+export interface FieldRendererProps<TData extends Record<string, any>> {
+    field: BuiltField<TData>;
+    value: any;
+    error?: string;
+    disabled?: boolean;
+    data: TData;
+    onChange: (value: any) => void;
+    onBlur?: () => void;
+}
+export declare function FieldRenderer<TData extends Record<string, any>>({ field, value, error, disabled, data, onChange, onBlur, }: FieldRendererProps<TData>): ReactNode;

package/dist/forms/components/form-actions.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from "react";
+import { FormActionConfig } from "../types/actions";
+export interface FormActionsProps<TData extends Record<string, any>> {
+    actions: FormActionConfig<TData>[];
+    position?: "start" | "end" | "between" | "center";
+    data: TData;
+    processing?: boolean;
+}
+export declare function FormActions<TData extends Record<string, any>>({ actions, position, data, processing, }: FormActionsProps<TData>): ReactNode;

package/dist/forms/components/form-renderer.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from "react";
+import { FormBuildResult } from "../types/form";
+export interface FormRendererProps<TData extends Record<string, any>> {
+    schema: FormBuildResult<TData>;
+    data: TData;
+    errors: Partial<Record<keyof TData, string>>;
+    onChange: (field: keyof TData, value: any) => void;
+    onSubmit: () => void;
+    processing?: boolean;
+    className?: string;
+    disabled?: boolean;
+    onBlur?: (field: string) => void;
+}
+export declare function FormRenderer<TData extends Record<string, any>>({ schema, data, errors, onChange, onSubmit, processing, className, disabled, onBlur, }: FormRendererProps<TData>): ReactNode;

package/dist/forms/components/grid-layout.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from "react";
+export interface GridLayoutProps {
+    columns?: number;
+    children: ReactNode;
+    className?: string;
+}
+export declare function GridLayout({ columns, children, className, }: GridLayoutProps): ReactNode;

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

@@ -0,0 +1,9 @@
+export { FormRenderer } from "./form-renderer";
+export type { FormRendererProps } from "./form-renderer";
+export { FieldRenderer } from "./field-renderer";
+export type { FieldRendererProps } from "./field-renderer";
+export { GridLayout } from "./grid-layout";
+export { FormActions } from "./form-actions";
+export { SectionRenderer } from "./section-renderer";
+export { TabRenderer } from "./tab-renderer";
+export { WizardRenderer } from "./wizard-renderer";

package/dist/forms/components/section-renderer.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from "react";
+import { SectionConfig } from "../types/layout";
+import { BuiltField } from "../types/form";
+export interface SectionRendererProps<TData extends Record<string, any>> {
+    section: SectionConfig<TData>;
+    fields: BuiltField<TData>[];
+    data: TData;
+    errors: Partial<Record<keyof TData, string>>;
+    onChange: (field: keyof TData, value: any) => void;
+    onBlur?: (field: string) => void;
+    isFieldVisible: (field: BuiltField<TData>) => boolean;
+    isFieldDisabled: (field: BuiltField<TData>) => boolean;
+}
+export declare function SectionRenderer<TData extends Record<string, any>>({ section, fields, data, errors, onChange, onBlur, isFieldVisible, isFieldDisabled, }: SectionRendererProps<TData>): ReactNode;

package/dist/forms/components/tab-renderer.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from "react";
+import { TabConfig } from "../types/layout";
+import { BuiltField } from "../types/form";
+export interface TabRendererProps<TData extends Record<string, any>> {
+    tabs: TabConfig<TData>[];
+    fields: BuiltField<TData>[];
+    data: TData;
+    errors: Partial<Record<keyof TData, string>>;
+    onChange: (field: keyof TData, value: any) => void;
+    onBlur?: (field: string) => void;
+    isFieldVisible: (field: BuiltField<TData>) => boolean;
+    isFieldDisabled: (field: BuiltField<TData>) => boolean;
+    columns?: number;
+}
+export declare function TabRenderer<TData extends Record<string, any>>({ tabs, fields, data, errors, onChange, onBlur, isFieldVisible, isFieldDisabled, columns, }: TabRendererProps<TData>): ReactNode;

package/dist/forms/components/wizard-renderer.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode } from "react";
+import { WizardStepConfig } from "../types/layout";
+import { BuiltField } from "../types/form";
+export interface WizardRendererProps<TData extends Record<string, any>> {
+    steps: WizardStepConfig<TData>[];
+    fields: BuiltField<TData>[];
+    data: TData;
+    errors: Partial<Record<keyof TData, string>>;
+    onChange: (field: keyof TData, value: any) => void;
+    onBlur?: (field: string) => void;
+    isFieldVisible: (field: BuiltField<TData>) => boolean;
+    isFieldDisabled: (field: BuiltField<TData>) => boolean;
+    columns?: number;
+    onSubmit: () => void;
+    processing?: boolean;
+}
+export declare function WizardRenderer<TData extends Record<string, any>>({ steps, fields, data, errors, onChange, onBlur, isFieldVisible, isFieldDisabled, columns, onSubmit, processing, }: WizardRendererProps<TData>): ReactNode;

package/dist/forms/confirm/ConfirmProvider.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from "react";
+interface ConfirmProviderProps {
+    children: ReactNode;
+}
+export declare function ConfirmProvider({ children }: ConfirmProviderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/forms/confirm/confirm.d.ts

@@ -0,0 +1,3 @@
+import { ConfirmOptions, ConfirmHandler } from "./types";
+export declare function registerConfirm(handler: ConfirmHandler | null): void;
+export declare function confirm(options: ConfirmOptions): Promise<boolean>;

package/dist/forms/confirm/index.d.ts

@@ -0,0 +1,3 @@
+export { ConfirmProvider } from "./ConfirmProvider";
+export { confirm } from "./confirm";
+export type { ConfirmOptions } from "./types";

package/dist/forms/confirm/types.d.ts

@@ -0,0 +1,10 @@
+export interface ConfirmOptions {
+    title?: string;
+    description?: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    variant?: "destructive" | "default";
+    icon?: React.ReactNode;
+    image?: string;
+}
+export type ConfirmHandler = (options: ConfirmOptions) => Promise<boolean>;

package/dist/forms/fields/base-field.d.ts

@@ -0,0 +1,24 @@
+import { ReactNode } from "react";
+import { BaseFieldConfig, ValidationRule } from "../types/field";
+import { FieldType, FieldRenderProps, BuiltField } from "../types/form";
+export declare abstract class BaseField<TData extends Record<string, any>, TConfig extends BaseFieldConfig<TData>> {
+    protected config: TConfig;
+    constructor(name: string);
+    label(label: string): this;
+    placeholder(placeholder: string): this;
+    helperText(text: string): this;
+    required(required?: boolean): this;
+    disabled(disabled?: boolean | ((data: TData) => boolean)): this;
+    readOnly(readOnly?: boolean): this;
+    hidden(hidden?: boolean | ((data: TData) => boolean)): this;
+    default(value: any): this;
+    columnSpan(span: number): this;
+    className(className: string): this;
+    rules(rules: ValidationRule[]): this;
+    zodSchema(schema: any): this;
+    dependsOn<K extends string & keyof TData>(field: K, condition: (value: TData[K], data: TData) => boolean, effect?: "show" | "hide" | "enable" | "disable" | "setValue", effectValue?: any): this;
+    reactive(reactive?: boolean): this;
+    abstract readonly fieldType: FieldType;
+    abstract renderField(props: FieldRenderProps<TData>): ReactNode;
+    build(): BuiltField<TData>;
+}

package/dist/forms/fields/checkbox-group.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from "react";
+import { BaseField } from "./base-field";
+import { CheckboxGroupConfig, SelectOption } from "../types/field";
+import { FieldType, FieldRenderProps } from "../types/form";
+export declare class CheckboxGroup<TData extends Record<string, any>> extends BaseField<TData, CheckboxGroupConfig<TData>> {
+    readonly fieldType: FieldType;
+    constructor(name: string);
+    static make<TData extends Record<string, any>>(name: string & keyof TData | string): CheckboxGroup<TData>;
+    options(options: SelectOption[]): this;
+    columns(columns: number): this;
+    renderField({ value, onChange, error, disabled, }: FieldRenderProps<TData>): ReactNode;
+}

package/dist/forms/fields/checkbox.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from "react";
+import { BaseField } from "./base-field";
+import { CheckboxConfig } from "../types/field";
+import { FieldType, FieldRenderProps } from "../types/form";
+export declare class Checkbox<TData extends Record<string, any>> extends BaseField<TData, CheckboxConfig<TData>> {
+    readonly fieldType: FieldType;
+    static make<TData extends Record<string, any>>(name: string & keyof TData | string): Checkbox<TData>;
+    renderField({ value, onChange, error, disabled, }: FieldRenderProps<TData>): ReactNode;
+}

package/dist/forms/fields/date-picker.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from "react";
+import { BaseField } from "./base-field";
+import { DatePickerConfig } from "../types/field";
+import { FieldType, FieldRenderProps } from "../types/form";
+export declare class DatePicker<TData extends Record<string, any>> extends BaseField<TData, DatePickerConfig<TData>> {
+    readonly fieldType: FieldType;
+    constructor(name: string);
+    static make<TData extends Record<string, any>>(name: string & keyof TData | string): DatePicker<TData>;
+    minDate(date: Date | ((data: TData) => Date)): this;
+    maxDate(date: Date | ((data: TData) => Date)): this;
+    format(format: string): this;
+    includeTime(includeTime?: boolean): this;
+    locale(locale: string): this;
+    renderField({ value, onChange, error, disabled, data, }: FieldRenderProps<TData>): ReactNode;
+}

package/dist/forms/fields/file-upload.d.ts

@@ -0,0 +1,17 @@
+import { ReactNode } from "react";
+import { BaseField } from "./base-field";
+import { FileUploadConfig } from "../types/field";
+import { FieldType, FieldRenderProps } from "../types/form";
+export declare class FileUpload<TData extends Record<string, any>> extends BaseField<TData, FileUploadConfig<TData>> {
+    readonly fieldType: FieldType;
+    constructor(name: string);
+    static make<TData extends Record<string, any>>(name: string & keyof TData | string): FileUpload<TData>;
+    accept(accept: string): this;
+    maxSize(bytes: number): this;
+    multiple(multiple?: boolean): this;
+    maxFiles(max: number): this;
+    preview(preview?: boolean): this;
+    image(): this;
+    pdf(): this;
+    renderField({ value, onChange, error, disabled, }: FieldRenderProps<TData>): ReactNode;
+}

package/dist/forms/fields/hidden.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from "react";
+import { BaseField } from "./base-field";
+import { HiddenConfig } from "../types/field";
+import { FieldType, FieldRenderProps } from "../types/form";
+export declare class Hidden<TData extends Record<string, any>> extends BaseField<TData, HiddenConfig<TData>> {
+    readonly fieldType: FieldType;
+    static make<TData extends Record<string, any>>(name: string & keyof TData | string): Hidden<TData>;
+    renderField({ value }: FieldRenderProps<TData>): ReactNode;
+}

package/dist/forms/fields/index.d.ts

@@ -0,0 +1,12 @@
+export { BaseField } from "./base-field";
+export { TextInput } from "./text-input";
+export { Textarea } from "./textarea";
+export { Select } from "./select";
+export { Checkbox } from "./checkbox";
+export { Toggle } from "./toggle";
+export { RadioGroup } from "./radio-group";
+export { DatePicker } from "./date-picker";
+export { Hidden } from "./hidden";
+export { FileUpload } from "./file-upload";
+export { CheckboxGroup } from "./checkbox-group";
+export { Repeater } from "./repeater";

package/dist/forms/fields/radio-group.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from "react";
+import { BaseField } from "./base-field";
+import { RadioGroupConfig, SelectOption } from "../types/field";
+import { FieldType, FieldRenderProps } from "../types/form";
+export declare class RadioGroup<TData extends Record<string, any>> extends BaseField<TData, RadioGroupConfig<TData>> {
+    readonly fieldType: FieldType;
+    constructor(name: string);
+    static make<TData extends Record<string, any>>(name: string & keyof TData | string): RadioGroup<TData>;
+    options(options: SelectOption[]): this;
+    orientation(orientation: "horizontal" | "vertical"): this;
+    horizontal(): this;
+    vertical(): this;
+    renderField({ value, onChange, error, disabled, }: FieldRenderProps<TData>): ReactNode;
+}

package/dist/forms/fields/repeater.d.ts

@@ -0,0 +1,21 @@
+import { ReactNode } from "react";
+import { BaseField } from "./base-field";
+import { RepeaterConfig } from "../types/field";
+import { FieldType, FieldRenderProps, BuiltField } from "../types/form";
+type FieldBuilder<TData extends Record<string, any>> = {
+    build(): BuiltField<TData>;
+};
+export declare class Repeater<TData extends Record<string, any>> extends BaseField<TData, RepeaterConfig<TData>> {
+    readonly fieldType: FieldType;
+    private fieldBuilders;
+    constructor(name: string);
+    static make<TData extends Record<string, any>>(name: string & keyof TData | string): Repeater<TData>;
+    fields(...builders: FieldBuilder<any>[]): this;
+    minItems(min: number): this;
+    maxItems(max: number): this;
+    addLabel(label: string): this;
+    collapsible(collapsible?: boolean): this;
+    orderable(orderable?: boolean): this;
+    renderField({ value, onChange, error, disabled, data, }: FieldRenderProps<TData>): ReactNode;
+}
+export {};

package/dist/forms/fields/select.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from "react";
+import { BaseField } from "./base-field";
+import { SelectConfig, SelectOption } from "../types/field";
+import { FieldType, FieldRenderProps } from "../types/form";
+export declare class Select<TData extends Record<string, any>> extends BaseField<TData, SelectConfig<TData>> {
+    readonly fieldType: FieldType;
+    constructor(name: string);
+    static make<TData extends Record<string, any>>(name: string & keyof TData | string): Select<TData>;
+    options(options: SelectOption[] | ((data: TData) => SelectOption[])): this;
+    multiple(multiple?: boolean): this;
+    searchable(searchable?: boolean): this;
+    clearable(clearable?: boolean): this;
+    maxItems(max: number): this;
+    loadOptions(fn: (query: string) => Promise<SelectOption[]>): this;
+    renderField({ value, onChange, error, disabled, data, }: FieldRenderProps<TData>): ReactNode;
+}

package/dist/forms/fields/text-input.d.ts

@@ -0,0 +1,20 @@
+import { ReactNode } from "react";
+import { BaseField } from "./base-field";
+import { TextInputConfig } from "../types/field";
+import { FieldType, FieldRenderProps } from "../types/form";
+export declare class TextInput<TData extends Record<string, any>> extends BaseField<TData, TextInputConfig<TData>> {
+    readonly fieldType: FieldType;
+    static make<TData extends Record<string, any>>(name: string & keyof TData | string): TextInput<TData>;
+    type(type: "text" | "email" | "password" | "number" | "url" | "tel"): this;
+    email(): this;
+    password(): this;
+    number(): this;
+    url(): this;
+    tel(): this;
+    minLength(min: number): this;
+    maxLength(max: number): this;
+    prefix(prefix: string | ReactNode): this;
+    suffix(suffix: string | ReactNode): this;
+    autocomplete(value: string): this;
+    renderField({ value, onChange, onBlur, error, disabled, }: FieldRenderProps<TData>): ReactNode;
+}

package/dist/forms/fields/textarea.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from "react";
+import { BaseField } from "./base-field";
+import { TextareaConfig } from "../types/field";
+import { FieldType, FieldRenderProps } from "../types/form";
+export declare class Textarea<TData extends Record<string, any>> extends BaseField<TData, TextareaConfig<TData>> {
+    readonly fieldType: FieldType;
+    constructor(name: string);
+    static make<TData extends Record<string, any>>(name: string & keyof TData | string): Textarea<TData>;
+    rows(rows: number): this;
+    minLength(min: number): this;
+    maxLength(max: number): this;
+    autoResize(autoResize?: boolean): this;
+    renderField({ value, onChange, onBlur, error, disabled, }: FieldRenderProps<TData>): ReactNode;
+}

package/dist/forms/fields/toggle.d.ts

@@ -0,0 +1,11 @@
+import { ReactNode } from "react";
+import { BaseField } from "./base-field";
+import { ToggleConfig } from "../types/field";
+import { FieldType, FieldRenderProps } from "../types/form";
+export declare class Toggle<TData extends Record<string, any>> extends BaseField<TData, ToggleConfig<TData>> {
+    readonly fieldType: FieldType;
+    static make<TData extends Record<string, any>>(name: string & keyof TData | string): Toggle<TData>;
+    onLabel(label: string): this;
+    offLabel(label: string): this;
+    renderField({ value, onChange, error, disabled, }: FieldRenderProps<TData>): ReactNode;
+}

package/dist/forms/forms/builders/actions-builder.d.ts

@@ -0,0 +1,14 @@
+import { FormActionConfig } from "../types/actions";
+export declare class ActionsBuilder<TData extends Record<string, any>> {
+    private actionsList;
+    submit(opts?: Partial<Omit<FormActionConfig<TData>, "type">> & {
+        label?: string;
+    }): this;
+    cancel(opts?: Partial<Omit<FormActionConfig<TData>, "type">> & {
+        label?: string;
+    }): this;
+    custom(opts: Omit<FormActionConfig<TData>, "type"> & {
+        label: string;
+    }): this;
+    build(): FormActionConfig<TData>[];
+}

package/dist/forms/forms/builders/form-schema.d.ts

@@ -0,0 +1,35 @@
+import { FormBuildResult, BuiltField } from "../types/form";
+import { SectionConfig, TabConfig, WizardStepConfig } from "../types/layout";
+import { ActionsBuilder } from "./actions-builder";
+type FieldBuilder<TData extends Record<string, any>> = {
+    build(): BuiltField<TData>;
+};
+/**
+ * Form Schema Builder
+ * Fluent API for building complete form configurations
+ */
+export declare class FormSchema<TData extends Record<string, any>> {
+    private fieldBuilders;
+    private schemaConfig;
+    static make<TData extends Record<string, any>>(): FormSchema<TData>;
+    title(title: string | ((data: TData) => string)): this;
+    description(description: string | ((data: TData) => string)): this;
+    columns(columns: number): this;
+    bordered(bordered?: boolean): this;
+    spacing(spacing: "compact" | "normal" | "relaxed"): this;
+    disabled(disabled: boolean | ((data: TData) => boolean)): this;
+    fields(...builders: FieldBuilder<TData>[]): this;
+    sections(...sections: {
+        build(): SectionConfig<TData>;
+    }[]): this;
+    tabs(...tabs: {
+        build(): TabConfig<TData>;
+    }[]): this;
+    wizard(...steps: {
+        build(): WizardStepConfig<TData>;
+    }[]): this;
+    actions(fn: (builder: ActionsBuilder<TData>) => ActionsBuilder<TData>): this;
+    actionsPosition(position: "start" | "end" | "between" | "center"): this;
+    build(): FormBuildResult<TData>;
+}
+export {};

package/dist/forms/forms/builders/index.d.ts

@@ -0,0 +1,5 @@
+export { FormSchema } from "./form-schema";
+export { ActionsBuilder } from "./actions-builder";
+export { SectionBuilder } from "./section-builder";
+export { TabBuilder } from "./tab-builder";
+export { WizardStep } from "./wizard-builder";

package/dist/forms/forms/builders/section-builder.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from "react";
+import { SectionConfig } from "../types/layout";
+export declare class SectionBuilder<TData extends Record<string, any>> {
+    private sectionConfig;
+    constructor(title: string);
+    static make<TData extends Record<string, any>>(title: string): SectionBuilder<TData>;
+    id(id: string): this;
+    description(description: string): this;
+    fields(fields: string[]): this;
+    columns(columns: number): this;
+    collapsible(collapsible?: boolean): this;
+    collapsed(collapsed?: boolean): this;
+    icon(icon: ReactNode): this;
+    hidden(fn: (data: TData) => boolean): this;
+    build(): SectionConfig<TData>;
+}