@nccirtu/tablefy 0.8.4 → 0.9.0

package/dist/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/builders/index.d.ts

@@ -0,0 +1,2 @@
+export { TableSchema } from "./table-schema";
+export { EmptyStateBuilder } from "./empty-state";

package/dist/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>;
+}

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

@@ -0,0 +1,16 @@
+import { ReactNode } from "react";
+import { TabConfig, SectionConfig } from "../types/layout";
+export declare class TabBuilder<TData extends Record<string, any>> {
+    private tabConfig;
+    constructor(label: string);
+    static make<TData extends Record<string, any>>(label: string): TabBuilder<TData>;
+    id(id: string): this;
+    icon(icon: ReactNode): this;
+    fields(fields: string[]): this;
+    sections(...sections: {
+        build(): SectionConfig<TData>;
+    }[]): this;
+    badge(badge: string | number | ((data: TData) => string | number)): this;
+    disabled(fn: (data: TData) => boolean): this;
+    build(): TabConfig<TData>;
+}

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

@@ -0,0 +1,45 @@
+import { ColumnDef } from "@tanstack/react-table";
+import { DataTableConfig } from "../types/table";
+import { HeaderAction } from "../types/actions";
+import { EmptyStateConfig } from "../types/empty-state";
+type ColumnBuilder<TData> = {
+    build(): ColumnDef<TData, unknown>;
+};
+/**
+ * Table Schema Builder
+ * Fluent API for building complete table configurations
+ */
+export declare class TableSchema<TData> {
+    private columnBuilders;
+    private config;
+    static make<TData>(): TableSchema<TData>;
+    description(text: string): this;
+    title(text: string): this;
+    headerActions(actions: HeaderAction<TData>[]): this;
+    emptyState(config: EmptyStateConfig): this;
+    searchEmptyState(config: EmptyStateConfig): this;
+    filterEmptyState(config: EmptyStateConfig): this;
+    searchable(config?: {
+        placeholder?: string;
+    } | boolean): this;
+    paginated(config?: {
+        pageSize?: number;
+        pageSizeOptions?: number[];
+    } | boolean): this;
+    selectable(multiSelect?: boolean): this;
+    sortable(defaultSort?: {
+        id: string;
+        desc: boolean;
+    }): this;
+    columnVisibility(enabled?: boolean): this;
+    bordered(enabled?: boolean): this;
+    striped(enabled?: boolean): this;
+    hoverable(enabled?: boolean): this;
+    density(density: "compact" | "default" | "comfortable"): this;
+    columns(...builders: ColumnBuilder<TData>[]): this;
+    build(): {
+        columns: ColumnDef<TData, unknown>[];
+        config: DataTableConfig<TData>;
+    };
+}
+export {};

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

@@ -0,0 +1,17 @@
+import { ReactNode } from "react";
+import { WizardStepConfig, SectionConfig } from "../types/layout";
+export declare class WizardStep<TData extends Record<string, any>> {
+    private stepConfig;
+    constructor(label: string);
+    static make<TData extends Record<string, any>>(label: string): WizardStep<TData>;
+    id(id: string): this;
+    description(description: string): this;
+    icon(icon: ReactNode): this;
+    fields(fields: string[]): this;
+    sections(...sections: {
+        build(): SectionConfig<TData>;
+    }[]): this;
+    canProceed(fn: (data: TData) => boolean): this;
+    beforeNext(fn: (data: TData) => Promise<boolean> | boolean): this;
+    build(): WizardStepConfig<TData>;
+}

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

@@ -0,0 +1,26 @@
+import { ColumnDef } from "@tanstack/react-table";
+import { ReactNode } from "react";
+export interface ActionItem<TData> {
+    label?: string;
+    icon?: ReactNode;
+    onClick?: (row: TData) => void;
+    href?: (row: TData) => string;
+    render?: (row: TData) => ReactNode;
+    variant?: "default" | "destructive";
+    separator?: boolean;
+    hidden?: (row: TData) => boolean;
+    disabled?: (row: TData) => boolean;
+}
+export declare class ActionsColumn<TData> {
+    private config;
+    static make<TData>(): ActionsColumn<TData>;
+    label(label: string): this;
+    triggerIcon(icon: ReactNode): this;
+    action(action: ActionItem<TData>): this;
+    view(onClick: (row: TData) => void): this;
+    edit(onClick: (row: TData) => void): this;
+    delete(onClick: (row: TData) => void): this;
+    link(label: string, href: (row: TData) => string): this;
+    separator(): this;
+    build(): ColumnDef<TData, unknown>;
+}

package/dist/forms/columns/avatar-group-column.d.ts

@@ -0,0 +1,38 @@
+import { ColumnDef } from "@tanstack/react-table";
+import { BaseColumn } from "./base-column";
+import { BaseColumnConfig } from "./types";
+interface AvatarItem {
+    src?: string;
+    name: string;
+    fallback?: string;
+}
+interface AvatarGroupColumnConfig<TData> extends BaseColumnConfig<TData> {
+    maxVisible?: number;
+    size?: number;
+    overlap?: "none" | "sm" | "md" | "lg";
+    showTooltip?: boolean;
+    nameField?: keyof TData | ((row: TData) => AvatarItem[]);
+    srcField?: string;
+    fallbackField?: string;
+    showNames?: boolean;
+    maxNames?: number;
+}
+export declare class AvatarGroupColumn<TData> extends BaseColumn<TData, AvatarGroupColumnConfig<TData>> {
+    constructor(accessor: keyof TData | string);
+    static make<TData>(accessor: keyof TData | string): AvatarGroupColumn<TData>;
+    maxVisible(max: number): this;
+    size(size: "xs" | "sm" | "md" | "lg"): this;
+    overlap(overlap: "none" | "sm" | "md" | "lg"): this;
+    noOverlap(): this;
+    hideTooltip(): this;
+    fields(config: {
+        src?: string;
+        name: string;
+        fallback?: string;
+    }): this;
+    mapItems(fn: (row: TData) => AvatarItem[]): this;
+    showNames(show?: boolean, max?: number): this;
+    private toContactItems;
+    build(): ColumnDef<TData, unknown>;
+}
+export {};

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

@@ -0,0 +1,29 @@
+import { ColumnDef } from "@tanstack/react-table";
+import { ReactNode } from "react";
+import { BaseColumn } from "./base-column";
+import { BadgeColumnConfig } from "./types";
+type BadgeVariant = "default" | "secondary" | "destructive" | "outline" | "success" | "warning" | "info" | "muted";
+interface VariantConfig {
+    label?: string;
+    variant?: BadgeVariant;
+    className?: string;
+    icon?: ReactNode;
+}
+export declare class BadgeColumn<TData> extends BaseColumn<TData, BadgeColumnConfig<TData>> {
+    static make<TData>(accessor: keyof TData | string): BadgeColumn<TData>;
+    variants(variants: Record<string, VariantConfig>): this;
+    boolean(trueLabel?: string, falseLabel?: string): this;
+    status(statuses: Record<string, {
+        label: string;
+        color: string;
+    }>): this;
+    variantFn(fn: (value: unknown, row: TData) => {
+        label?: string;
+        variant?: BadgeVariant;
+        className?: string;
+        icon?: ReactNode;
+    }): this;
+    classNameFn(fn: (value: unknown, row: TData) => string): this;
+    build(): ColumnDef<TData, unknown>;
+}
+export {};

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

@@ -0,0 +1,21 @@
+import { ColumnDef } from "@tanstack/react-table";
+import { BaseColumnConfig } from "./types";
+export declare abstract class BaseColumn<TData, TConfig extends BaseColumnConfig<TData>> {
+    protected config: TConfig;
+    constructor(accessor: keyof TData | string);
+    label(label: string): this;
+    sortable(sortable?: boolean): this;
+    searchable(searchable?: boolean): this;
+    hidden(hidden?: boolean): this;
+    visibleByDefault(visible?: boolean): this;
+    visibilityLabel(label: string): this;
+    alignLeft(): this;
+    alignCenter(): this;
+    alignRight(): this;
+    width(width: string | number): this;
+    className(className: string): this;
+    headerClassName(className: string): this;
+    cellClassName(className: string): this;
+    abstract build(): ColumnDef<TData, unknown>;
+    protected getAlignmentClass(): string;
+}

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

@@ -0,0 +1,14 @@
+interface ButtonColumnConfig {
+    accessorKey?: string;
+    header?: string;
+    label?: string;
+    onClick?: (data: any) => void;
+}
+export declare const ButtonColumn: (config: ButtonColumnConfig) => {
+    accessorKey: string;
+    header: string;
+    cell: ({ row }: {
+        row: any;
+    }) => import("react/jsx-runtime").JSX.Element;
+};
+export { ButtonColumn as buttonColumn };

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

@@ -0,0 +1,5 @@
+import { ColumnDef } from "@tanstack/react-table";
+export declare class CheckboxColumn<TData> {
+    static make<TData>(): CheckboxColumn<TData>;
+    build(): ColumnDef<TData, unknown>;
+}

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

@@ -0,0 +1,24 @@
+import { ColumnDef } from "@tanstack/react-table";
+import { BaseColumn } from "./base-column";
+import { BaseColumnConfig } from "./types";
+interface DateColumnConfig<TData> extends BaseColumnConfig<TData> {
+    format?: "short" | "long" | "relative" | "time" | "datetime" | string;
+    locale?: string;
+    showIcon?: boolean;
+}
+export declare class DateColumn<TData> extends BaseColumn<TData, DateColumnConfig<TData>> {
+    constructor(accessor: keyof TData | string);
+    static make<TData>(accessor: keyof TData | string): DateColumn<TData>;
+    format(format: "short" | "long" | "relative" | "time" | "datetime"): this;
+    locale(locale: string): this;
+    withIcon(show?: boolean): this;
+    short(): this;
+    long(): this;
+    relative(): this;
+    time(): this;
+    datetime(): this;
+    private formatDate;
+    private getRelativeTime;
+    build(): ColumnDef<TData, unknown>;
+}
+export {};

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

@@ -0,0 +1,17 @@
+interface DropdownOption {
+    label: string;
+    onClick?: (data: any) => void;
+}
+interface DropdownColumnConfig {
+    accessorKey?: string;
+    header?: string;
+    options: DropdownOption[];
+}
+export declare const DropdownColumn: (config: DropdownColumnConfig) => {
+    accessorKey: string;
+    header: string;
+    cell: ({ row }: {
+        row: any;
+    }) => import("react/jsx-runtime").JSX.Element;
+};
+export { DropdownColumn as dropdownColumn };

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

@@ -0,0 +1,52 @@
+import { ColumnDef } from "@tanstack/react-table";
+import { LucideIcon } from "lucide-react";
+import { BaseColumn } from "./base-column";
+import { BaseColumnConfig } from "./types";
+export interface EnumOption<T = string | number> {
+    value: T;
+    label: string;
+    icon?: LucideIcon;
+    color?: "default" | "secondary" | "destructive" | "outline" | "success" | "warning" | "info";
+    className?: string;
+}
+interface EnumColumnConfig<TData> extends BaseColumnConfig<TData> {
+    options: EnumOption[];
+    asBadge?: boolean;
+    showIcon?: boolean;
+    iconPosition?: "left" | "right";
+    placeholder?: string;
+}
+export declare class EnumColumn<TData> extends BaseColumn<TData, EnumColumnConfig<TData>> {
+    constructor(accessor: keyof TData | string);
+    static make<TData>(accessor: keyof TData | string): EnumColumn<TData>;
+    /**
+     * Define the enum options with labels, icons, and colors
+     */
+    options(options: EnumOption[]): this;
+    /**
+     * Display as plain text instead of badge
+     */
+    asText(): this;
+    /**
+     * Display as badge (default)
+     */
+    asBadge(): this;
+    /**
+     * Hide icons
+     */
+    hideIcon(): this;
+    /**
+     * Show icons (default)
+     */
+    showIcon(): this;
+    /**
+     * Set icon position
+     */
+    iconPosition(position: "left" | "right"): this;
+    /**
+     * Placeholder for unknown values
+     */
+    placeholder(placeholder: string): this;
+    build(): ColumnDef<TData, unknown>;
+}
+export {};

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

@@ -0,0 +1,58 @@
+import { ColumnDef } from "@tanstack/react-table";
+import { LucideIcon } from "lucide-react";
+import { ReactNode } from "react";
+import { BaseColumn } from "./base-column";
+import { BaseColumnConfig } from "./types";
+interface IconState {
+    icon: ReactNode | LucideIcon;
+    label?: string;
+    color?: string;
+    bgColor?: string;
+    tooltip?: string;
+}
+interface IconColumnConfig<TData> extends BaseColumnConfig<TData> {
+    states?: Record<string, IconState>;
+    size?: "xs" | "sm" | "md" | "lg";
+    showLabel?: boolean;
+    showTooltip?: boolean;
+    withBackground?: boolean;
+    defaultIcon?: ReactNode;
+    defaultLabel?: string;
+}
+export declare class IconColumn<TData> extends BaseColumn<TData, IconColumnConfig<TData>> {
+    constructor(accessor: keyof TData | string);
+    static make<TData>(accessor: keyof TData | string): IconColumn<TData>;
+    state(value: string, config: IconState): this;
+    states(states: Record<string, IconState>): this;
+    size(size: "xs" | "sm" | "md" | "lg"): this;
+    showLabel(show?: boolean): this;
+    hideTooltip(): this;
+    withBackground(show?: boolean): this;
+    default(icon: ReactNode, label?: string): this;
+    boolean(config?: {
+        trueIcon?: ReactNode;
+        falseIcon?: ReactNode;
+        trueLabel?: string;
+        falseLabel?: string;
+        trueColor?: string;
+        falseColor?: string;
+        trueBgColor?: string;
+        falseBgColor?: string;
+    }): this;
+    activeInactive(): this;
+    onlineStatus(): this;
+    priority(): this;
+    verification(): this;
+    private createCheckIcon;
+    private createXIcon;
+    private createCircleIcon;
+    private createArrowUpIcon;
+    private createArrowDownIcon;
+    private createMinusIcon;
+    private createAlertIcon;
+    private createShieldCheckIcon;
+    private createShieldXIcon;
+    private createClockIcon;
+    build(): ColumnDef<TData, unknown>;
+}
+export {};

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

@@ -0,0 +1,21 @@
+import { ColumnDef } from "@tanstack/react-table";
+import { BaseColumn } from "./base-column";
+import { BaseColumnConfig } from "./types";
+interface ImageColumnConfig<TData> extends BaseColumnConfig<TData> {
+    size?: "sm" | "md" | "lg";
+    rounded?: "none" | "sm" | "md" | "lg" | "full";
+    fallback?: string;
+    alt?: (row: TData) => string;
+}
+export declare class ImageColumn<TData> extends BaseColumn<TData, ImageColumnConfig<TData>> {
+    constructor(accessor: keyof TData | string);
+    static make<TData>(accessor: keyof TData | string): ImageColumn<TData>;
+    size(size: "sm" | "md" | "lg"): this;
+    rounded(rounded: "none" | "sm" | "md" | "lg" | "full"): this;
+    circular(): this;
+    square(): this;
+    fallback(url: string): this;
+    alt(fn: (row: TData) => string): this;
+    build(): ColumnDef<TData, unknown>;
+}
+export {};

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

@@ -0,0 +1,18 @@
+export { AvatarGroupColumn } from "./avatar-group-column";
+export { BadgeColumn } from "./badge-column";
+export { ButtonColumn } from "./button-column";
+export { CheckboxColumn } from "./checkbox-column";
+export { DateColumn } from "./date-column";
+export { DropdownColumn } from "./dropdown-column";
+export { IconColumn } from "./icon-column";
+export { ImageColumn } from "./image-column";
+export { InputColumn } from "./input-column";
+export { LinkColumn } from "./link-column";
+export { NumberColumn } from "./number-column";
+export { ProgressColumn } from "./progress-column";
+export { SelectColumn } from "./select-column";
+export { TextColumn } from "./text-column";
+export { ActionsColumn } from "./actions-column";
+export { EnumColumn } from "./enum-column";
+export type { EnumOption } from "./enum-column";
+export type * from "./types";

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>;
+}