@eintrek/erp-theme 1.0.3 → 1.4.3

package/dist/components/data-table/data-table-cell.d.ts

@@ -0,0 +1,35 @@
+import type * as React from "react";
+interface DataTableCellProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: React.ReactNode;
+    title?: string;
+    truncate?: boolean;
+    maxWidth?: string;
+    showTooltip?: boolean;
+    className?: string;
+    lineClamp?: 1 | 2 | 3 | 4 | 5 | 6;
+}
+/**
+ * Reusable cell component with truncation and tooltip support
+ *
+ * @example
+ * // Basic usage with truncation
+ * <DataTableCell truncate title="Full text content">
+ *   Long text that will be truncated
+ * </DataTableCell>
+ *
+ * @example
+ * // Multi-line truncation
+ * <DataTableCell truncate lineClamp={2} maxWidth="300px">
+ *   Multi-line text content
+ * </DataTableCell>
+ *
+ * @example
+ * // Without truncation (default)
+ * <DataTableCell>
+ *   Normal cell content
+ * </DataTableCell>
+ */
+export declare function DataTableCell({ children, title, truncate, maxWidth, width, showTooltip, lineClamp, className, ...props }: DataTableCellProps & {
+    width?: string;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/data-table/data-table-column-header.d.ts

@@ -1,8 +1,9 @@
 import type { Column } from "@tanstack/react-table";
-import { DropdownMenuTrigger } from "@/components/ui/dropdown-menu";
+import { DropdownMenuTrigger } from "../../index";
 interface DataTableColumnHeaderProps<TData, TValue> extends React.ComponentProps<typeof DropdownMenuTrigger> {
     column: Column<TData, TValue>;
     title: string;
+    sortable?: boolean;
 }
-export declare function DataTableColumnHeader<TData, TValue>({ column, title, className, ...props }: DataTableColumnHeaderProps<TData, TValue>): import("react/jsx-runtime").JSX.Element;
+export declare function DataTableColumnHeader<TData, TValue>({ column, title, className, sortable, ...props }: DataTableColumnHeaderProps<TData, TValue>): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/data-table/data-table-faceted-filter.d.ts

@@ -1,5 +1,5 @@
-import type { Option } from "@/types/data-table";
 import type { Column } from "@tanstack/react-table";
+import type { Option } from "./data-table-types";
 interface DataTableFacetedFilterProps<TData, TValue> {
     column?: Column<TData, TValue>;
     title?: string;

package/dist/components/data-table/data-table-filter-dropdown.d.ts

@@ -0,0 +1,12 @@
+import * as React from "react";
+interface DataTableFilterDropdownProps {
+    children: React.ReactNode;
+    className?: string;
+    buttonText?: string;
+    icon?: React.ReactNode;
+    variant?: "default" | "outline";
+    /** Applied to PopoverContent (e.g. min-w-[520px] for custom filter layout) */
+    contentClassName?: string;
+}
+export declare function DataTableFilterDropdown({ children, className, buttonText, icon, variant, contentClassName, }: DataTableFilterDropdownProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/data-table/data-table-filter-list.d.ts

@@ -1,6 +1,6 @@
 import type { Table } from "@tanstack/react-table";
 import * as React from "react";
-import { PopoverContent } from "@/components/ui/popover";
+import { PopoverContent } from "../../index";
 interface DataTableFilterListProps<TData> extends React.ComponentProps<typeof PopoverContent> {
     table: Table<TData>;
     debounceMs?: number;

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

@@ -1,7 +1,21 @@
 import type { Table } from "@tanstack/react-table";
+import * as React from "react";
 interface DataTablePaginationProps<TData> extends React.ComponentProps<"div"> {
     table: Table<TData>;
     pageSizeOptions?: number[];
 }
-export declare function DataTablePagination<TData>({ table, pageSizeOptions, className, ...props }: DataTablePaginationProps<TData>): import("react/jsx-runtime").JSX.Element;
+export declare function DataTablePagination<TData>({ table, pageSizeOptions, className, ...props }: DataTablePaginationProps<TData>): import("react/jsx-runtime").JSX.Element | null;
+/**
+ * SimplePagination - A standalone pagination component for non-DataTable use cases
+ */
+interface SimplePaginationProps extends React.ComponentProps<"div"> {
+    currentPage: number;
+    totalPages: number;
+    onPageChange: (page: number) => void;
+    totalItems?: number;
+    pageSize?: number;
+    pageSizeOptions?: number[];
+    onPageSizeChange?: (pageSize: number) => void;
+}
+export declare function SimplePagination({ currentPage, totalPages, onPageChange, totalItems, pageSize, pageSizeOptions, onPageSizeChange, className, ...props }: SimplePaginationProps): import("react/jsx-runtime").JSX.Element | null;
 export {};

package/dist/components/data-table/data-table-range-filter.d.ts

@@ -1,6 +1,6 @@
 import type { Column } from "@tanstack/react-table";
 import * as React from "react";
-import type { ExtendedColumnFilter } from "@/types/data-table";
+import type { ExtendedColumnFilter } from "./data-table-types";
 interface DataTableRangeFilterProps<TData> extends React.ComponentProps<"div"> {
     filter: ExtendedColumnFilter<TData>;
     column: Column<TData>;

package/dist/components/data-table/data-table-slider-filter.d.ts

@@ -1,7 +1,6 @@
 import type { Column } from "@tanstack/react-table";
 interface DataTableSliderFilterProps<TData> {
     column: Column<TData, unknown>;
-    title?: string;
 }
-export declare function DataTableSliderFilter<TData>({ column, title, }: DataTableSliderFilterProps<TData>): import("react/jsx-runtime").JSX.Element;
+export declare function DataTableSliderFilter<TData>({ column, }: DataTableSliderFilterProps<TData>): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/data-table/data-table-sort-list.d.ts

@@ -1,6 +1,6 @@
 import type { Table } from "@tanstack/react-table";
 import * as React from "react";
-import { PopoverContent } from "@/components/ui/popover";
+import { PopoverContent } from "../../index";
 interface DataTableSortListProps<TData> extends React.ComponentProps<typeof PopoverContent> {
     table: Table<TData>;
 }

package/dist/components/data-table/data-table-toolbar.d.ts

@@ -2,6 +2,11 @@ import type { Table } from "@tanstack/react-table";
 import * as React from "react";
 interface DataTableToolbarProps<TData> extends React.ComponentProps<"div"> {
     table: Table<TData>;
+    mode?: "simple" | "advanced";
+    /** Custom filter content; when set, shown inside the filter dropdown instead of default column filters */
+    filterContent?: React.ReactNode;
+    /** Optional class for the filter dropdown popover when using filterContent (e.g. min-w-[560px]) */
+    filterDropdownContentClassName?: string;
 }
-export declare function DataTableToolbar<TData>({ table, children, className, ...props }: DataTableToolbarProps<TData>): import("react/jsx-runtime").JSX.Element;
+export declare function DataTableToolbar<TData>({ table, mode, filterContent, filterDropdownContentClassName, className, ...props }: DataTableToolbarProps<TData>): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/data-table/data-table-types.d.ts

@@ -0,0 +1,115 @@
+import type * as React from "react";
+import type { ColumnSort, Row } from "@tanstack/react-table";
+import { z } from "zod";
+import type { DataTableConfig } from "./data-table-config";
+import type { Column } from "@tanstack/react-table";
+export interface Option {
+    label: string;
+    value: string;
+    icon?: React.ComponentType<{
+        className?: string;
+    }>;
+    count?: number;
+}
+export type FilterOperator = DataTableConfig["operators"][number];
+export type FilterVariant = DataTableConfig["filterVariants"][number];
+export type JoinOperator = DataTableConfig["joinOperators"][number];
+declare const filterItemSchema: z.ZodObject<{
+    id: z.ZodString;
+    value: z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>;
+    variant: z.ZodEnum<[string, ...string[]]>;
+    operator: z.ZodEnum<[string, ...string[]]>;
+    filterId: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    value: string | string[];
+    operator: string;
+    variant: string;
+    filterId: string;
+}, {
+    id: string;
+    value: string | string[];
+    operator: string;
+    variant: string;
+    filterId: string;
+}>;
+export type FilterItemSchema = z.infer<typeof filterItemSchema>;
+export interface ExtendedColumnFilter<TData> extends FilterItemSchema {
+    id: Extract<keyof TData, string>;
+}
+export interface ExtendedColumnSort<TData> extends Omit<ColumnSort, "id"> {
+    id: Extract<keyof TData, string>;
+}
+export interface ToolbarColumnMeta {
+    variant?: "text" | "number" | "range" | "date" | "dateRange" | "select" | "multiSelect" | "boolean";
+    label?: string;
+    placeholder?: string;
+    unit?: string;
+    options?: Option[];
+    range?: [number, number];
+    icon?: React.ComponentType<{
+        className?: string;
+    }>;
+    sticky?: "left" | "right";
+    /** Pixel offset from the sticky edge — used when stacking multiple sticky
+     * columns on the same side (e.g. the second-to-right pinned column needs
+     * `stickyOffset` equal to the rightmost pinned column's width). */
+    stickyOffset?: number;
+    hideHeader?: boolean;
+    showLeftDivider?: boolean;
+    renderFilter?: (props: {
+        column: Column<unknown>;
+    }) => React.ReactNode;
+}
+export interface DataTableRowAction<TData> {
+    row: Row<TData>;
+    variant: "update" | "delete";
+}
+declare module "@tanstack/react-table" {
+    interface ColumnMeta<TData, TValue> extends ToolbarColumnMeta {
+    }
+    interface TableMeta<TData> {
+        queryKeys?: {
+            filters?: string;
+            joinOperator?: string;
+            sort?: string;
+            page?: string;
+            perPage?: string;
+        };
+    }
+}
+/**
+ * Get filters state parser for URL synchronization
+ */
+export declare const getFiltersStateParser: <TData>(columnIds?: string[] | Set<string>) => import("nuqs/server").SingleParserBuilder<ExtendedColumnFilter<TData>[]>;
+/**
+ * Get common pinning styles for table columns
+ */
+export declare function getCommonPinningStyles<TData>({ column, withBorder, }: {
+    column: Column<TData>;
+    withBorder?: boolean;
+}): React.CSSProperties;
+/**
+ * Get filter operators for a specific filter variant
+ */
+export declare function getFilterOperators(filterVariant: FilterVariant): {
+    label: string;
+    value: FilterOperator;
+}[];
+/**
+ * Get default filter operator for a filter variant
+ */
+export declare function getDefaultFilterOperator(filterVariant: FilterVariant): "iLike" | "notILike" | "eq" | "ne" | "isEmpty" | "isNotEmpty" | "lt" | "lte" | "gt" | "gte" | "isBetween" | "isRelativeToToday" | "inArray" | "notInArray";
+/**
+ * Get valid filters (remove empty/invalid filters)
+ */
+export declare function getValidFilters<TData>(filters: ExtendedColumnFilter<TData>[]): ExtendedColumnFilter<TData>[];
+export declare const getSortingStateParser: <TData>(columnIds?: string[] | Set<string>) => import("nuqs/server").SingleParserBuilder<ExtendedColumnSort<TData>[]>;
+export interface QueryKeys {
+    page: string;
+    perPage: string;
+    sort: string;
+    filters: string;
+    joinOperator: string;
+}
+export {};

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

@@ -1,8 +1,11 @@
-import { type Table as TanstackTable } from "@tanstack/react-table";
+import { type Table as TanstackTable, type Row } from "@tanstack/react-table";
 import type * as React from "react";
 interface DataTableProps<TData> extends React.ComponentProps<"div"> {
     table: TanstackTable<TData>;
     actionBar?: React.ReactNode;
+    isLoading?: boolean;
+    isFetching?: boolean;
+    getRowClassName?: (row: Row<TData>) => string;
 }
-export declare function DataTable<TData>({ table, actionBar, children, className, ...props }: DataTableProps<TData>): import("react/jsx-runtime").JSX.Element;
+export declare function DataTable<TData>({ table, actionBar, children, className, isLoading, isFetching, getRowClassName, ...props }: DataTableProps<TData>): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/data-table/hooks/use-callback-ref.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @see https://github.com/radix-ui/primitives/blob/main/packages/react/use-callback-ref/src/useCallbackRef.tsx
+ */
+/**
+ * A custom hook that converts a callback to a ref to avoid triggering re-renders when passed as a
+ * prop or avoid re-executing effects when passed as a dependency
+ */
+declare function useCallbackRef<T extends (...args: never[]) => unknown>(callback: T | undefined): T;
+export { useCallbackRef };

package/dist/{hooks → components/data-table/hooks}/use-data-table.d.ts

@@ -1,10 +1,11 @@
 import { type TableOptions, type TableState } from "@tanstack/react-table";
 import * as React from "react";
-import type { ExtendedColumnSort } from "@/types/data-table";
-interface UseDataTableProps<TData> extends Omit<TableOptions<TData>, "state" | "pageCount" | "getCoreRowModel" | "manualFiltering" | "manualPagination" | "manualSorting">, Required<Pick<TableOptions<TData>, "pageCount">> {
+import type { ExtendedColumnSort, QueryKeys } from "../data-table-types";
+export interface UseDataTableProps<TData> extends Omit<TableOptions<TData>, "state" | "pageCount" | "getCoreRowModel" | "manualFiltering" | "manualPagination" | "manualSorting">, Required<Pick<TableOptions<TData>, "pageCount">> {
     initialState?: Omit<Partial<TableState>, "sorting"> & {
         sorting?: ExtendedColumnSort<TData>[];
     };
+    queryKeys?: Partial<QueryKeys>;
     history?: "push" | "replace";
     debounceMs?: number;
     throttleMs?: number;
@@ -13,6 +14,7 @@ interface UseDataTableProps<TData> extends Omit<TableOptions<TData>, "state" | "
     scroll?: boolean;
     shallow?: boolean;
     startTransition?: React.TransitionStartFunction;
+    resetOnMount?: boolean;
 }
 export declare function useDataTable<TData>(props: UseDataTableProps<TData>): {
     table: import("@tanstack/react-table").Table<TData>;
@@ -20,4 +22,3 @@ export declare function useDataTable<TData>(props: UseDataTableProps<TData>): {
     debounceMs: number;
     throttleMs: number;
 };
-export {};

package/dist/components/data-table/hooks/use-debounced-callback.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @see https://github.com/mantinedev/mantine/blob/master/packages/@mantine/hooks/src/use-debounced-callback/use-debounced-callback.ts
+ */
+export declare function useDebouncedCallback<T extends (...args: never[]) => unknown>(callback: T, delay: number): (...args: Parameters<T>) => void;

package/dist/components/data-table/hooks/use-media-query.d.ts

@@ -0,0 +1 @@
+export declare function useMediaQuery(query: string): boolean;

package/dist/components/data-table/index.d.ts

@@ -0,0 +1,17 @@
+export { DataTable } from "./data-table";
+export { DataTableCell } from "./data-table-cell";
+export { DataTableColumnHeader } from "./data-table-column-header";
+export { DataTablePagination } from "./data-table-pagination";
+export { DataTableSkeleton } from "./data-table-skeleton";
+export { DataTableDateFilter } from "./data-table-date-filter";
+export { DataTableFacetedFilter } from "./data-table-faceted-filter";
+export { DataTableSliderFilter } from "./data-table-slider-filter";
+export { DataTableToolbar } from "./data-table-toolbar";
+export { DataTableViewOptions } from "./data-table-view-options";
+export { DataTableSortList } from "./data-table-sort-list";
+export { DataTableFilterList } from "./data-table-filter-list";
+export { useDataTable, type UseDataTableProps } from "./hooks/use-data-table";
+export { DataTableRangeFilter } from "./data-table-range-filter";
+export { DataTableFilterDropdown } from "./data-table-filter-dropdown";
+export { dataTableConfig, type DataTableConfig } from "./data-table-config";
+export * from "./data-table-types";

package/dist/components/ui/calendar.d.ts

@@ -1,8 +1,23 @@
-import * as React from "react";
-import { DayButton, DayPicker } from "react-day-picker";
-import { Button } from "@/components/ui/button";
-declare function Calendar({ className, classNames, showOutsideDays, captionLayout, buttonVariant, formatters, components, ...props }: React.ComponentProps<typeof DayPicker> & {
-    buttonVariant?: React.ComponentProps<typeof Button>["variant"];
-}): import("react/jsx-runtime").JSX.Element;
-declare function CalendarDayButton({ className, day, modifiers, ...props }: React.ComponentProps<typeof DayButton>): import("react/jsx-runtime").JSX.Element;
-export { Calendar, CalendarDayButton };
+export interface DateRange {
+    from?: Date;
+    to?: Date;
+}
+interface CalendarProps {
+    className?: string;
+    selected?: Date | Date[] | DateRange;
+    onSelect?: (date: Date | Date[] | DateRange | undefined) => void;
+    mode?: "single" | "range" | "multiple";
+    initialFocus?: boolean;
+    showOutsideDays?: boolean;
+    disabled?: (date: Date) => boolean;
+}
+declare function Calendar({ className, selected, onSelect, mode, disabled, }: CalendarProps): import("react/jsx-runtime").JSX.Element;
+interface DateInputProps {
+    value?: Date;
+    onChange?: (date: Date | undefined) => void;
+    placeholder?: string;
+    className?: string;
+    disabled?: boolean;
+}
+declare function DateInput({ value, onChange, placeholder, className, disabled }: DateInputProps): import("react/jsx-runtime").JSX.Element;
+export { Calendar, DateInput };

package/dist/components/ui/carousel.d.ts

@@ -1,6 +1,6 @@
 import useEmblaCarousel, { type UseEmblaCarouselType } from "embla-carousel-react";
 import * as React from "react";
-import { Button } from "@/components/ui/button";
+import { Button } from "./button";
 type CarouselApi = UseEmblaCarouselType[1];
 type UseCarouselParameters = Parameters<typeof useEmblaCarousel>;
 type CarouselOptions = UseCarouselParameters[0];

package/dist/components/ui/command.d.ts

@@ -1,6 +1,6 @@
 import { Command as CommandPrimitive } from "cmdk";
 import * as React from "react";
-import { Dialog } from "@/components/ui/dialog";
+import { Dialog } from "./dialog";
 declare function Command({ className, ...props }: React.ComponentProps<typeof CommandPrimitive>): import("react/jsx-runtime").JSX.Element;
 declare function CommandDialog({ title, description, children, className, showCloseButton, ...props }: React.ComponentProps<typeof Dialog> & {
     title?: string;

package/dist/components/ui/custom-select-field2.d.ts

@@ -0,0 +1,18 @@
+import { Control, FieldValues, Path } from "react-hook-form";
+interface CustomSelectField2Props<T extends FieldValues> {
+    name: Path<T>;
+    label: string;
+    control: Control<T>;
+    options: {
+        label: string;
+        value: string;
+    }[];
+    placeholder: string;
+    searchPlaceholder?: string;
+    emptyText?: string;
+    required?: boolean;
+    readonly?: boolean;
+    className?: string;
+}
+export declare function CustomSelectField2<T extends FieldValues>({ name, label, control, options, placeholder, searchPlaceholder, emptyText, required, readonly, className, }: CustomSelectField2Props<T>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ui/date-picker-field.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+import { type DatePickerProps } from "./date-picker";
+export interface DatePickerFieldProps extends DatePickerProps {
+    label?: React.ReactNode;
+    helperText?: React.ReactNode;
+    error?: React.ReactNode;
+    required?: boolean;
+    containerClassName?: string;
+    labelClassName?: string;
+    messageClassName?: string;
+}
+declare function DatePickerField({ id, label, helperText, error, required, containerClassName, labelClassName, messageClassName, className, ...props }: DatePickerFieldProps): import("react/jsx-runtime").JSX.Element;
+export { DatePickerField };

package/dist/components/ui/date-picker.d.ts

@@ -0,0 +1,19 @@
+export interface DatePickerProps {
+    date?: Date;
+    onDateChange?: (date: Date | undefined) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    /** Restrict which dates are selectable. Default: no future dates and no dates before 1900-01-01. */
+    disabledDates?: (date: Date) => boolean;
+    /** Override the trigger label format. Defaults to Intl `th-TH` long format. */
+    formatDate?: (date: Date) => string;
+    className?: string;
+    id?: string;
+    /** Used as `aria-label` and trigger placeholder when no date is selected. */
+    ariaLabel?: string;
+    "aria-required"?: boolean;
+    "aria-invalid"?: boolean;
+    "aria-describedby"?: string;
+}
+declare function DatePicker({ date, onDateChange, placeholder, disabled, disabledDates, formatDate, className, id, ariaLabel, "aria-required": ariaRequired, "aria-invalid": ariaInvalid, "aria-describedby": ariaDescribedby, }: DatePickerProps): import("react/jsx-runtime").JSX.Element;
+export { DatePicker };

package/dist/components/ui/faceted.d.ts

@@ -1,6 +1,6 @@
 import * as React from "react";
-import { CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator } from "@/components/ui/command";
-import { Popover, PopoverContent, PopoverTrigger } from "@/components/ui/popover";
+import { CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList, CommandSeparator } from "./command";
+import { Popover, PopoverContent, PopoverTrigger } from "./popover";
 type FacetedValue<Multiple extends boolean> = Multiple extends true ? string[] : string;
 interface FacetedProps<Multiple extends boolean = false> extends React.ComponentProps<typeof Popover> {
     value?: FacetedValue<Multiple>;

package/dist/components/ui/file-uploader.d.ts

@@ -0,0 +1,33 @@
+export interface UploadedFile {
+    id: string;
+    file: File;
+    title: string;
+    url?: string;
+}
+/**
+ * Helper function to convert File objects to UploadedFile format
+ */
+export declare const convertFilesToUploadedFiles: (files: File[] | undefined) => UploadedFile[];
+/**
+ * Helper function to convert single File to UploadedFile format
+ */
+export declare const convertFileToUploadedFile: (file: File | undefined) => UploadedFile[];
+export interface FileUploaderProps {
+    label: string;
+    helperText?: string;
+    accept?: string;
+    maxSizeMB?: number;
+    multiple?: boolean;
+    onFilesChange: (files: UploadedFile[]) => void;
+    mode?: "create" | "edit" | "view";
+    className?: string;
+    buttonText?: string;
+    initialFiles?: UploadedFile[];
+}
+/**
+ * FileUploader Component
+ *
+ * A simple file uploader with validation and download functionality.
+ * Displays uploaded files as blue clickable links.
+ */
+export declare function FileUploader({ label, helperText, accept, maxSizeMB, multiple, onFilesChange, mode, className, buttonText, initialFiles, }: FileUploaderProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ui/form-skeleton.d.ts

@@ -0,0 +1,11 @@
+export interface FormSkeletonSection {
+    title: string;
+    fieldRows: number[];
+    gridCols?: 1 | 2 | 3;
+}
+export interface FormSkeletonProps {
+    sections: FormSkeletonSection[];
+    showActionButtons?: boolean;
+    className?: string;
+}
+export declare function FormSkeleton({ sections, showActionButtons, className, }: FormSkeletonProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ui/input-field.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+export interface InputFieldProps extends Omit<React.ComponentProps<"input">, "ref"> {
+    label?: React.ReactNode;
+    helperText?: React.ReactNode;
+    error?: React.ReactNode;
+    required?: boolean;
+    containerClassName?: string;
+    labelClassName?: string;
+    messageClassName?: string;
+    ref?: React.Ref<HTMLInputElement>;
+}
+declare function InputField({ id, label, helperText, error, required, containerClassName, labelClassName, messageClassName, className, ref, ...props }: InputFieldProps): import("react/jsx-runtime").JSX.Element;
+export { InputField };

package/dist/components/ui/loading-screen.d.ts

@@ -0,0 +1 @@
+export declare function LoadingScreen(): import("react/jsx-runtime").JSX.Element;

package/dist/components/ui/page-header.d.ts

@@ -0,0 +1,7 @@
+import { ReactNode } from "react";
+interface PageHeaderProps {
+    title: ReactNode;
+    actions?: ReactNode;
+}
+export declare function PageHeader({ title, actions }: PageHeaderProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ui/pagination.d.ts

@@ -1,5 +1,5 @@
 import * as React from "react";
-import { Button } from "@/components/ui/button";
+import { Button } from "./button";
 declare function Pagination({ className, ...props }: React.ComponentProps<"nav">): import("react/jsx-runtime").JSX.Element;
 declare function PaginationContent({ className, ...props }: React.ComponentProps<"ul">): import("react/jsx-runtime").JSX.Element;
 declare function PaginationItem({ ...props }: React.ComponentProps<"li">): import("react/jsx-runtime").JSX.Element;

package/dist/components/ui/select-field.d.ts

@@ -0,0 +1,31 @@
+import * as React from "react";
+export interface SelectFieldOption {
+    value: string;
+    label: React.ReactNode;
+    disabled?: boolean;
+}
+export interface SelectFieldProps {
+    id?: string;
+    label?: React.ReactNode;
+    helperText?: React.ReactNode;
+    error?: React.ReactNode;
+    required?: boolean;
+    placeholder?: string;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    disabled?: boolean;
+    /** Declarative list of options. Ignored when `children` is provided. */
+    options?: SelectFieldOption[];
+    /** Use this to compose custom `<SelectContent>` children. Overrides `options`. */
+    children?: React.ReactNode;
+    containerClassName?: string;
+    labelClassName?: string;
+    triggerClassName?: string;
+    messageClassName?: string;
+    size?: "sm" | "default";
+    "aria-label"?: string;
+    "aria-describedby"?: string;
+}
+declare function SelectField({ id, label, helperText, error, required, placeholder, value, defaultValue, onValueChange, disabled, options, children, containerClassName, labelClassName, triggerClassName, messageClassName, size, "aria-label": ariaLabel, "aria-describedby": ariaDescribedby, }: SelectFieldProps): import("react/jsx-runtime").JSX.Element;
+export { SelectField };

package/dist/components/ui/sidebar.d.ts

@@ -1,9 +1,9 @@
 import { VariantProps } from "class-variance-authority";
 import * as React from "react";
-import { Button } from "@/components/ui/button";
-import { Input } from "@/components/ui/input";
-import { Separator } from "@/components/ui/separator";
-import { TooltipContent } from "@/components/ui/tooltip";
+import { Button } from "./button";
+import { Input } from "./Input";
+import { Separator } from "./separator";
+import { TooltipContent } from "./tooltip";
 type SidebarContextProps = {
     state: "expanded" | "collapsed";
     open: boolean;

package/dist/components/ui/tabs.d.ts

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

package/dist/components/ui/textarea-field.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+export interface TextareaFieldProps extends Omit<React.ComponentProps<"textarea">, "ref"> {
+    label?: React.ReactNode;
+    helperText?: React.ReactNode;
+    error?: React.ReactNode;
+    required?: boolean;
+    containerClassName?: string;
+    labelClassName?: string;
+    messageClassName?: string;
+    ref?: React.Ref<HTMLTextAreaElement>;
+}
+declare function TextareaField({ id, label, helperText, error, required, containerClassName, labelClassName, messageClassName, className, ref, ...props }: TextareaFieldProps): import("react/jsx-runtime").JSX.Element;
+export { TextareaField };

package/dist/components/ui/toggle-group.d.ts

@@ -1,7 +1,7 @@
 import { type VariantProps } from "class-variance-authority";
 import { ToggleGroup as ToggleGroupPrimitive } from "radix-ui";
 import * as React from "react";
-import { toggleVariants } from "@/components/ui/toggle";
+import { toggleVariants } from "./toggle";
 declare function ToggleGroup({ className, variant, size, children, ...props }: React.ComponentProps<typeof ToggleGroupPrimitive.Root> & VariantProps<typeof toggleVariants>): import("react/jsx-runtime").JSX.Element;
 declare function ToggleGroupItem({ className, children, variant, size, ...props }: React.ComponentProps<typeof ToggleGroupPrimitive.Item> & VariantProps<typeof toggleVariants>): import("react/jsx-runtime").JSX.Element;
 export { ToggleGroup, ToggleGroupItem };