@eintrek/erp-theme 1.0.4 → 1.4.4

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

@@ -0,0 +1,9 @@
+import type { Column } from "@tanstack/react-table";
+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, sortable, ...props }: DataTableColumnHeaderProps<TData, TValue>): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,124 @@
+export type DataTableConfig = typeof dataTableConfig;
+export declare const dataTableConfig: {
+    textOperators: ({
+        label: string;
+        value: "iLike";
+    } | {
+        label: string;
+        value: "notILike";
+    } | {
+        label: string;
+        value: "eq";
+    } | {
+        label: string;
+        value: "ne";
+    } | {
+        label: string;
+        value: "isEmpty";
+    } | {
+        label: string;
+        value: "isNotEmpty";
+    })[];
+    numericOperators: ({
+        label: string;
+        value: "eq";
+    } | {
+        label: string;
+        value: "ne";
+    } | {
+        label: string;
+        value: "lt";
+    } | {
+        label: string;
+        value: "lte";
+    } | {
+        label: string;
+        value: "gt";
+    } | {
+        label: string;
+        value: "gte";
+    } | {
+        label: string;
+        value: "isBetween";
+    } | {
+        label: string;
+        value: "isEmpty";
+    } | {
+        label: string;
+        value: "isNotEmpty";
+    })[];
+    dateOperators: ({
+        label: string;
+        value: "eq";
+    } | {
+        label: string;
+        value: "ne";
+    } | {
+        label: string;
+        value: "lt";
+    } | {
+        label: string;
+        value: "gt";
+    } | {
+        label: string;
+        value: "lte";
+    } | {
+        label: string;
+        value: "gte";
+    } | {
+        label: string;
+        value: "isBetween";
+    } | {
+        label: string;
+        value: "isRelativeToToday";
+    } | {
+        label: string;
+        value: "isEmpty";
+    } | {
+        label: string;
+        value: "isNotEmpty";
+    })[];
+    selectOperators: ({
+        label: string;
+        value: "eq";
+    } | {
+        label: string;
+        value: "ne";
+    } | {
+        label: string;
+        value: "isEmpty";
+    } | {
+        label: string;
+        value: "isNotEmpty";
+    })[];
+    multiSelectOperators: ({
+        label: string;
+        value: "inArray";
+    } | {
+        label: string;
+        value: "notInArray";
+    } | {
+        label: string;
+        value: "isEmpty";
+    } | {
+        label: string;
+        value: "isNotEmpty";
+    })[];
+    booleanOperators: ({
+        label: string;
+        value: "eq";
+    } | {
+        label: string;
+        value: "ne";
+    })[];
+    sortOrders: ({
+        label: string;
+        value: "asc";
+    } | {
+        label: string;
+        value: "desc";
+    })[];
+    filterVariants: readonly ["text", "number", "range", "date", "dateRange", "boolean", "select", "multiSelect"];
+    operators: readonly ["iLike", "notILike", "eq", "ne", "inArray", "notInArray", "isEmpty", "isNotEmpty", "lt", "lte", "gt", "gte", "isBetween", "isRelativeToToday"];
+    joinOperators: readonly ["and", "or"];
+};

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

@@ -0,0 +1,8 @@
+import type { Column } from "@tanstack/react-table";
+interface DataTableDateFilterProps<TData> {
+    column: Column<TData, unknown>;
+    title?: string;
+    multiple?: boolean;
+}
+export declare function DataTableDateFilter<TData>({ column, title, multiple, }: DataTableDateFilterProps<TData>): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,10 @@
+import type { Column } from "@tanstack/react-table";
+import type { Option } from "./data-table-types";
+interface DataTableFacetedFilterProps<TData, TValue> {
+    column?: Column<TData, TValue>;
+    title?: string;
+    options: Option[];
+    multiple?: boolean;
+}
+export declare function DataTableFacetedFilter<TData, TValue>({ column, title, options, multiple, }: DataTableFacetedFilterProps<TData, TValue>): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,11 @@
+import type { Table } from "@tanstack/react-table";
+import * as React from "react";
+import { PopoverContent } from "../../index";
+interface DataTableFilterListProps<TData> extends React.ComponentProps<typeof PopoverContent> {
+    table: Table<TData>;
+    debounceMs?: number;
+    throttleMs?: number;
+    shallow?: boolean;
+}
+export declare function DataTableFilterList<TData>({ table, debounceMs, throttleMs, shallow, ...props }: DataTableFilterListProps<TData>): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +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 | 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

@@ -0,0 +1,11 @@
+import type { Column } from "@tanstack/react-table";
+import * as React from "react";
+import type { ExtendedColumnFilter } from "./data-table-types";
+interface DataTableRangeFilterProps<TData> extends React.ComponentProps<"div"> {
+    filter: ExtendedColumnFilter<TData>;
+    column: Column<TData>;
+    inputId: string;
+    onFilterUpdate: (filterId: string, updates: Partial<Omit<ExtendedColumnFilter<TData>, "filterId">>) => void;
+}
+export declare function DataTableRangeFilter<TData>({ filter, column, inputId, onFilterUpdate, className, ...props }: DataTableRangeFilterProps<TData>): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,11 @@
+interface DataTableSkeletonProps extends React.ComponentProps<"div"> {
+    columnCount: number;
+    rowCount?: number;
+    filterCount?: number;
+    cellWidths?: string[];
+    withViewOptions?: boolean;
+    withPagination?: boolean;
+    shrinkZero?: boolean;
+}
+export declare function DataTableSkeleton({ columnCount, rowCount, filterCount, cellWidths, withViewOptions, withPagination, shrinkZero, className, ...props }: DataTableSkeletonProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,6 @@
+import type { Column } from "@tanstack/react-table";
+interface DataTableSliderFilterProps<TData> {
+    column: Column<TData, unknown>;
+}
+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

@@ -0,0 +1,8 @@
+import type { Table } from "@tanstack/react-table";
+import * as React from "react";
+import { PopoverContent } from "../../index";
+interface DataTableSortListProps<TData> extends React.ComponentProps<typeof PopoverContent> {
+    table: Table<TData>;
+}
+export declare function DataTableSortList<TData>({ table, ...props }: DataTableSortListProps<TData>): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,12 @@
+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, 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-view-options.d.ts

@@ -0,0 +1,6 @@
+import type { Table } from "@tanstack/react-table";
+interface DataTableViewOptionsProps<TData> {
+    table: Table<TData>;
+}
+export declare function DataTableViewOptions<TData>({ table, }: DataTableViewOptionsProps<TData>): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,11 @@
+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, 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/components/data-table/hooks/use-data-table.d.ts

@@ -0,0 +1,24 @@
+import { type TableOptions, type TableState } from "@tanstack/react-table";
+import * as React from "react";
+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;
+    clearOnDefault?: boolean;
+    enableAdvancedFilter?: boolean;
+    scroll?: boolean;
+    shallow?: boolean;
+    startTransition?: React.TransitionStartFunction;
+    resetOnMount?: boolean;
+}
+export declare function useDataTable<TData>(props: UseDataTableProps<TData>): {
+    table: import("@tanstack/react-table").Table<TData>;
+    shallow: boolean;
+    debounceMs: number;
+    throttleMs: number;
+};

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