@rchemist/listgrid 0.2.6

package/dist/listgrid/components/fields/DateField.js

@@ -0,0 +1,116 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { AbstractDateField, } from './abstract';
+import { getInputRendererParameters } from '../helper/FieldRendererHelper';
+import { fDate } from '../../misc';
+import { FlatPickrDateField } from '../../ui';
+import { IconCalendar } from '@tabler/icons-react';
+import { isTrue } from '../../utils/BooleanUtil';
+import { TextInput } from '../../ui';
+export class DateField extends AbstractDateField {
+    constructor(name, order, limit, range) {
+        super(name, order, 'date', limit, range);
+    }
+    async getCurrentValue(renderType) {
+        const value = await super.getCurrentValue(renderType);
+        if (value === 'today') {
+            if (isTrue(this.range)) {
+                const today = new Date();
+                const tomorrow = new Date(today);
+                tomorrow.setDate(today.getDate() + 1);
+                return [fDate(today), fDate(tomorrow)];
+            }
+            return fDate(new Date());
+        }
+        return value;
+    }
+    /**
+     * DateField 핵심 렌더링 로직
+     */
+    renderInstance(params) {
+        return (async () => {
+            const readonly = isTrue(this.readonly);
+            let value = await this.getCurrentValue(params.entityForm.getRenderType());
+            if (value) {
+                if (this.range && Array.isArray(value)) {
+                    value = `${fDate(value[0])} ~ ${fDate(value[1])}`;
+                }
+                else {
+                    value = fDate(value + '');
+                }
+            }
+            if (readonly) {
+                return (_jsx(TextInput, { name: `${this.name}_${params.entityForm.id}`, readonly: true, onChange: (value) => {
+                        // do nothing
+                    }, value: value }));
+            }
+            return (_jsx(FlatPickrDateField, { type: 'date', limit: this.limit, range: this.range, ...await getInputRendererParameters(this, params) }));
+        })();
+    }
+    /**
+     * DateField 핵심 리스트 필터 렌더링 로직
+     */
+    renderListFilterInstance(params) {
+        return (async () => {
+            return (_jsx(FlatPickrDateField, { type: 'date', name: this.getName(), onChange: (value) => {
+                    if (Array.isArray(value) && value.length === 2) {
+                        if (value[0] === value[1]) {
+                            const until = new Date(value[1]);
+                            until.setDate(until.getDate() + 1);
+                            params.onChange([value[0], fDate(until, `yyyy-MM-dd`)], 'BETWEEN');
+                        }
+                        else {
+                            params.onChange(value, 'BETWEEN');
+                        }
+                        return;
+                    }
+                }, limit: this.limit, range: true, value: params.value }));
+        })();
+    }
+    /**
+     * DateField 핵심 리스트 아이템 렌더링 로직
+     */
+    renderListItemInstance(props) {
+        const value = props.item[this.name];
+        if (this.range && Array.isArray(value) && value.length === 2) {
+            return Promise.resolve({
+                result: `${fDate(value[0], 'yyyy-MM-dd')} ~ ${fDate(value[1], 'yyyy-MM-dd')}`,
+            });
+        }
+        return Promise.resolve({ result: fDate(value ?? '', 'yyyy-MM-dd') });
+    }
+    /**
+     * DateField View 모드 렌더링 - 날짜 포맷팅 및 캘린더 아이콘 적용
+     * cardIcon이 설정된 경우 해당 아이콘을 우선 사용
+     */
+    async renderViewInstance(props) {
+        const value = props.item[this.name];
+        // null, undefined, 빈 문자열 처리
+        if (value === null || value === undefined || value === '') {
+            return { result: null };
+        }
+        // 아이콘 컴포넌트 결정 (cardIcon > 기본 캘린더 아이콘)
+        const IconComponent = this.cardIcon || IconCalendar;
+        const frameColor = this.cardIcon ? undefined : 'info';
+        // range 타입인 경우 시작~끝 포맷
+        if (this.range && Array.isArray(value) && value.length === 2) {
+            const dateText = `${fDate(value[0], 'yyyy-MM-dd')} ~ ${fDate(value[1], 'yyyy-MM-dd')}`;
+            return {
+                result: (_jsxs("span", { className: "rcm-bool-wrap", children: [_jsx("span", { className: "rcm-icon-frame", "data-color": frameColor, children: _jsx(IconComponent, { className: "rcm-icon", "data-size": "sm", stroke: 1.75 }) }), _jsx("span", { className: "rcm-text", "data-weight": "medium", children: dateText })] })),
+            };
+        }
+        // 일반 날짜: yyyy-MM-dd 포맷으로 표시 (캘린더 아이콘 포함)
+        const dateText = fDate(value, 'yyyy-MM-dd');
+        return {
+            result: (_jsxs("span", { className: "rcm-bool-wrap", children: [_jsx("span", { className: "rcm-icon-frame", "data-color": frameColor, children: _jsx(IconComponent, { className: "rcm-icon", "data-size": "sm", stroke: 1.75 }) }), _jsx("span", { className: "rcm-text", "data-weight": "medium", children: dateText })] })),
+        };
+    }
+    /**
+     * DateField 인스턴스 생성
+     */
+    createInstance(name, order) {
+        return new DateField(name, order, this.limit, this.range);
+    }
+    static create(props) {
+        return new DateField(props.name, props.order, props.limit, props.range).copyFields(props, true);
+    }
+}

package/dist/listgrid/components/fields/DatetimeField.d.ts

@@ -0,0 +1,29 @@
+import { AbstractDateField, AbstractDateFieldProps, ViewListProps, ViewListResult } from './abstract';
+import React from 'react';
+import { FieldRenderParameters, FilterRenderParameters } from '../../config/EntityField';
+import { RenderType } from '../../config/Config';
+import { MinMaxStringLimit } from '../../form/Type';
+interface DatetimeFieldProps extends AbstractDateFieldProps {
+}
+export declare class DatetimeField extends AbstractDateField<DatetimeField> {
+    constructor(name: string, order: number, limit?: MinMaxStringLimit, range?: boolean);
+    getCurrentValue(renderType?: RenderType): Promise<string | undefined | string[]>;
+    /**
+     * DatetimeField 핵심 렌더링 로직
+     */
+    protected renderInstance(params: FieldRenderParameters): Promise<React.ReactNode | null>;
+    /**
+     * DatetimeField 핵심 리스트 필터 렌더링 로직
+     */
+    protected renderListFilterInstance(params: FilterRenderParameters): Promise<React.ReactNode | null>;
+    /**
+     * DatetimeField 핵심 리스트 아이템 렌더링 로직
+     */
+    protected renderListItemInstance(props: ViewListProps): Promise<ViewListResult>;
+    /**
+     * DatetimeField 인스턴스 생성
+     */
+    protected createInstance(name: string, order: number): DatetimeField;
+    static create(props: DatetimeFieldProps): DatetimeField;
+}
+export {};

package/dist/listgrid/components/fields/DatetimeField.js

@@ -0,0 +1,93 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { AbstractDateField, } from './abstract';
+import { fDate, fDateTime, fToNow } from '../../misc';
+import { getInputRendererParameters } from '../helper/FieldRendererHelper';
+import { FlatPickrDateField } from '../../ui';
+import { isTrue } from '../../utils/BooleanUtil';
+import { DatetimeFilter } from './filter/DatetimeFilter';
+import { isBlank } from '../../utils/StringUtil';
+import { Tooltip } from '../../ui';
+import { TextInput } from '../../ui';
+export class DatetimeField extends AbstractDateField {
+    constructor(name, order, limit, range) {
+        super(name, order, 'date', limit, range);
+    }
+    async getCurrentValue(renderType) {
+        const value = await super.getCurrentValue(renderType);
+        if (value === 'today') {
+            if (isTrue(this.range)) {
+                const today = new Date();
+                const tomorrow = new Date(today);
+                tomorrow.setDate(today.getDate() + 1);
+                return [fDate(today, `yyyy-MM-dd HH:mm`), fDate(tomorrow, `yyyy-MM-dd HH:mm`)];
+            }
+            return fDate(new Date(), `yyyy-MM-dd'T'HH:mm`);
+        }
+        return value;
+    }
+    /**
+     * DatetimeField 핵심 렌더링 로직
+     */
+    renderInstance(params) {
+        return (async () => {
+            const readonly = isTrue(this.readonly);
+            const value = (await this.getCurrentValue(params.entityForm.getRenderType())) + '';
+            if (readonly) {
+                return (_jsx(TextInput, { name: `${this.name}_${params.entityForm.id}`, readonly: true, onChange: () => {
+                        // do nothing
+                    }, value: fDateTime(value) }));
+            }
+            else {
+                return (_jsx(FlatPickrDateField, { type: 'datetime', limit: this.limit, range: this.range, ...await getInputRendererParameters(this, params) }));
+            }
+        })();
+    }
+    /**
+     * DatetimeField 핵심 리스트 필터 렌더링 로직
+     */
+    renderListFilterInstance(params) {
+        return (async () => {
+            return _jsx(DatetimeFilter, { ...params, name: this.getName(), limit: this.limit });
+        })();
+    }
+    /**
+     * DatetimeField 핵심 리스트 아이템 렌더링 로직
+     */
+    renderListItemInstance(props) {
+        if (this.range) {
+            const value = props.item[this.name];
+            if (value == undefined) {
+                return Promise.resolve({ result: '' });
+            }
+            else {
+                return Promise.resolve({ result: `${fDateTime(value[0])} ~ ${fDateTime(value[1])}` });
+            }
+        }
+        else {
+            const viewRaw = isTrue(this.listConfig?.viewRaw);
+            if (viewRaw) {
+                return Promise.resolve({ result: fDate(props.item[this.name]) });
+            }
+            else {
+                const value = fToNow(props.item[this.name]) ?? '';
+                if (isBlank(value)) {
+                    return Promise.resolve({ result: '' });
+                }
+                else {
+                    return Promise.resolve({
+                        result: (_jsx(Tooltip, { label: `${fDateTime(props.item[this.name])}`, children: _jsx("span", { children: value }) })),
+                    });
+                }
+            }
+        }
+    }
+    /**
+     * DatetimeField 인스턴스 생성
+     */
+    createInstance(name, order) {
+        return new DatetimeField(name, order, this.limit, this.range);
+    }
+    static create(props) {
+        return new DatetimeField(props.name, props.order, props.limit, props.range).copyFields(props, true);
+    }
+}

package/dist/listgrid/components/fields/EmailField.d.ts

@@ -0,0 +1,37 @@
+import { CheckButtonValidationField, CheckButtonValidationFieldProps } from './abstract';
+import React from 'react';
+import { Validation } from '../../validations/Validation';
+import { FieldRenderParameters, FilterRenderParameters } from '../../config/EntityField';
+interface EmailFieldProps extends CheckButtonValidationFieldProps {
+    text?: boolean;
+    commonDomains?: string[];
+}
+export declare class EmailField extends CheckButtonValidationField<EmailField> {
+    text: boolean;
+    commonDomains: string[];
+    constructor(name: string, order: number, validations?: Validation[]);
+    withText(text: boolean): this;
+    withCommonDomains(commonDomains: string[]): this;
+    /**
+     * EmailField 핵심 렌더링 로직
+     */
+    protected renderInstance(params: FieldRenderParameters): Promise<React.ReactNode | null>;
+    /**
+     * EmailDomainInput 렌더링 (복합 입력 모드)
+     */
+    private renderEmailDomainInput;
+    /**
+     * EmailDomainCheckButtonInput 렌더링 (복합 입력 모드 + 중복확인 버튼)
+     */
+    private renderCheckButtonValidationEmailDomainInput;
+    /**
+     * EmailField 핵심 리스트 필터 렌더링 로직
+     */
+    protected renderListFilterInstance(params: FilterRenderParameters): Promise<React.ReactNode | null>;
+    /**
+     * EmailField 인스턴스 생성
+     */
+    protected createInstance(name: string, order: number): EmailField;
+    static create(props: EmailFieldProps): EmailField;
+}
+export {};

package/dist/listgrid/components/fields/EmailField.js

@@ -0,0 +1,144 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { CheckButtonValidationField } from './abstract';
+import { ValidateResult } from '../../validations/Validation';
+import { EmailValidation } from '../../validations/EmailValidation';
+import { getInputRendererParameters } from '../helper/FieldRendererHelper';
+import { TextInput } from '../../ui';
+import { DEFAULT_EMAIL_DOMAINS, EmailDomainCheckButtonInput, EmailDomainInput } from '../../ui';
+import { isEmpty } from '../../utils';
+export class EmailField extends CheckButtonValidationField {
+    constructor(name, order, validations) {
+        super(name, order, 'email');
+        this.text = true;
+        this.commonDomains = DEFAULT_EMAIL_DOMAINS;
+        if (validations) {
+            this.validations = [...validations];
+        }
+        else {
+            this.validations = [new EmailValidation()];
+        }
+    }
+    withText(text) {
+        this.text = text;
+        return this;
+    }
+    withCommonDomains(commonDomains) {
+        this.commonDomains = commonDomains;
+        return this;
+    }
+    /**
+     * EmailField 핵심 렌더링 로직
+     */
+    renderInstance(params) {
+        if (this.checkButtonValidation !== undefined) {
+            if (this.text) {
+                // text mode with checkButtonValidation
+                return this.renderCheckButtonValidationField(params);
+            }
+            // complex mode with checkButtonValidation
+            return this.renderCheckButtonValidationEmailDomainInput(params);
+        }
+        if (this.text) {
+            return (async () => {
+                return _jsx(TextInput, { ...await getInputRendererParameters(this, params) });
+            })();
+        }
+        // Complex mode: [localPart] @ [domain select/input]
+        return this.renderEmailDomainInput(params);
+    }
+    /**
+     * EmailDomainInput 렌더링 (복합 입력 모드)
+     */
+    renderEmailDomainInput(params) {
+        return (async () => {
+            const entityForm = params.entityForm;
+            const value = await entityForm.getValue(this.getName());
+            return (_jsx(EmailDomainInput, { value: value, name: this.getName(), readonly: params.readonly, required: params.required, commonDomains: this.commonDomains, onChange: (newValue) => params.onChange(newValue) }));
+        })();
+    }
+    /**
+     * EmailDomainCheckButtonInput 렌더링 (복합 입력 모드 + 중복확인 버튼)
+     */
+    renderCheckButtonValidationEmailDomainInput(params) {
+        return (async () => {
+            const entityForm = params.entityForm;
+            const value = await entityForm.getValue(this.getName());
+            return (_jsx(EmailDomainCheckButtonInput, { name: this.getName(), entityForm: entityForm, onError: params.onError, readonly: params.readonly, required: params.required, commonDomains: this.commonDomains, buttonLabel: this.checkButtonLabel, value: value, defaultValue: this.value?.fetched ?? this.value?.default ?? '', onValid: (newValue) => {
+                    entityForm.setFieldValidationState(this.getName(), {
+                        validated: true,
+                        color: 'success',
+                    });
+                    params.onChange(newValue);
+                }, onClear: () => {
+                    entityForm.clearFieldValidationState(this.getName());
+                    params.onChange('');
+                }, onCheck: async (checkValue) => {
+                    if (!isEmpty(this.validations)) {
+                        const currentValue = { ...this.value };
+                        this.value = { ...this.value, current: checkValue };
+                        const validateResult = await this.validate(entityForm);
+                        if (Array.isArray(validateResult)) {
+                            for (const result of validateResult) {
+                                if (result.hasError()) {
+                                    this.value = currentValue;
+                                    entityForm.setFieldValidationState(this.getName(), {
+                                        validated: false,
+                                        message: result.message,
+                                        color: 'secondary',
+                                    });
+                                    return ValidateResult.fail(result.message + ' 입력 값을 변경하고 중복확인을 눌러 주세요.');
+                                }
+                            }
+                        }
+                        else {
+                            if (validateResult.hasError()) {
+                                this.value = currentValue;
+                                entityForm.setFieldValidationState(this.getName(), {
+                                    validated: false,
+                                    message: validateResult.message,
+                                    color: 'secondary',
+                                });
+                                return ValidateResult.fail(validateResult.message + ' 입력 값을 변경하고 중복확인을 눌러 주세요.');
+                            }
+                        }
+                    }
+                    const result = await this.checkButtonValidation(entityForm, checkValue);
+                    entityForm.setFieldValidationState(this.getName(), {
+                        validated: !result.error,
+                        message: result.message,
+                        color: result.error ? 'secondary' : 'success',
+                    });
+                    return result;
+                } }));
+        })();
+    }
+    /**
+     * EmailField 핵심 리스트 필터 렌더링 로직
+     */
+    renderListFilterInstance(params) {
+        return (async () => {
+            return (_jsx(TextInput, { ...await getInputRendererParameters(this, {
+                    ...params,
+                    onChange: (value) => params.onChange(value, 'LIKE'),
+                }) }));
+        })();
+    }
+    /**
+     * EmailField 인스턴스 생성
+     */
+    createInstance(name, order) {
+        return new EmailField(name, order, this.validations)
+            .withText(this.text)
+            .withCommonDomains(this.commonDomains);
+    }
+    static create(props) {
+        const field = new EmailField(props.name, props.order, props.validations).copyFields(props, true);
+        if (props.text !== undefined) {
+            field.withText(props.text);
+        }
+        if (props.commonDomains !== undefined) {
+            field.withCommonDomains(props.commonDomains);
+        }
+        return field;
+    }
+}

package/dist/listgrid/components/fields/FileField.d.ts

@@ -0,0 +1,36 @@
+import { ListableFormField, ListableFormFieldProps, ViewListProps, ViewListResult } from './abstract';
+import React from 'react';
+import { IAssetConfig, RenderType } from '../../config/Config';
+import { FieldRenderParameters, FilterRenderParameters } from '../../config/EntityField';
+interface FileFieldProps extends ListableFormFieldProps {
+    config?: IAssetConfig | undefined;
+}
+export declare class FileField extends ListableFormField<FileField> {
+    config?: IAssetConfig | undefined;
+    constructor(name: string, order: number, config?: IAssetConfig);
+    withConfig(config?: IAssetConfig): this;
+    withMaxSize(maxSize?: number): this;
+    withMaxCount(maxCount?: number): this;
+    withExtensions(...extension: string[]): this;
+    withFileTypes(...fileTypes: string[]): this;
+    /**
+     * FileField 핵심 렌더링 로직 (원본 render 로직 보존)
+     */
+    protected renderInstance(params: FieldRenderParameters): Promise<React.ReactNode | null>;
+    /**
+     * FileField 인스턴스 생성
+     */
+    protected createInstance(name: string, order: number): FileField;
+    /**
+     * FileField 리스트 필터 렌더링 (기본 텍스트 입력)
+     */
+    protected renderListFilterInstance(params: FilterRenderParameters): Promise<React.ReactNode | null>;
+    /**
+     * FileField 리스트 아이템 렌더링 (원본 renderListItem 로직 보존)
+     */
+    protected renderListItemInstance(props: ViewListProps): Promise<ViewListResult>;
+    static create(props: FileFieldProps): FileField;
+    isBlank(renderType?: RenderType): Promise<boolean>;
+    isDirty(): boolean;
+}
+export {};

package/dist/listgrid/components/fields/FileField.js

@@ -0,0 +1,157 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ListableFormField, } from './abstract';
+import { FileFieldValue } from '../../ui';
+import { LazyFileUploadInput as FileUploadInput } from '../../ui';
+import { getInputRendererParameters } from '../helper/FieldRendererHelper';
+import { isEmpty } from '../../utils';
+import { getAccessableAssetUrl } from '../../misc';
+import { IconDeviceFloppy } from '@tabler/icons-react';
+import { TextInput } from '../../ui';
+import { isBlank as isBlankString } from '../../utils/StringUtil';
+export class FileField extends ListableFormField {
+    constructor(name, order, config) {
+        super(name, order, 'file');
+        this.config = config;
+    }
+    withConfig(config) {
+        this.config = config;
+        return this;
+    }
+    withMaxSize(maxSize) {
+        this.config = {
+            maxSize: maxSize,
+            maxCount: this.config?.maxCount,
+            extensions: this.config?.extensions,
+            fileTypes: this.config?.fileTypes,
+        };
+        return this;
+    }
+    withMaxCount(maxCount) {
+        this.config = {
+            maxSize: this.config?.maxSize,
+            maxCount: maxCount,
+            extensions: this.config?.extensions,
+            fileTypes: this.config?.fileTypes,
+        };
+        return this;
+    }
+    withExtensions(...extension) {
+        this.config = {
+            maxSize: this.config?.maxSize,
+            maxCount: this.config?.maxCount,
+            extensions: extension,
+            fileTypes: this.config?.fileTypes,
+        };
+        return this;
+    }
+    withFileTypes(...fileTypes) {
+        this.config = {
+            maxSize: this.config?.maxSize,
+            maxCount: this.config?.maxCount,
+            extensions: this.config?.extensions,
+            fileTypes: fileTypes,
+        };
+        return this;
+    }
+    /**
+     * FileField 핵심 렌더링 로직 (원본 render 로직 보존)
+     */
+    renderInstance(params) {
+        return (async () => {
+            return (_jsx(FileUploadInput, { config: this.config, ...await getInputRendererParameters(this, params) }));
+        })();
+    }
+    /**
+     * FileField 인스턴스 생성
+     */
+    createInstance(name, order) {
+        return new FileField(name, order, this.config);
+    }
+    /**
+     * FileField 리스트 필터 렌더링 (기본 텍스트 입력)
+     */
+    renderListFilterInstance(params) {
+        return (async () => {
+            return (_jsx(TextInput, { name: `${this.name}_${params.entityForm.id}`, onChange: (value) => params.onChange(value, 'LIKE'), value: params.value }));
+        })();
+    }
+    /**
+     * FileField 리스트 아이템 렌더링 (원본 renderListItem 로직 보존)
+     */
+    renderListItemInstance(props) {
+        return (async () => {
+            const value = await props.item;
+            if (value[this.name]) {
+                const file = value[this.name];
+                if (!isEmpty(file.existFiles) && !isBlankString(file.existFiles[0]?.url)) {
+                    const fileDownloadUrl = getAccessableAssetUrl(file.existFiles[0].url);
+                    return {
+                        result: (_jsx("div", { className: "rcm-file-field-cell", children: _jsx("div", { className: "rcm-file-field-inner", children: _jsxs("a", { href: fileDownloadUrl, target: "_blank", rel: "noreferrer", className: "rcm-file-field-link", children: [_jsx(IconDeviceFloppy, { className: "rcm-file-field-icon" }), _jsx("span", { className: "rcm-file-field-name", children: file.existFiles[0].url })] }) }) })),
+                        linkOnCell: false,
+                    };
+                }
+            }
+            return {
+                result: null,
+            };
+        })();
+    }
+    static create(props) {
+        return new FileField(props.name, props.order, props.config).copyFields(props, true);
+    }
+    async isBlank(renderType = 'create') {
+        const value = await this.getCurrentValue(renderType);
+        if (value !== undefined && value !== null && value instanceof FileFieldValue) {
+            let blank = true;
+            for (const file of value.existFiles) {
+                if (!isBlankString(file.url)) {
+                    blank = false;
+                    break;
+                }
+            }
+            if (blank) {
+                for (const file of value.newFiles) {
+                    if (!isBlankString(file.url)) {
+                        blank = false;
+                        break;
+                    }
+                }
+            }
+            return blank;
+        }
+        return true;
+    }
+    isDirty() {
+        if (this.value) {
+            if (this.value.fetched !== undefined) {
+                // fetch 된 값이 존재할 때는 fetched 된 값과 비교한다.
+                let dirty = this.value.current === undefined || this.value.current === null;
+                if (!dirty) {
+                    const fileValue = FileFieldValue.create(this.value.current);
+                    return fileValue.isDirty();
+                }
+                return dirty;
+            }
+            else {
+                // fetch 된 값이 없을 때는 default 값과 비교한다.
+                let dirty = this.value.default === undefined || this.value.default === null;
+                if (!dirty) {
+                    const fileValue = FileFieldValue.create(this.value.default);
+                    return fileValue.isDirty();
+                }
+                else {
+                    const value = this.value.current;
+                    // 현재 값에 아무 파일이 없을 때
+                    if (this.value.current === undefined || this.value.current === null) {
+                        return false;
+                    }
+                    if (value !== undefined && value !== null && value instanceof FileFieldValue) {
+                        return value.isDirty();
+                    }
+                }
+                return dirty;
+            }
+        }
+        return false;
+    }
+}

package/dist/listgrid/components/fields/HtmlField.d.ts

@@ -0,0 +1,24 @@
+import { FormField, FormFieldProps, ViewRenderProps, ViewRenderResult } from './abstract';
+import { FieldRenderParameters } from '../../config/EntityField';
+import React from 'react';
+interface HtmlFieldProps extends FormFieldProps {
+}
+export declare class HtmlField extends FormField<HtmlField> {
+    constructor(name: string, order: number);
+    /**
+     * HtmlField 핵심 렌더링 로직
+     */
+    protected renderInstance(params: FieldRenderParameters): Promise<React.ReactNode | null>;
+    /**
+     * View mode: render HTML content with dangerouslySetInnerHTML
+     */
+    protected renderViewInstance(props: ViewRenderProps): Promise<ViewRenderResult>;
+    /**
+     * HtmlField 인스턴스 생성
+     */
+    protected createInstance(name: string, order: number): HtmlField;
+    private isEqualsOrEmpty;
+    isDirty(): boolean;
+    static create(props: HtmlFieldProps): HtmlField;
+}
+export {};