@goplusvn/core 0.1.0

package/dist/crud/index.d.mts

@@ -0,0 +1,646 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { EntityConfig, CrudPermissions, CrudResponse, ActiveFilter, SortingState, CrudQueryParams, ExportOptions, FieldConfig, FilterOperator, DataSource, ImportOptions, ImportResult } from '../types/index.mjs';
+import * as React$1 from 'react';
+import { ReactNode } from 'react';
+import { useForm } from 'react-hook-form';
+import { a as DictionaryType } from '../index-B9zQVEVi.mjs';
+import { Table } from '@tanstack/react-table';
+import { z } from 'zod';
+export { getCrudPermissions, mergePermissions } from './server.mjs';
+export { a as CrudTableSkeleton, b as CrudTableSkeletonProps } from '../data-table-skeleton-12NA8Mjx.mjs';
+import 'lucide-react';
+import '../tenant-provider-B8eC_Wpb.mjs';
+import 'next-auth';
+
+interface CrudBulkActionsProps {
+    config: EntityConfig;
+    permissions: CrudPermissions;
+    onDelete?: (rowIds: string[]) => void;
+    onExport?: (rowIds: string[]) => void;
+}
+declare function CrudBulkActions({ config, permissions, onDelete, onExport, }: CrudBulkActionsProps): react_jsx_runtime.JSX.Element | null;
+
+interface CrudCardViewProps<TData = Record<string, unknown>> {
+    config: EntityConfig;
+    data: CrudResponse<TData>;
+    permissions: CrudPermissions;
+    loading?: boolean;
+    onEdit?: (rowId: string, rowData?: Record<string, unknown>) => void;
+    onDelete?: (rowId: string) => void;
+    onCustomAction?: (action: string, rowId: string, rowData: Record<string, unknown>) => void | Promise<void>;
+    onEmptyStateAction?: {
+        onCreate?: () => void;
+        onClearSearch?: () => void;
+        onClearFilters?: () => void;
+    };
+}
+declare function CrudCardView<TData extends Record<string, unknown>>({ config: propConfig, // Rename to avoid conflict if we use context, but here we might just use props as it was designed
+data, permissions: propPermissions, loading, onEdit, onDelete, onCustomAction, onEmptyStateAction, }: CrudCardViewProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface CrudTranslations {
+    edit?: string;
+    delete?: string;
+    save?: string;
+    cancel?: string;
+    create?: string;
+    update?: string;
+    creating?: string;
+    updating?: string;
+    deleting?: string;
+    savedSuccessfully?: string;
+    createdSuccessfully?: string;
+    updatedSuccessfully?: string;
+    confirmDeleteTitle?: string;
+    confirmBulkDeleteTitle?: string;
+    confirmDeleteDescription?: string;
+    confirmBulkDeleteDescription?: string;
+    deleteSelected?: string;
+    actions?: string;
+    add?: string;
+    addNew?: string;
+}
+interface CrudConfigContextValue {
+    config: EntityConfig | null;
+    setConfig: (config: EntityConfig) => void;
+    permissions: CrudPermissions;
+    setPermissions: (permissions: CrudPermissions) => void;
+    translations: CrudTranslations;
+    setTranslations: (translations: CrudTranslations) => void;
+}
+declare const CrudConfigContext: React$1.Context<CrudConfigContextValue | undefined>;
+declare function useCrudConfig(): CrudConfigContextValue;
+interface CrudStateContextValue {
+    search: string;
+    setSearch: (search: string) => void;
+    filters: ActiveFilter[];
+    setFilters: (filters: ActiveFilter[]) => void;
+    addFilter: (filter: ActiveFilter) => void;
+    removeFilter: (filterName: string) => void;
+    updateFilter: (filterName: string, value: unknown) => void;
+    clearFilters: () => void;
+    pagination: {
+        page: number;
+        pageSize: number;
+    };
+    setPagination: (pagination: {
+        page: number;
+        pageSize: number;
+    }) => void;
+    setPage: (page: number) => void;
+    setPageSize: (pageSize: number) => void;
+    sorting: SortingState | null;
+    setSorting: (sorting: SortingState | null) => void;
+    getQueryParams: () => CrudQueryParams;
+}
+declare const CrudStateContext: React$1.Context<CrudStateContextValue | undefined>;
+declare function useCrudState(): CrudStateContextValue;
+interface CrudSelectionContextValue {
+    selectedRows: Set<string>;
+    setSelectedRows: (selectedRows: Set<string>) => void;
+    toggleRowSelection: (rowId: string) => void;
+    selectAllRows: (rowIds: string[]) => void;
+    clearSelection: () => void;
+}
+declare const CrudSelectionContext: React$1.Context<CrudSelectionContextValue | undefined>;
+declare function useCrudSelection(): CrudSelectionContextValue;
+
+interface CrudDeleteDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    config: EntityConfig;
+    itemData?: Record<string, unknown>;
+    itemCount?: number;
+    onConfirm: () => void;
+    loading?: boolean;
+    translations?: {
+        confirmDeleteTitle?: string;
+        confirmBulkDeleteTitle?: string;
+        confirmDeleteDescription?: string;
+        confirmBulkDeleteDescription?: string;
+        cancel?: string;
+        delete?: string;
+        deleting?: string;
+    };
+}
+declare function CrudDeleteDialog({ open, onOpenChange, config, itemData, itemCount, onConfirm, loading, translations, }: CrudDeleteDialogProps): react_jsx_runtime.JSX.Element;
+
+interface CrudDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    config: EntityConfig;
+    initialData?: Record<string, unknown>;
+    mode?: "create" | "edit";
+    onSubmit: (data: Record<string, unknown>) => Promise<void> | void;
+}
+declare function CrudDialog({ open, onOpenChange, config, initialData, mode, onSubmit, }: CrudDialogProps): react_jsx_runtime.JSX.Element;
+
+interface CrudEmptyStateProps {
+    config: EntityConfig;
+    hasSearch?: boolean;
+    hasFilters?: boolean;
+    onClearSearch?: () => void;
+    onClearFilters?: () => void;
+    onCreate?: () => void;
+    canCreate?: boolean;
+}
+declare function CrudEmptyState({ config, hasSearch, hasFilters, onClearSearch, onClearFilters, onCreate, canCreate, }: CrudEmptyStateProps): react_jsx_runtime.JSX.Element;
+
+interface CrudExportButtonProps {
+    endpoint: string;
+    filters?: ActiveFilter[];
+    search?: string;
+    canExport?: boolean;
+    format?: ExportOptions["format"];
+}
+declare function CrudExportButton({ endpoint, filters, search, canExport, }: CrudExportButtonProps): react_jsx_runtime.JSX.Element | null;
+
+interface CrudFieldRendererProps {
+    field: FieldConfig;
+    mode?: "create" | "edit";
+}
+declare function CrudFieldRenderer({ field, mode, }: CrudFieldRendererProps): react_jsx_runtime.JSX.Element;
+
+interface CrudFilterChipsProps {
+    config: EntityConfig;
+}
+declare function CrudFilterChips({ config }: CrudFilterChipsProps): react_jsx_runtime.JSX.Element | null;
+
+interface CrudFormProps {
+    config: EntityConfig;
+    initialData?: Record<string, unknown>;
+    onSubmit: (data: Record<string, unknown>) => Promise<void> | void;
+    onCancel?: () => void;
+    submitLabel?: string;
+    cancelLabel?: string;
+    submittingLabel?: string;
+    isSubmitting?: boolean;
+    mode?: "create" | "edit";
+    enableAutoSave?: boolean;
+    onFormReady?: (form: ReturnType<typeof useForm>) => void;
+}
+declare const CrudForm: React$1.ForwardRefExoticComponent<CrudFormProps & React$1.RefAttributes<HTMLFormElement>>;
+
+interface CrudImportDialogProps {
+    config: EntityConfig;
+    endpoint: string;
+    canImport?: boolean;
+    onSuccess?: () => void;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+declare function CrudImportDialog({ config, endpoint, canImport, onSuccess, open: controlledOpen, onOpenChange: controlledOnOpenChange, }: CrudImportDialogProps): react_jsx_runtime.JSX.Element | null;
+
+interface CrudInfiniteScrollProps {
+    endpoint: string;
+    queryParams: CrudQueryParams;
+    onLoadMore: (data: unknown[]) => void;
+    mode?: "auto" | "button";
+}
+declare function CrudInfiniteScroll({ endpoint, queryParams, onLoadMore, mode, }: CrudInfiniteScrollProps): react_jsx_runtime.JSX.Element | null;
+
+interface CrudPageProps {
+    config: EntityConfig;
+    permissions: CrudPermissions;
+    entityName?: string;
+    dictionary: DictionaryType;
+    customActions?: React.ReactNode;
+}
+declare function CrudPage({ config, permissions, entityName, dictionary, customActions, }: CrudPageProps): react_jsx_runtime.JSX.Element;
+
+interface CrudContextValue extends CrudConfigContextValue, CrudStateContextValue, CrudSelectionContextValue {
+}
+interface CrudProviderProps {
+    children: ReactNode;
+    initialConfig?: EntityConfig;
+    initialPermissions?: CrudPermissions;
+    initialTranslations?: CrudTranslations;
+}
+declare function CrudProvider({ children, initialConfig, initialPermissions, initialTranslations, }: CrudProviderProps): react_jsx_runtime.JSX.Element;
+declare function useCrudContext(): CrudContextValue;
+
+interface CrudRowActionsProps {
+    rowId: string;
+    rowData: Record<string, unknown>;
+    config: EntityConfig;
+    permissions: CrudPermissions;
+    onEdit?: (rowId: string, rowData?: Record<string, unknown>) => void;
+    onDelete?: (rowId: string) => void;
+    onCustomAction?: (action: string, rowId: string, rowData: Record<string, unknown>) => void | Promise<void>;
+    translations?: {
+        edit?: string;
+        delete?: string;
+        actions?: string;
+    };
+}
+declare function CrudRowActions({ rowId, rowData, config, permissions, onEdit, onDelete, onCustomAction, translations, }: CrudRowActionsProps): react_jsx_runtime.JSX.Element | null;
+
+interface CrudSearchProps {
+    placeholder?: string;
+    debounceMs?: number;
+}
+declare function CrudSearch({ placeholder, debounceMs, }: CrudSearchProps): react_jsx_runtime.JSX.Element;
+
+interface CrudSheetProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    config: EntityConfig;
+    initialData?: Record<string, unknown>;
+    mode?: "create" | "edit";
+    onSubmit: (data: Record<string, unknown>) => Promise<void> | void;
+    side?: "top" | "right" | "bottom" | "left";
+}
+declare function CrudSheet({ open, onOpenChange, config, initialData, mode, onSubmit, side, }: CrudSheetProps): react_jsx_runtime.JSX.Element;
+
+interface LegacyCrudTableSkeletonProps {
+    columns: number;
+    rows?: number;
+}
+/**
+ * @deprecated Use DataTableSkeleton from @goerp/core/ui instead
+ * This is kept for backward compatibility
+ */
+declare function CrudTableSkeletonLegacy({ columns, rows, }: LegacyCrudTableSkeletonProps): react_jsx_runtime.JSX.Element;
+
+interface CrudTableToolbarProps<TData> {
+    table?: Table<TData>;
+    config: EntityConfig;
+    permissions: CrudPermissions;
+    viewMode?: "table" | "card";
+    onViewModeChange?: (mode: "table" | "card") => void;
+}
+declare function CrudTableToolbar<TData>({ table, config, permissions, viewMode, onViewModeChange, }: CrudTableToolbarProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface CrudTableProps<TData = Record<string, unknown>> {
+    data: CrudResponse<TData>;
+    loading?: boolean;
+    onEdit?: (rowId: string, rowData?: Record<string, unknown>) => void;
+    onDelete?: (rowId: string) => void;
+    onCustomAction?: (action: string, rowId: string, rowData: Record<string, unknown>) => void | Promise<void>;
+    onTableReady?: (table: Table<TData>) => void;
+    onEmptyStateAction?: {
+        onCreate?: () => void;
+        onClearSearch?: () => void;
+        onClearFilters?: () => void;
+    };
+    getTranslation?: (key: string) => string;
+}
+declare function CrudTable<TData extends Record<string, unknown>>({ data, loading, onEdit, onDelete, onCustomAction, onTableReady, onEmptyStateAction, getTranslation, }: CrudTableProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface CrudVirtualTableProps<TData = Record<string, unknown>> {
+    config: EntityConfig;
+    data: CrudResponse<TData>;
+    permissions: CrudPermissions;
+    loading?: boolean;
+    onEdit?: (rowId: string) => void;
+    onDelete?: (rowId: string) => void;
+}
+/**
+ * Virtual table component for large datasets
+ *
+ * TODO: Implement with @tanstack/react-virtual when needed
+ * Example implementation:
+ *
+ * import { useVirtualizer } from '@tanstack/react-virtual'
+ *
+ * const parentRef = useRef<HTMLDivElement>(null)
+ * const virtualizer = useVirtualizer({
+ *   count: data.data.length,
+ *   getScrollElement: () => parentRef.current,
+ *   estimateSize: () => 50,
+ *   overscan: 5,
+ * })
+ */
+declare function CrudVirtualTable<TData extends Record<string, unknown>>({ config, data, permissions, loading, onEdit, onDelete, }: CrudVirtualTableProps<TData>): react_jsx_runtime.JSX.Element;
+
+interface EntityCrudPageProps {
+    entity: string;
+    lang: string;
+    config: EntityConfig;
+    session: any;
+    dictionary: any;
+}
+declare function EntityCrudPage({ entity, lang, config, session, dictionary, }: EntityCrudPageProps): Promise<react_jsx_runtime.JSX.Element>;
+
+declare class CrudService {
+    /**
+     * Fetch list of records
+     */
+    fetch<T = Record<string, unknown>>(endpoint: string, params: CrudQueryParams, signal?: AbortSignal): Promise<CrudResponse<T>>;
+    /**
+     * Create a new record
+     */
+    create(endpoint: string, data: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /**
+     * Update an existing record
+     */
+    update(endpoint: string, id: string, data: Record<string, unknown>): Promise<Record<string, unknown>>;
+    /**
+     * Delete a record
+     */
+    delete(endpoint: string, id: string): Promise<void>;
+    /**
+     * Delete multiple records
+     */
+    deleteMany(endpoint: string, ids: string[]): Promise<void>;
+}
+declare const crudService: CrudService;
+
+/**
+ * Build query string from CrudQueryParams
+ */
+declare function buildQueryString(params: CrudQueryParams): string;
+/**
+ * Parse query string to CrudQueryParams
+ */
+declare function parseQueryString(searchParams: URLSearchParams): CrudQueryParams;
+/**
+ * Apply filter operator to value
+ */
+declare function applyFilterOperator(value: unknown, operator: FilterOperator, filterValue: unknown): boolean;
+/**
+ * Get default value for a field
+ */
+declare function getFieldDefaultValue(field: FieldConfig): unknown;
+/**
+ * Get default values for all fields in config
+ */
+declare function getDefaultValues(config: EntityConfig): Record<string, unknown>;
+/**
+ * Check if a field is visible in table
+ */
+declare function isFieldVisibleInTable(field: FieldConfig): boolean;
+/**
+ * Check if a field is visible in form
+ */
+declare function isFieldVisibleInForm(field: FieldConfig): boolean;
+/**
+ * Filter out display-only (DTO) fields from form data before submitting to API
+ * Display-only fields are computed/transformed fields, not actual entity fields
+ */
+declare function filterDisplayOnlyFields(data: Record<string, unknown>, config: EntityConfig): Record<string, unknown>;
+/**
+ * Sort fields by order property
+ * Fields without order will be placed after fields with order
+ * If multiple fields have the same order, maintain original array order
+ */
+declare function sortFieldsByOrder(fields: FieldConfig[]): FieldConfig[];
+/**
+ * Validate field value
+ */
+declare function validateFieldValue(value: unknown, field: FieldConfig): {
+    valid: boolean;
+    error?: string;
+};
+/**
+ * Type guard: Check if value is a valid CrudResponse
+ */
+declare function isCrudResponse<T = unknown>(value: unknown): value is CrudResponse<T>;
+
+/**
+ * Build Zod schema from FieldConfig
+ */
+declare function buildSchemaFromConfig(fields: FieldConfig[]): z.ZodObject<Record<string, z.ZodTypeAny>>;
+/**
+ * Validate form data against EntityConfig
+ */
+declare function validateFormData(data: Record<string, unknown>, config: EntityConfig): {
+    valid: boolean;
+    errors: Record<string, string>;
+};
+/**
+ * Get default values object from config
+ */
+declare function getDefaultValuesFromConfig(config: EntityConfig): Record<string, unknown>;
+/**
+ * Transform form data to match API format
+ */
+declare function transformFormData(data: Record<string, unknown>, config: EntityConfig): Record<string, unknown>;
+
+declare class DataLoader {
+    private cache;
+    private cacheEnabled;
+    private defaultCacheTime;
+    private pendingRequests;
+    /**
+     * Load options from dataSource (static or API)
+     */
+    loadOptions(dataSource: DataSource): Promise<Array<{
+        label: string;
+        value: string | number | boolean;
+    }>>;
+    /**
+     * Load options from API with caching
+     */
+    private loadFromAPI;
+    /**
+     * Actually fetch data from API
+     */
+    private fetchFromAPI;
+    /**
+     * Generate cache key from dataSource
+     */
+    private getCacheKey;
+    /**
+     * Clear cache for a specific endpoint or all cache
+     */
+    clearCache(endpoint?: string): void;
+    /**
+     * Get cache size
+     */
+    getCacheSize(): number;
+}
+declare const dataLoader: DataLoader;
+
+/**
+ * Field Calculator - Handles field calculations based on dependencies
+ */
+
+/**
+ * Evaluate a formula string or function
+ * SECURITY: No longer uses eval() - uses safe evaluator instead
+ */
+declare function evaluateFormula(formula: string | ((values: Record<string, unknown>) => unknown), values: Record<string, unknown>): unknown;
+/**
+ * Calculate field value based on dependencies
+ */
+declare function calculateFieldValue(field: FieldConfig, formValues: Record<string, unknown>): unknown;
+/**
+ * Get all fields that depend on a given field
+ */
+declare function getDependentFields(fieldName: string, allFields: FieldConfig[]): FieldConfig[];
+
+/**
+ * Field Formatter - Handles field value formatting for display
+ */
+
+/**
+ * Format a value based on field configuration
+ */
+declare function formatFieldValue(value: unknown, field: FieldConfig): string;
+
+/**
+ * Parse CSV file
+ */
+declare function parseCSV(file: File): Promise<Record<string, unknown>[]>;
+/**
+ * Parse JSON file
+ */
+declare function parseJSON(file: File): Promise<Record<string, unknown>[]>;
+/**
+ * Parse XLSX file (requires xlsx library)
+ */
+declare function parseXLSX(file: File): Promise<Record<string, unknown>[]>;
+/**
+ * Parse file based on format
+ */
+declare function parseFile(file: File, format: ImportOptions["format"]): Promise<Record<string, unknown>[]>;
+/**
+ * Validate import data against field configs
+ */
+declare function validateImportData(data: Record<string, unknown>[], config: EntityConfig, options?: Partial<ImportOptions>): ImportResult;
+/**
+ * Generate CSV template from config
+ */
+declare function generateCSVTemplate(config: EntityConfig): string;
+/**
+ * Generate JSON template from config
+ */
+declare function generateJSONTemplate(config: EntityConfig): Record<string, unknown>;
+/**
+ * Generate XLSX template (requires xlsx library)
+ */
+declare function generateXLSXTemplate(config: EntityConfig): Promise<Blob>;
+/**
+ * Export data to CSV
+ */
+declare function exportToCSV(data: Record<string, unknown>[], fields?: string[]): string;
+/**
+ * Export data to JSON
+ */
+declare function exportToJSON(data: Record<string, unknown>[], fields?: string[]): string;
+/**
+ * Export data to XLSX (requires xlsx library)
+ */
+declare function exportToXLSX(data: Record<string, unknown>[], fields?: string[]): Promise<Blob>;
+/**
+ * Download file
+ */
+declare function downloadFile(blob: Blob, filename: string): void;
+
+declare function getRowValue(row: Record<string, unknown>, field: Pick<FieldConfig, "name" | "label">): unknown;
+declare function normalizeRowForConfig(row: Record<string, unknown>, config: EntityConfig): Record<string, unknown>;
+declare function coerceRowForConfig(row: Record<string, unknown>, config: EntityConfig): Record<string, unknown>;
+declare function emptyImportResult(): ImportResult;
+
+declare class LazyLoader {
+    private state;
+    private lastAccessTime;
+    private readonly MAX_STATES;
+    private readonly MAX_AGE;
+    private cleanupInterval;
+    constructor();
+    /**
+     * Start periodic cleanup of old states
+     */
+    private startCleanupInterval;
+    /**
+     * Stop cleanup interval
+     */
+    private stopCleanupInterval;
+    /**
+     * Cleanup old and unused states
+     */
+    private cleanupOldStates;
+    /**
+     * Get or initialize state for an endpoint
+     */
+    private getState;
+    /**
+     * Load initial data
+     */
+    loadInitial(endpoint: string, queryParams: CrudQueryParams): Promise<CrudResponse>;
+    /**
+     * Load more data (next page)
+     */
+    loadMore(endpoint: string, queryParams: CrudQueryParams): Promise<CrudResponse>;
+    /**
+     * Reset state for an endpoint
+     */
+    reset(endpoint: string): void;
+    /**
+     * Cleanup all states (useful for testing or memory management)
+     */
+    cleanupAll(): void;
+    /**
+     * Get current cache size
+     */
+    getCacheSize(): number;
+    /**
+     * Check if has more data to load
+     */
+    hasMore(endpoint: string): boolean;
+    /**
+     * Get current data
+     */
+    getData(endpoint: string): unknown[];
+    /**
+     * Get loading state
+     */
+    isLoading(endpoint: string): boolean;
+}
+declare const lazyLoader: LazyLoader;
+
+/**
+ * Parse filters from CRUD query params
+ * Extracts filter values from filters array format
+ */
+/**
+ * Parse filters from query params and extract specific filter values
+ * @param filtersParam - JSON string of filters array
+ * @param filterName - Name of the filter to extract
+ * @returns Filter value or undefined
+ */
+declare function parseFilterValue(filtersParam: string | null, filterName: string): string | undefined;
+/**
+ * Parse multiple filter values from query params
+ * @param filtersParam - JSON string of filters array
+ * @param filterNames - Array of filter names to extract
+ * @returns Object with filter values
+ */
+declare function parseFilterValues<T extends string>(filtersParam: string | null, filterNames: T[]): Partial<Record<T, string>>;
+
+interface StreamChunk {
+    type: "data" | "error" | "done";
+    data?: unknown[];
+    error?: string;
+    total?: number;
+}
+/**
+ * Stream data from API using fetch streaming
+ */
+declare function streamData(endpoint: string, queryParams: CrudQueryParams): AsyncGenerator<StreamChunk, void, unknown>;
+/**
+ * Load data progressively from stream
+ */
+declare function loadStreamData(endpoint: string, queryParams: CrudQueryParams, onChunk: (chunk: unknown[]) => void): Promise<CrudResponse>;
+
+/**
+ * CRUD Translation Utilities
+ * Translate EntityConfig ở server-side trước khi pass xuống client
+ */
+
+/**
+ * Translate EntityConfig với dictionary
+ * Chạy ở server-side trước khi pass xuống client
+ */
+declare function translateEntityConfig(config: EntityConfig, dictionary: DictionaryType, locale: string, entityName?: string): EntityConfig;
+/**
+ * Get common CRUD translations
+ */
+declare function getCrudCommonTranslations(dictionary: DictionaryType): Record<string, string>;
+/**
+ * Translate CRUD message với parameters
+ */
+declare function translateCrudMessage(dictionary: DictionaryType, key: string, params?: Record<string, string | number>): string;
+
+export { CrudBulkActions, CrudCardView, CrudConfigContext, type CrudConfigContextValue, CrudDeleteDialog, CrudDialog, CrudEmptyState, CrudExportButton, CrudFieldRenderer, CrudFilterChips, CrudForm, CrudImportDialog, CrudInfiniteScroll, CrudPage, CrudProvider, CrudRowActions, CrudSearch, CrudSelectionContext, type CrudSelectionContextValue, CrudSheet, CrudStateContext, type CrudStateContextValue, CrudTable, CrudTableSkeletonLegacy, CrudTableToolbar, type CrudTranslations, CrudVirtualTable, DataLoader, EntityCrudPage, LazyLoader, type LegacyCrudTableSkeletonProps, applyFilterOperator, buildQueryString, buildSchemaFromConfig, calculateFieldValue, coerceRowForConfig, crudService, dataLoader, downloadFile, emptyImportResult, evaluateFormula, exportToCSV, exportToJSON, exportToXLSX, filterDisplayOnlyFields, formatFieldValue, generateCSVTemplate, generateJSONTemplate, generateXLSXTemplate, getCrudCommonTranslations, getDefaultValues, getDefaultValuesFromConfig, getDependentFields, getFieldDefaultValue, getRowValue, isCrudResponse, isFieldVisibleInForm, isFieldVisibleInTable, lazyLoader, loadStreamData, normalizeRowForConfig, parseCSV, parseFile, parseFilterValue, parseFilterValues, parseJSON, parseQueryString, parseXLSX, sortFieldsByOrder, streamData, transformFormData, translateCrudMessage, translateEntityConfig, useCrudConfig, useCrudContext, useCrudSelection, useCrudState, validateFieldValue, validateFormData, validateImportData };