@nccirtu/tablefy 0.1.1 → 0.1.4

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

@@ -0,0 +1,26 @@
+import { ColumnDef } from '@tanstack/react-table';
+import { ReactNode } from 'react';
+interface ActionItem<TData> {
+    label: string;
+    icon?: ReactNode;
+    onClick?: (row: TData) => void;
+    href?: (row: TData) => string;
+    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>;
+}
+export {};

package/dist/columns/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?: "xs" | "sm" | "md" | "lg";
+    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/columns/columns/badge-column.d.ts

@@ -0,0 +1,22 @@
+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;
+    build(): ColumnDef<TData, unknown>;
+}
+export {};

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

@@ -0,0 +1,19 @@
+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;
+    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/columns/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/columns/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/columns/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/columns/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/columns/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/columns/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/columns/columns/index.d.ts

@@ -0,0 +1,16 @@
+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 type * from "./types";

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

@@ -0,0 +1,14 @@
+interface InputColumnConfig {
+    accessorKey?: string;
+    header?: string;
+    placeholder?: string;
+    onChange?: (data: any, value: string) => void;
+}
+export declare const InputColumn: (config: InputColumnConfig) => {
+    accessorKey: string;
+    header: string;
+    cell: ({ row }: {
+        row: any;
+    }) => import("react/jsx-runtime").JSX.Element;
+};
+export { InputColumn as inputColumn };

package/dist/columns/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/columns/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/columns/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/columns/columns/select-column.d.ts

@@ -0,0 +1,19 @@
+interface SelectOption {
+    label: string;
+    value: string;
+}
+interface SelectColumnConfig {
+    accessorKey?: string;
+    header?: string;
+    placeholder?: string;
+    options: SelectOption[];
+    onChange?: (data: any, value: string) => void;
+}
+export declare const SelectColumn: (config: SelectColumnConfig) => {
+    accessorKey: string;
+    header: string;
+    cell: ({ row }: {
+        row: any;
+    }) => import("react/jsx-runtime").JSX.Element;
+};
+export { SelectColumn as selectColumn };

package/dist/columns/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/columns/columns/types.d.ts

@@ -0,0 +1,37 @@
+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;
+    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;
+    }>;
+}
+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/columns/components/animata/list/avatar-list.d.ts

@@ -0,0 +1,12 @@
+export declare const AvatarList: ({ items, maxVisible, size, ...props }: {
+    items: Array<{
+        id: string;
+        src?: string;
+        alt?: string;
+        initials?: string;
+    }>;
+    maxVisible?: number;
+    size?: number | string;
+    [key: string]: any;
+}) => import("react/jsx-runtime").JSX.Element;
+export default AvatarList;

package/dist/columns/components/ui/badge.d.ts

@@ -0,0 +1,9 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const badgeVariants: (props?: ({
+    variant?: "link" | "default" | "secondary" | "outline" | "ghost" | "destructive" | "success" | "warning" | "info" | "muted" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+declare function Badge({ className, variant, asChild, ...props }: React.ComponentProps<"span"> & VariantProps<typeof badgeVariants> & {
+    asChild?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export { Badge, badgeVariants };

package/dist/columns/components/ui/button.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+import { type VariantProps } from "class-variance-authority";
+declare const buttonVariants: (props?: ({
+    variant?: "link" | "default" | "secondary" | "outline" | "ghost" | "destructive" | "table_header" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | "table_header" | "xs" | "icon-xs" | "icon-sm" | "icon-lg" | null | undefined;
+} & import("class-variance-authority/dist/types").ClassProp) | undefined) => string;
+declare function Button({ className, variant, size, asChild, ...props }: React.ComponentProps<"button"> & VariantProps<typeof buttonVariants> & {
+    asChild?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+export { Button, buttonVariants };

package/dist/columns/components/ui/checkbox.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import { Checkbox as CheckboxPrimitive } from "radix-ui";
+declare function Checkbox({ className, ...props }: React.ComponentProps<typeof CheckboxPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export { Checkbox };

package/dist/columns/components/ui/data-table/data-table-empty.d.ts

@@ -0,0 +1,8 @@
+import { EmptyStateConfig } from "@/lib/types";
+interface DataTableEmptyProps {
+    config: EmptyStateConfig;
+    colSpan: number;
+    className?: string;
+}
+export declare function DataTableEmpty({ config, colSpan, className, }: DataTableEmptyProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/columns/components/ui/data-table/data-table-header.d.ts

@@ -0,0 +1,15 @@
+import { Table as TanstackTable } from "@tanstack/react-table";
+import { HeaderAction, SearchConfig } from "@/lib/types";
+interface DataTableHeaderProps<TData> {
+    title?: string;
+    description?: string;
+    actions?: HeaderAction<TData>[];
+    search?: SearchConfig;
+    searchValue?: string;
+    onSearchChange?: (value: string) => void;
+    table?: TanstackTable<TData>;
+    selectedCount?: number;
+    className?: string;
+}
+export declare function DataTableHeader<TData>({ title, description, actions, search, searchValue, onSearchChange, table, selectedCount, className, }: DataTableHeaderProps<TData>): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/columns/components/ui/data-table/data-table-pagination.d.ts

@@ -0,0 +1,9 @@
+import { Table as TanstackTable } from "@tanstack/react-table";
+import { PaginationConfig } from "@/lib/types";
+interface DataTablePaginationProps<TData> {
+    table: TanstackTable<TData>;
+    config?: PaginationConfig;
+    className?: string;
+}
+export declare function DataTablePagination<TData>({ table, config, className, }: DataTablePaginationProps<TData>): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/columns/components/ui/data-table/data-table-schema.d.ts

@@ -0,0 +1,5 @@
+interface DataTableSchemaProps {
+    [key: string]: any;
+}
+export declare const DataTableSchema: (props: DataTableSchemaProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/columns/components/ui/data-table/data-table.d.ts

@@ -0,0 +1,13 @@
+import { ColumnDef } from "@tanstack/react-table";
+import { DataTableConfig } from "@/lib/types";
+interface DataTableProps<TData, TValue> {
+    columns: ColumnDef<TData, TValue>[];
+    data: TData[];
+    config?: DataTableConfig<TData>;
+    className?: string;
+    isLoading?: boolean;
+    isError?: boolean;
+    onRetry?: () => void;
+}
+export declare function DataTable<TData, TValue>({ columns, data, config, className, isLoading, isError, onRetry, }: DataTableProps<TData, TValue>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/columns/components/ui/dropdown-menu.d.ts

@@ -0,0 +1,25 @@
+import * as React from "react";
+import { DropdownMenu as DropdownMenuPrimitive } from "radix-ui";
+declare function DropdownMenu({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuPortal({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuTrigger({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuContent({ className, align, sideOffset, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuGroup({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Group>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuItem({ className, inset, variant, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Item> & {
+    inset?: boolean;
+    variant?: "default" | "destructive";
+}): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuCheckboxItem({ className, children, checked, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.CheckboxItem>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuRadioGroup({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioGroup>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuRadioItem({ className, children, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioItem>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuLabel({ className, inset, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Label> & {
+    inset?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuSeparator({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Separator>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuShortcut({ className, ...props }: React.ComponentProps<"span">): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuSub({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Sub>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuSubTrigger({ className, inset, children, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.SubTrigger> & {
+    inset?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuSubContent({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.SubContent>): import("react/jsx-runtime").JSX.Element;
+export { DropdownMenu, DropdownMenuPortal, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuGroup, DropdownMenuLabel, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubTrigger, DropdownMenuSubContent, };

package/dist/columns/components/ui/input.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare function Input({ className, type, ...props }: React.ComponentProps<"input">): import("react/jsx-runtime").JSX.Element;
+export { Input };

package/dist/columns/components/ui/progress.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import { Progress as ProgressPrimitive } from "radix-ui";
+declare function Progress({ className, value, ...props }: React.ComponentProps<typeof ProgressPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export { Progress };

package/dist/columns/components/ui/select.d.ts

@@ -0,0 +1,15 @@
+import * as React from "react";
+import { Select as SelectPrimitive } from "radix-ui";
+declare function Select({ ...props }: React.ComponentProps<typeof SelectPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function SelectGroup({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Group>): import("react/jsx-runtime").JSX.Element;
+declare function SelectValue({ ...props }: React.ComponentProps<typeof SelectPrimitive.Value>): import("react/jsx-runtime").JSX.Element;
+declare function SelectTrigger({ className, size, children, ...props }: React.ComponentProps<typeof SelectPrimitive.Trigger> & {
+    size?: "sm" | "default";
+}): import("react/jsx-runtime").JSX.Element;
+declare function SelectContent({ className, children, position, align, ...props }: React.ComponentProps<typeof SelectPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+declare function SelectLabel({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Label>): import("react/jsx-runtime").JSX.Element;
+declare function SelectItem({ className, children, ...props }: React.ComponentProps<typeof SelectPrimitive.Item>): import("react/jsx-runtime").JSX.Element;
+declare function SelectSeparator({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Separator>): import("react/jsx-runtime").JSX.Element;
+declare function SelectScrollUpButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollUpButton>): import("react/jsx-runtime").JSX.Element;
+declare function SelectScrollDownButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollDownButton>): import("react/jsx-runtime").JSX.Element;
+export { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, };

package/dist/columns/components/ui/table.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+declare function Table({ className, ...props }: React.ComponentProps<"table">): import("react/jsx-runtime").JSX.Element;
+declare function TableHeader({ className, ...props }: React.ComponentProps<"thead">): import("react/jsx-runtime").JSX.Element;
+declare function TableBody({ className, ...props }: React.ComponentProps<"tbody">): import("react/jsx-runtime").JSX.Element;
+declare function TableFooter({ className, ...props }: React.ComponentProps<"tfoot">): import("react/jsx-runtime").JSX.Element;
+declare function TableRow({ className, ...props }: React.ComponentProps<"tr">): import("react/jsx-runtime").JSX.Element;
+declare function TableHead({ className, ...props }: React.ComponentProps<"th">): import("react/jsx-runtime").JSX.Element;
+declare function TableCell({ className, ...props }: React.ComponentProps<"td">): import("react/jsx-runtime").JSX.Element;
+declare function TableCaption({ className, ...props }: React.ComponentProps<"caption">): import("react/jsx-runtime").JSX.Element;
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption, };

package/dist/columns/components/ui/tooltip.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+import { Tooltip as TooltipPrimitive } from "radix-ui";
+declare function TooltipProvider({ delayDuration, ...props }: React.ComponentProps<typeof TooltipPrimitive.Provider>): import("react/jsx-runtime").JSX.Element;
+declare function Tooltip({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function TooltipTrigger({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function TooltipContent({ className, sideOffset, children, ...props }: React.ComponentProps<typeof TooltipPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+export { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger };