@rchemist/listgrid 0.2.6

package/dist/listgrid/misc/index.js

@@ -0,0 +1,478 @@
+// Stage 3c — miscellaneous utilities that the original kit's root barrel
+// provided. Ported to match the original semantics exactly so library-internal
+// callers (DatetimeField, FormField, PasswordValidation, etc.) behave the same
+// as before extraction.
+//
+// Sources (in utils/):
+//   validation.ts, formatTime.ts, NumberUtil.ts, CompareUtil.ts, Server.ts,
+//   StringUtil.ts, RequestUtil.ts, jsonUtils.ts, BooleanUtil.ts,
+//   LocalStorageUtils.ts, SessionStorageUtil.ts
+import { format, formatDistanceToNow, getTime } from 'date-fns';
+import { ko } from 'date-fns/locale';
+// -- Regex patterns --------------------------------------------------------
+// From validation.ts. These are the exact originals — changing them breaks
+// validators (PasswordValidation, PhoneNumberValidation, etc.).
+export const RegexPhoneNumber = /^[0-9]{10,11}$/;
+export const RegexTelephoneNumber = /^[0-9]{9,11}$/;
+export const RegexPasswordNormal = /^(?=.*[A-Za-z])(?=.*\d)(?=.*[@$!%*#?&+~()=_-])[A-Za-z\d@$!%*#?&+~()=_-]{8,25}$/;
+export const RegexEmailAddress = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4}$/;
+export const RegexKoreanName = /^[가-힣]{2,5}$/;
+export const RegexLoginName = /^[a-z][a-z0-9]{4,23}$/;
+export const RegexLoginNameForSignIn = /^[a-zA-Z][a-zA-Z0-9._-]{1,23}$/;
+export const RegexStudentLoginName = /^\d{10}$/;
+export const RegexAlias = /^[a-z0-9-_]{3,24}$/;
+export const RegexUrlBody = /^[a-zA-Z0-9-\/가-힣]{2,100}$/;
+export const RegexDomain = /^(https?:\/\/)[^\s\/$.?#].[^\s]*[^\/?]$/;
+export const RegexLowerEnglish = /^[a-z]{1,100}$/;
+export const RegexLowerEnglishNumber = /^[a-z0-9]{1,100}$/;
+export const RegexEnglishNumber = /^[a-zA-Z0-9]{1,100}$/;
+export const RegexNumber = /^[0-9]{1,100}$/;
+// -- Boolean helper (subset of BooleanUtil used by CompareUtil) ------------
+function isTrue(value, defaultValue) {
+    if (value === undefined || value === null || value === '') {
+        return defaultValue ?? false;
+    }
+    if (typeof value === 'boolean')
+        return value;
+    return value === 'true' || value === '1' || value === 'on' || value === 'yes' || value === '예';
+}
+// -- String helpers (subset of StringUtil used by library-internal callers) -
+function isBlank(data) {
+    return data === undefined || data === null || data === '';
+}
+// -- Date formatters (from formatTime.ts) ----------------------------------
+export function fDate(date, dateFormat) {
+    const fm = dateFormat ?? 'yyyy-MM-dd';
+    try {
+        return date ? format(new Date(date), fm) : '';
+    }
+    catch {
+        return '';
+    }
+}
+export function fDateTime(date, newFormat) {
+    const fm = newFormat ?? 'yyyy-MM-dd p';
+    try {
+        return date ? format(new Date(date), fm) : '';
+    }
+    catch {
+        return '';
+    }
+}
+export function fTimestamp(date) {
+    try {
+        return date ? getTime(new Date(date)) : '';
+    }
+    catch {
+        return '';
+    }
+}
+export function fToNow(date, options) {
+    try {
+        if (!date)
+            return '';
+        const d = typeof date === 'string' ? new Date(date) : date;
+        const opts = options ?? {};
+        if (!opts.relative) {
+            return fDate(d, opts.format);
+        }
+        const now = new Date();
+        const diff = now.getTime() - d.getTime();
+        const days = Math.ceil(diff / (1000 * 3600 * 24));
+        if (days > (opts.diffDays ?? 1)) {
+            return fDate(d, opts.format);
+        }
+        return formatDistanceToNow(d, { addSuffix: true, locale: ko });
+    }
+    catch {
+        return '';
+    }
+}
+export function formatYearMonth(date) {
+    if (!date)
+        return '';
+    if (typeof date === 'number')
+        return formatYearMonth(date.toString());
+    if (date.length < 6)
+        return date;
+    if (date.includes('-'))
+        return date.split('-')[0] + '년 ' + date.split('-')[1] + '월';
+    if (date.includes('.'))
+        return date.split('.')[0] + '년 ' + date.split('.')[1] + '월';
+    const year = date.substring(0, 4);
+    const month = date.substring(4, 6);
+    return `${year}년 ${month}월`;
+}
+function paddingMonth(mon) {
+    return mon < 10 ? `0${mon}` : mon;
+}
+export function getCurrentYear() {
+    return new Date().getFullYear();
+}
+export function getCurrentMonth() {
+    return new Date().getMonth() + 1 + '';
+}
+export function getCurrentYearMonth() {
+    const d = new Date();
+    return `${d.getFullYear()}-${paddingMonth(d.getMonth() + 1)}`;
+}
+export function getCurrentHour() {
+    const h = new Date().getHours();
+    return h < 10 ? `0${h}` : `${h}`;
+}
+// Mutates the input date — matches original signature/behavior.
+export function getFormattedTime(date = new Date(), hourOffset = 0, minuteOffset = 0) {
+    date.setHours(date.getHours() + hourOffset);
+    date.setMinutes(date.getMinutes() + minuteOffset);
+    const hours = date.getHours();
+    const minutes = date.getMinutes();
+    const hh = hours < 10 ? `0${hours}` : `${hours}`;
+    const mm = minutes < 10 ? `0${minutes}` : `${minutes}`;
+    return `${hh}:${mm}`;
+}
+// -- NumberUtil.formatPrice ------------------------------------------------
+export function formatPrice(value, localeCode) {
+    if (localeCode) {
+        try {
+            return new Intl.NumberFormat(localeCode, { style: 'currency', currency: 'KRW' }).format(value);
+        }
+        catch {
+            /* fall through */
+        }
+    }
+    const formattedNumber = value.toLocaleString('en-US');
+    if (localeCode === '원')
+        return `${formattedNumber} 원`;
+    if (localeCode)
+        return `${localeCode}${formattedNumber}`;
+    return formattedNumber;
+}
+// -- CompareUtil -----------------------------------------------------------
+export function isNulls(value, other) {
+    if (value === undefined && other === undefined)
+        return true;
+    if (value === undefined) {
+        if (other === null)
+            return true;
+        if (other === '')
+            return true;
+    }
+    else if (other === undefined) {
+        if (value === null)
+            return true;
+        if (value === '')
+            return true;
+    }
+    return false;
+}
+export function isEquals(value, other) {
+    if (isNulls(value, other))
+        return true;
+    if (value === other)
+        return true;
+    // plain object deep comparison (matches original CompareUtil.isEquals)
+    if (typeof value === 'object' &&
+        typeof other === 'object' &&
+        value !== null &&
+        other !== null &&
+        !Array.isArray(value) &&
+        !Array.isArray(other)) {
+        const a = value;
+        const b = other;
+        const keysA = Object.keys(a);
+        const keysB = Object.keys(b);
+        if (keysA.length !== keysB.length)
+            return false;
+        return keysA.every((key) => keysB.includes(key) && isEquals(a[key], b[key]));
+    }
+    return false;
+}
+export function isEqualsIgnoreCase(value, other) {
+    if (isNulls(value, other))
+        return true;
+    if (value == null || other == null)
+        return false;
+    return value.toLowerCase() === other.toLowerCase();
+}
+export function isEqualCollection(value, other, ignoreOrder = false) {
+    if (value.length !== other.length)
+        return false;
+    if (isTrue(ignoreOrder)) {
+        return value.every((v) => other.includes(v));
+    }
+    return value.every((v, i) => isEquals(v, other[i]));
+}
+export function isEmpty(collection) {
+    if (collection === undefined || collection === null)
+        return true;
+    if (collection instanceof Map)
+        return collection.size === 0;
+    return collection.length === 0;
+}
+export function isPositive(value) {
+    if (value === undefined || value === null)
+        return false;
+    return value > 0;
+}
+export function isNegative(value) {
+    if (value === undefined || value === null)
+        return false;
+    return value < 0;
+}
+// -- URL helpers -----------------------------------------------------------
+// From RequestUtil.normalizeUrl — prefixes '/' for relative paths, preserves
+// absolute http(s) URLs. NOT the trailing-slash variant previously here.
+export function normalizeUrl(url) {
+    if (isBlank(url))
+        return url;
+    const trimmed = url.trim();
+    if (trimmed.startsWith('http://') || trimmed.startsWith('https://'))
+        return trimmed;
+    if (!trimmed.startsWith('/'))
+        return `/${trimmed}`;
+    return trimmed;
+}
+// From StringUtil.removeTrailingSeparator — separator is REQUIRED and the
+// logic strips the trailing segment up to (and including) the last separator.
+export function removeTrailingSeparator(input, separator) {
+    const parts = input.split(separator);
+    const lastPart = parts[parts.length - 1];
+    if (lastPart.trim() !== '') {
+        return input.slice(0, input.lastIndexOf(separator));
+    }
+    return input;
+}
+// -- JSON helpers (from jsonUtils.ts) --------------------------------------
+function reviver(_key, value) {
+    if (typeof value === 'object' && value !== null) {
+        const record = value;
+        if (record.dataType === 'Map' && record.value) {
+            return new Map(record.value);
+        }
+    }
+    return value;
+}
+function mapReplacer(_key, value) {
+    if (value instanceof Map)
+        return Object.fromEntries(value);
+    if (value instanceof Set)
+        return [...value];
+    return value;
+}
+export function stringify(obj, beautify) {
+    const seen = new WeakSet();
+    const circularSafeReplacer = (key, value) => {
+        const mapped = mapReplacer(key, value);
+        if (typeof mapped !== 'object' || mapped === null)
+            return mapped;
+        if (seen.has(mapped))
+            return '[Circular Reference]';
+        seen.add(mapped);
+        return mapped;
+    };
+    try {
+        return beautify
+            ? JSON.stringify(obj, circularSafeReplacer, 2)
+            : JSON.stringify(obj, circularSafeReplacer);
+    }
+    catch (e) {
+        console.error('stringify error:', e);
+        return '{}';
+    }
+}
+// Generic JSON parser with Map reviver support.
+// Default type parameter is `unknown` — callers should narrow explicitly via
+// `parse<T>(str)` or `parse(str) as T`. This is stricter than prior `any`
+// contract and nudges consumers toward explicit schema knowledge.
+export function parse(str) {
+    return JSON.parse(str, reviver);
+}
+// -- Storage helpers (from LocalStorageUtils.ts / SessionStorageUtil.ts) ---
+// Matches the original CachedStorageItem wrapper exactly so data written by
+// host code (or by older versions of the library) remains readable.
+class CachedStorageItem {
+    constructor(value, expiry) {
+        this.value = value;
+        this.expiry = expiry;
+    }
+    static create(props) {
+        return new CachedStorageItem(props.value, props.expiry);
+    }
+    isAvailable() {
+        if (this.expiry)
+            return Date.now() <= this.expiry;
+        return true;
+    }
+    getData() {
+        if (!this.isAvailable())
+            return undefined;
+        return this.value;
+    }
+}
+function safeWindow() {
+    return typeof window !== 'undefined';
+}
+export function removeLocalStorageItem(key) {
+    if (!safeWindow())
+        return;
+    localStorage.removeItem(key);
+}
+export function setLocalStorageItem(key, value, expirySeconds) {
+    if (!safeWindow())
+        return;
+    const item = new CachedStorageItem(value, expirySeconds ? Date.now() + expirySeconds * 1000 : undefined);
+    localStorage.setItem(key, stringify(item));
+}
+export function getLocalStorageItem(key) {
+    if (!safeWindow())
+        return undefined;
+    const itemJson = localStorage.getItem(key);
+    if (!itemJson)
+        return undefined;
+    try {
+        const item = CachedStorageItem.create({
+            ...parse(itemJson),
+        });
+        if (item.isAvailable())
+            return item.getData();
+        localStorage.removeItem(key);
+    }
+    catch (e) {
+        console.error(e);
+    }
+    return undefined;
+}
+export function getLocalStorageObject(key, customParse) {
+    const value = getLocalStorageItem(key);
+    if (isBlank(value))
+        return undefined;
+    if (customParse !== undefined)
+        return customParse(value);
+    return parse(value);
+}
+export function removeSessionStorageItem(key) {
+    if (!safeWindow())
+        return;
+    sessionStorage.removeItem(key);
+}
+export function setSessionStorageItem(key, value, expirySeconds) {
+    if (!safeWindow())
+        return;
+    const item = new CachedStorageItem(value, expirySeconds ? Date.now() + expirySeconds * 1000 : undefined);
+    sessionStorage.setItem(key, stringify(item));
+}
+export function getSessionStorageItem(key) {
+    if (!safeWindow())
+        return undefined;
+    const itemJson = sessionStorage.getItem(key);
+    if (!itemJson)
+        return undefined;
+    try {
+        const obj = parse(itemJson);
+        const item = new CachedStorageItem(obj.value, obj.expiry);
+        if (item.isAvailable())
+            return item.getData();
+        sessionStorage.removeItem(key);
+    }
+    catch {
+        sessionStorage.removeItem(key);
+    }
+    return undefined;
+}
+export function getSessionStorageObject(key, customParse) {
+    const value = getSessionStorageItem(key);
+    if (value === undefined)
+        return undefined;
+    if (customParse !== undefined)
+        return customParse(value);
+    return parse(value);
+}
+// -- Server / asset URL helpers (from Server.ts) ---------------------------
+// Originals are module-level constants pulled from env. Library-consumer
+// Next.js bundles substitute NEXT_PUBLIC_* at build time, so this reads the
+// same env var and matches the original shape (plain strings, not Proxies).
+export const ASSET_SERVER_URL = (typeof process !== 'undefined' && process.env?.NEXT_PUBLIC_ASSET_SERVER) ||
+    'http://127.0.0.1:8320';
+export const ASSET_PREFIX = '/static-resource/';
+// Host-configuration override — hosts that set the env var don't need this;
+// hosts that bootstrap at runtime (non-Next environments) can override here.
+let _assetServerUrlOverride;
+let _assetPrefixOverride;
+export function configureAssetServerUrl(url) {
+    _assetServerUrlOverride = url.replace(/\/+$/, '');
+}
+export function configureAssetPrefix(prefix) {
+    _assetPrefixOverride = prefix;
+}
+function effectiveAssetServerUrl() {
+    return _assetServerUrlOverride ?? ASSET_SERVER_URL;
+}
+function effectiveAssetPrefix() {
+    return _assetPrefixOverride ?? ASSET_PREFIX;
+}
+export function getAccessableAssetUrl(imgUrl) {
+    if (!imgUrl)
+        return '';
+    let u = removeAssetServerPrefix(imgUrl);
+    if (u.startsWith('http://') || u.startsWith('https://'))
+        return u;
+    if (u.startsWith('/'))
+        u = u.substring(1);
+    return effectiveAssetServerUrl() + effectiveAssetPrefix() + u;
+}
+export function removeAssetServerPrefix(url) {
+    if (!url)
+        return '';
+    let u = url;
+    const server = effectiveAssetServerUrl();
+    const prefix = effectiveAssetPrefix();
+    if (u.startsWith(server))
+        u = u.substring(server.length);
+    if (u.startsWith(prefix))
+        u = u.substring(prefix.length);
+    // URL-encode each path segment; keeps '/' untouched so callers can
+    // concatenate the result with a base URL as before.
+    return u.split('/').map(encodeURIComponent).join('/');
+}
+export function validatedAssetFileName(fileName) {
+    fileName = fileName.replace(/ /g, '_');
+    fileName = fileName.replace(/[ㄱ-ㅎㅏ-ㅣ가-힣]/g, '_');
+    return fileName;
+}
+export function getDefinedDates(type) {
+    const now = new Date();
+    const start = new Date();
+    const end = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 23, 59, 59, 999);
+    if (type === 'TODAY') {
+        start.setHours(0, 0, 0, 0);
+    }
+    else if (type === 'WEEK') {
+        start.setDate(now.getDate() - 7);
+        start.setHours(0, 0, 0, 0);
+    }
+    else if (type === 'MONTH') {
+        start.setMonth(now.getMonth() - 1);
+        start.setHours(0, 0, 0, 0);
+    }
+    else if (type === 'MONTH3') {
+        start.setMonth(now.getMonth() - 3);
+        start.setHours(0, 0, 0, 0);
+    }
+    else if (type === 'MONTH6') {
+        start.setMonth(now.getMonth() - 6);
+        start.setHours(0, 0, 0, 0);
+    }
+    else if (type === 'YEAR') {
+        start.setFullYear(now.getFullYear() - 1);
+        start.setHours(0, 0, 0, 0);
+    }
+    return [start, end];
+}
+// -- API re-exports (host-supplied ApiClient; see src/listgrid/api) --------
+export { callExternalHttpRequest, getExternalApiData, getExternalApiDataWithError } from '../api';
+// -- Other -----------------------------------------------------------------
+// intentional: legacy placeholders kept for API parity with the original kit surface
+// (consumers dereference fields on these dynamically — tightening breaks out-of-scope)
+export const RequestUtil = {};
+export const EntityError = undefined;
+export { ResponseData } from '../api';

package/dist/listgrid/router/RouterProvider.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from 'react';
+import type { RouterApi, RouterLinkProps, RouterServices } from './types';
+export interface RouterProviderProps {
+    value: RouterServices;
+    children: ReactNode;
+}
+export declare function RouterProvider({ value, children }: RouterProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useRouter(): RouterApi;
+export declare function usePathname(): string;
+export declare function useParams(): Record<string, string | string[] | undefined>;
+export declare function useSearchParams(): URLSearchParams;
+export declare function Link(props: RouterLinkProps): import("react/jsx-runtime").JSX.Element;

package/dist/listgrid/router/RouterProvider.js

@@ -0,0 +1,34 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from 'react';
+const RouterContext = createContext(null);
+export function RouterProvider({ value, children }) {
+    return _jsx(RouterContext.Provider, { value: value, children: children });
+}
+function mustRouter(caller) {
+    // eslint-disable-next-line react-hooks/rules-of-hooks -- assertion helper always invoked from within hooks/components below
+    const ctx = useContext(RouterContext);
+    if (!ctx) {
+        throw new Error(`[@rchemist/listgrid] ${caller} must be called within a <RouterProvider>. ` +
+            'Wrap your app with <RouterProvider value={...}> imported from @rchemist/listgrid. ' +
+            'See @rchemist/listgrid-next for a Next.js adapter.');
+    }
+    return ctx;
+}
+export function useRouter() {
+    return mustRouter('useRouter').useRouter();
+}
+export function usePathname() {
+    return mustRouter('usePathname').usePathname();
+}
+export function useParams() {
+    return mustRouter('useParams').useParams();
+}
+export function useSearchParams() {
+    return mustRouter('useSearchParams').useSearchParams();
+}
+export function Link(props) {
+    const services = mustRouter('Link');
+    const Impl = services.Link;
+    return _jsx(Impl, { ...props });
+}

package/dist/listgrid/router/index.d.ts

@@ -0,0 +1,3 @@
+export type { RouterApi, RouterLinkProps, RouterServices } from './types';
+export { RouterProvider, useRouter, usePathname, useParams, useSearchParams, Link, } from './RouterProvider';
+export type { RouterProviderProps } from './RouterProvider';

package/dist/listgrid/router/index.js

@@ -0,0 +1 @@
+export { RouterProvider, useRouter, usePathname, useParams, useSearchParams, Link, } from './RouterProvider';

package/dist/listgrid/router/types.d.ts

@@ -0,0 +1,34 @@
+import type { ComponentType, MouseEvent, ReactNode } from 'react';
+export interface RouterApi {
+    push(url: string): void;
+    replace(url: string): void;
+    refresh?(): void;
+    back?(): void;
+    forward?(): void;
+    prefetch?(url: string): void;
+}
+export interface RouterLinkProps {
+    href: string;
+    children?: ReactNode;
+    className?: string;
+    onClick?: (event: MouseEvent<HTMLAnchorElement>) => void;
+    target?: string;
+    [key: string]: any;
+}
+/**
+ * Router services consumed by listgrid. Host adapters supply this to
+ * <RouterProvider value={...}>. The useXxx properties are React hooks
+ * — they will be invoked during listgrid component renders.
+ */
+export interface RouterServices {
+    /** Hook returning the imperative router API. Called inside listgrid components. */
+    useRouter: () => RouterApi;
+    /** Hook returning the current pathname (e.g. "/admin/users"). */
+    usePathname: () => string;
+    /** Hook returning current route params (dynamic segments). */
+    useParams: () => Record<string, string | string[] | undefined>;
+    /** Hook returning current URL search params. */
+    useSearchParams: () => URLSearchParams;
+    /** Link component that navigates client-side without full reload. */
+    Link: ComponentType<RouterLinkProps>;
+}

package/dist/listgrid/router/types.js

@@ -0,0 +1,6 @@
+// Stage 7c — Framework-agnostic router contract.
+//
+// Host adapters (e.g. @rchemist/listgrid-next) implement these by delegating
+// to their framework's navigation APIs (next/navigation, react-router,
+// Remix, Tanstack Router, etc.).
+export {};

package/dist/listgrid/store/index.d.ts

@@ -0,0 +1,24 @@
+import type { ReactNode } from 'react';
+export interface ModalOptions {
+    modalId?: string;
+    title?: ReactNode;
+    size?: string;
+    fullHeight?: boolean;
+    maxHeight?: string;
+    content?: ReactNode;
+    onClose?: () => void;
+    [key: string]: unknown;
+}
+interface ModalManagerState {
+    openModals: ModalOptions[];
+    openModal: (options: ModalOptions) => string;
+    closeModal: (modalId?: string, ...rest: unknown[]) => void;
+    closeTopModal: () => Promise<void>;
+    findModal: (modalId: string) => ModalOptions | undefined;
+    updateModalData: (modalId: string, data: Partial<ModalOptions>) => void;
+}
+export declare const useModalManagerStore: import("zustand").UseBoundStore<import("zustand").StoreApi<ModalManagerState>>;
+export declare function configureOverlayZIndex(base: number): void;
+export declare function getOverlayZIndex(offset?: number): number;
+export declare const POPOVER_Z_INDEX = 50;
+export {};

package/dist/listgrid/store/index.js

@@ -0,0 +1,40 @@
+// Stage 3d — internal modal/overlay state using zustand (already a dep).
+//
+// Shape matches the original the legacy UI kit API surface used throughout
+// listgrid: modalId-based, plus helpers closeTopModal / findModal /
+// updateModalData. Typed permissively (`any` on content) so host apps
+// can keep their existing modal conventions.
+import { create } from 'zustand';
+export const useModalManagerStore = create((set, get) => ({
+    openModals: [],
+    openModal: (options) => {
+        const modalId = options.modalId ?? `modal-${Math.random().toString(36).slice(2, 10)}`;
+        const normalized = { ...options, modalId };
+        set((state) => ({
+            openModals: [...state.openModals.filter((m) => m.modalId !== modalId), normalized],
+        }));
+        return modalId;
+    },
+    closeModal: (modalId) => set((state) => ({
+        openModals: modalId ? state.openModals.filter((m) => m.modalId !== modalId) : [],
+    })),
+    closeTopModal: async () => {
+        set((state) => ({
+            openModals: state.openModals.slice(0, -1),
+        }));
+    },
+    findModal: (modalId) => get().openModals.find((m) => m.modalId === modalId),
+    updateModalData: (modalId, data) => set((state) => ({
+        openModals: state.openModals.map((m) => (m.modalId === modalId ? { ...m, ...data } : m)),
+    })),
+}));
+// Overlay z-index helpers. Host apps that layer the library deep inside a
+// portal can override via configureOverlayZIndex.
+let _baseOverlayZIndex = 1000;
+export function configureOverlayZIndex(base) {
+    _baseOverlayZIndex = base;
+}
+export function getOverlayZIndex(offset = 0) {
+    return _baseOverlayZIndex + offset;
+}
+export const POPOVER_Z_INDEX = 50;

package/dist/listgrid/transfer/DataExportProcessor.d.ts

@@ -0,0 +1,18 @@
+import { DataField, DataRow, DataRowSet, SampleDataItem } from '../transfer/Type';
+import { SearchForm } from '../form/SearchForm';
+interface ExportProcessorProps {
+    process: boolean;
+    fields: DataField[];
+    url?: string | undefined;
+    onProcessed: () => void;
+    maxCount?: number | undefined;
+    countPerPage?: number | undefined;
+    searchForm?: SearchForm | undefined;
+    exportFileName?: string | undefined;
+    data?: SampleDataItem[][] | undefined;
+    password?: string | undefined;
+    addedFields?: ((row: DataRow) => Promise<DataRow>) | undefined;
+    overrideFormData?: ((formData: DataRowSet) => Promise<DataRowSet>) | undefined;
+}
+export declare const DataExportProcessor: ({ process, url, fields, onProcessed, maxCount, countPerPage, searchForm, exportFileName, data: initialData, password, addedFields, overrideFormData, }: ExportProcessorProps) => import("react/jsx-runtime").JSX.Element;
+export {};