@rchemist/listgrid 0.2.6

package/dist/listgrid/config/Config.js

@@ -0,0 +1,299 @@
+import React from 'react';
+import { SearchForm } from '../form/SearchForm';
+import { PageResult } from '../form/Type';
+import { isEmpty } from '../utils';
+import { generateSlug, isBlank } from '../utils/StringUtil';
+import { ValidateResult } from '../validations/Validation';
+function isOptionalReactNode(condition) {
+    return (condition &&
+        (typeof condition.onCreate !== 'undefined' || typeof condition.onUpdate !== 'undefined'));
+}
+export async function getConditionalBoolean(props, condition) {
+    if (!condition) {
+        return false;
+    }
+    if (typeof condition === 'function') {
+        return (await condition(props)) ?? false;
+    }
+    if (typeof condition === 'boolean') {
+        return condition;
+    }
+    const renderTypeValue = props.renderType ?? props.entityForm?.getRenderType();
+    const result = renderTypeValue
+        ? renderTypeValue === 'create'
+            ? condition.onCreate
+            : condition.onUpdate
+        : (condition.onCreate ?? condition.onUpdate);
+    return result ?? false;
+}
+export async function getConditionalString(props, condition) {
+    if (!condition) {
+        return '';
+    }
+    if (typeof condition === 'function') {
+        return (await condition(props)) ?? '';
+    }
+    if (typeof condition === 'string') {
+        return condition;
+    }
+    const renderTypeValue = props.renderType ?? props.entityForm?.getRenderType();
+    const result = renderTypeValue !== undefined
+        ? renderTypeValue === 'update'
+            ? condition.onUpdate
+            : condition.onCreate
+        : (condition.onCreate ?? condition.onUpdate);
+    return result ?? '';
+}
+export async function getConditionalReactNode(props, condition) {
+    if (!condition) {
+        return '';
+    }
+    if (typeof condition === 'function') {
+        return (await condition(props)) ?? '';
+    }
+    // 이 부분이 질문
+    // condition 이 ReactNode 타입인걸 어떻게 확인할 수 있어?
+    if (typeof condition === 'string' ||
+        typeof condition === 'number' ||
+        React.isValidElement(condition)) {
+        return condition;
+    }
+    if (isOptionalReactNode(condition)) {
+        const renderTypeValue = props.renderType ?? props.entityForm?.getRenderType();
+        const hidden = renderTypeValue
+            ? renderTypeValue === 'create'
+                ? condition.onCreate
+                : condition.onUpdate
+            : (condition.onCreate ?? condition.onUpdate);
+        return hidden ?? '';
+    }
+    return null;
+}
+export const ViewPresetTypes = [
+    { value: 'ALWAYS', label: '항상 표시' },
+    { value: 'ADD_ONLY', label: '신규 입력만' },
+    { value: 'MODIFY_ONLY', label: '수정만 가능' },
+];
+export function getViewPreset(type) {
+    if (type === 'ALWAYS') {
+        return ALWAYS;
+    }
+    else if (type === 'MODIFY_ONLY') {
+        return MODIFY_ONLY;
+    }
+    else {
+        return ADD_ONLY;
+    }
+}
+export const NO_FILTER_SORT_ON_LIST = {
+    support: true,
+    sortable: false,
+    filterable: false,
+};
+export const ALWAYS = {
+    hidden: {
+        onCreate: false,
+        onUpdate: false,
+    },
+};
+export const HIDDEN = {
+    hidden: {
+        onCreate: true,
+        onUpdate: true,
+    },
+};
+export const ADD_ONLY = {
+    readonly: {
+        onCreate: false,
+        onUpdate: true,
+    },
+};
+export const MODIFY_ONLY = {
+    readonly: {
+        onCreate: true,
+        onUpdate: false,
+    },
+    hidden: {
+        onCreate: true,
+        onUpdate: false,
+    },
+};
+export const VIEW_ONLY = {
+    readonly: {
+        onCreate: true,
+        onUpdate: true,
+    },
+    hidden: {
+        onCreate: true,
+        onUpdate: false,
+    },
+};
+export const LIST_ONLY = {
+    readonly: {
+        onCreate: true,
+        onUpdate: true,
+    },
+    hidden: {
+        onCreate: true,
+        onUpdate: true,
+    },
+};
+export const VIEW_HIDDEN = {
+    readonly: {
+        onCreate: false,
+        onUpdate: true,
+    },
+    hidden: {
+        onCreate: false,
+        onUpdate: true,
+    },
+};
+export const ModifiableTypes = [
+    { value: 'ALWAYS', label: '항상 표시' },
+    { value: 'ADD_ONLY', label: '신규 입력만' },
+    { value: 'MODIFY_ONLY', label: '수정만 가능' },
+    { value: 'VIEW_ONLY', label: '읽기만 가능' },
+    { value: 'VIEW_HIDDEN', label: '읽기만 표시' },
+    { value: 'HIDDEN', label: '숨김' },
+];
+export function getModifiableType(type) {
+    if (type === 'ALWAYS') {
+        return ALWAYS;
+    }
+    else if (type === 'ADD_ONLY') {
+        return ADD_ONLY;
+    }
+    else if (type === 'MODIFY_ONLY') {
+        return MODIFY_ONLY;
+    }
+    else if (type === 'VIEW_ONLY') {
+        return VIEW_ONLY;
+    }
+    else if (type === 'VIEW_HIDDEN') {
+        return VIEW_HIDDEN;
+    }
+    else if (type === 'HIDDEN') {
+        return HIDDEN;
+    }
+    else {
+        return ALWAYS;
+    }
+}
+export const HAS_VALUE_READONLY = {
+    readonly: (props) => {
+        return props.value?.current || props.value?.fetched
+            ? Promise.resolve(true)
+            : Promise.resolve(false);
+    },
+};
+export const HAS_VALUE_HIDDEN = {
+    hidden: (props) => {
+        return props.value?.current || props.value?.fetched
+            ? Promise.resolve(true)
+            : Promise.resolve(false);
+    },
+};
+/**
+ * 자기 자신을 ManyToOneField 로 가지고 있는 경우 (location.parentLocation 과 같이)
+ * manyToOne 을 lookup 할 때 자기 자신을 제외하는 필터
+ */
+export function excludeSelfOnManyToOneLookup() {
+    return (entityForm) => {
+        // 업데이트일 때 자기 자신은 대상에서 제외한다.
+        const id = entityForm.getId();
+        return Promise.resolve([
+            // 여기서는 NOT_IN 으로 해야 한다. Backend 서버의 LocationController#search 메소드에서 id 에 대한 NOT_EQUALS 를 자동으로 parent Id 를 전부 제외하는 쿼리로 변경하기 때문이다.
+            { name: 'id', queryConditionType: 'NOT_IN', values: [id] },
+        ]);
+    };
+}
+export function excludeIdListOnManyToOneLookUp(idList) {
+    return async (entityForm) => {
+        if (isEmpty(idList)) {
+            return [{ name: '__blank__', queryConditionType: 'NULL' }];
+        }
+        return [{ name: 'id', queryConditionType: 'NOT_IN', values: idList }];
+    };
+}
+export class AssetConfig {
+    static create(maxSize, maxCount, ...extensions) {
+        return new AssetConfig()
+            .withMaxSize(maxSize ?? 10)
+            .withMaxCount(maxCount ?? 1)
+            .withExtensions(...extensions);
+    }
+    withMaxSize(maxSize) {
+        this.maxSize = maxSize;
+        return this;
+    }
+    withMaxCount(maxCount) {
+        this.maxCount = maxCount;
+        return this;
+    }
+    withExtensions(...extensions) {
+        this.extensions = extensions;
+        return this;
+    }
+}
+export const DEFAULT_TAB_INFO = {
+    id: 'default',
+    label: '기본 정보',
+    order: 1,
+};
+export const DEFAULT_FIELD_GROUP_INFO = {
+    id: 'default',
+    label: '기본 정보',
+    order: 1,
+};
+export const STATUS_TAB_INFO = {
+    id: 'status',
+    label: '상태 정보',
+    order: 1000000,
+    hidden: false,
+};
+export const MANAGE_ENTITY_ALL = Object.freeze({
+    create: true,
+    update: true,
+    delete: true,
+});
+export const MANAGE_ENTITY_CREATE = {
+    create: true,
+    update: false,
+    delete: false,
+};
+export const MANAGE_ENTITY_UPDATE = {
+    create: false,
+    update: true,
+    delete: false,
+};
+export const MANAGE_ENTITY_NOT_DELETE = {
+    create: true,
+    update: true,
+    delete: false,
+};
+export async function onChangeNameToSlug(entityForm, fieldName, targetFieldName) {
+    if (entityForm.getRenderType() === 'create') {
+        const nameValue = await entityForm.getValue(fieldName);
+        const generatedSlug = generateSlug(nameValue);
+        entityForm = entityForm.setValue(targetFieldName, generatedSlug).withShouldReload(true);
+    }
+    return entityForm;
+}
+export function checkDuplicateValueProcess({ url, fieldName, label, ...props }) {
+    return async (entityForm, value) => {
+        const searchForm = SearchForm.create().handleAndFilter(fieldName, value);
+        if (props.parent) {
+            searchForm.handleAndFilter(props.parent.fieldName, props.parent.value ?? entityForm.parentId);
+        }
+        if (!isBlank(entityForm.id)) {
+            searchForm.handleAndFilter('id', entityForm.id, 'NOT_EQUAL');
+        }
+        const pageResult = await PageResult.fetchListData(url, searchForm);
+        if ((pageResult?.totalCount ?? 0) > 0) {
+            return ValidateResult.fail(`중복된 ${label} - '${value}' 가 존재합니다. 이 값은 중복될 수 없습니다.`);
+        }
+        else {
+            return ValidateResult.success();
+        }
+    };
+}

package/dist/listgrid/config/EntityField.d.ts

@@ -0,0 +1,148 @@
+import { FieldType, FieldValue, PlaceHolderType, RenderType, RequiredType } from '../config/Config';
+import { ReactNode } from 'react';
+import { EntityForm } from '../config/EntityForm';
+import { ValidateResult, Validation } from '../validations/Validation';
+import { QueryConditionType } from '../form/SearchForm';
+import { EntityItem } from '../config/EntityItem';
+import { Session } from '../auth/types';
+export interface EntityField extends EntityItem {
+    value?: FieldValue | undefined;
+    type: FieldType;
+    placeHolder?: PlaceHolderType;
+    required?: RequiredType;
+    validations?: Validation[];
+    exceptOnSave?: boolean;
+    requiredPermissions?: string[];
+    /**
+     * ViewField 할 때 사용할 수 있다.
+     * 필드를 커스텀으로 표시하게 하는데 필요한 여러 정보를 자유롭게 사용할 수 있다.
+     * 이 정보는 저장 용도로는 사용되지 않는다.
+     */
+    attributes?: Map<string, unknown>;
+    /**
+     * CheckButtonValidation의 검증 상태를 저장
+     * 탭 전환 시에도 상태를 유지하기 위함
+     */
+    validationState?: {
+        validated: boolean;
+        message?: string;
+    };
+    /**
+     * display value 를 변조할 수 있다.
+     * @param field
+     * @param renderType
+     */
+    displayFunc?: (entityForm: EntityForm, field: EntityField, renderType?: RenderType) => Promise<any>;
+    /**
+     * view 를 오버라이드 해 사용자정의 렌더링을 처리하는 경우 이 값을 설정한다.
+     * ReactNode 나 null 을 반환하면 기존 view 를 완전히 대체하게 되고, undefined 를 반환하면 기존 View 를 사용하게 된다.
+     * @param params
+     */
+    overrideRender?: (params: FieldRenderParameters) => Promise<ReactNode | null | undefined>;
+    /**
+     * EntityForm 을 저장할 때 생성하는 formData 에 제공할 값을 override 할 수 있다.
+     * @param field
+     * @param renderType
+     */
+    saveValue?: (entityForm: EntityForm, field: EntityField, renderType?: RenderType) => Promise<any>;
+    view(params: FieldRenderParameters): Promise<ReactNode | null>;
+    isDirty(): boolean;
+    isRequired(props: FieldInfoParameters): Promise<boolean>;
+    isBlank(renderType?: RenderType): Promise<boolean>;
+    withDisplayFunc(fn: (entityForm: EntityForm, field: EntityField, renderType?: RenderType) => Promise<any>): this;
+    withOverrideRender(fn: (params: FieldRenderParameters) => Promise<ReactNode | null | undefined>): this;
+    withPlaceHolder(placeHolder?: PlaceHolderType): this;
+    withRequired(required?: RequiredType): this;
+    withValue(value: any): this;
+    getDisplayValue(entityForm: EntityForm, renderType?: RenderType): Promise<any>;
+    getPlaceHolder(props: FieldInfoParameters): Promise<string>;
+    getSaveValue(entityForm: EntityForm, renderType?: RenderType): Promise<any>;
+    getCurrentValue(renderType?: RenderType): Promise<any>;
+    resetValue(renderType?: RenderType): void;
+    withValidations(...validation: Validation[]): this;
+    validate(entityForm: EntityForm, session?: Session): Promise<ValidateResult | ValidateResult[]>;
+    withDefaultValue(value: any): this;
+    withAttributes(attributes: Map<string, unknown>): this;
+    getFetchedValue(): Promise<any>;
+    /**
+     * 이 필드를 보기 위해 필요한 권한을 설정합니다.
+     * 사용자가 지정된 권한 중 하나라도 가지고 있으면 필드가 표시됩니다.
+     */
+    withRequiredPermissions(...permissions: string[]): this;
+    /**
+     * 사용자가 이 필드를 볼 수 있는 권한이 있는지 확인합니다.
+     * requiredPermissions가 없거나 비어있으면 true를 반환합니다.
+     * 사용자가 requiredPermissions 중 하나라도 가지고 있으면 true를 반환합니다.
+     */
+    isPermitted(userPermissions?: string[]): boolean;
+    /**
+     * View 모드에서 필드 값을 렌더링합니다.
+     * 각 필드 타입별로 적절한 포맷팅을 적용합니다.
+     * (예: NumberField는 formatPrice, SelectField는 Badge 등)
+     * @param props View 렌더링에 필요한 파라미터
+     * @returns 렌더링 결과
+     */
+    viewValue(props: ViewValueProps): Promise<ViewValueResult>;
+}
+/**
+ * EntityField.viewValue 의 props 타입.
+ * FormField.viewValue 가 사용하는 ViewRenderProps 와 구조적으로 동일 —
+ * TForm 제네릭화 (default `any`) + `compact?: boolean` 선행 버그 fix
+ * (CardFieldSection/CardFieldRenderer 호출부가 이미 compact: true 를
+ * 넘기고 있었음. 후속 리팩터링에서 타입 계약 정합성 확보).
+ */
+export interface ViewValueProps<TForm extends object = any> {
+    /** 아이템 데이터 (필드 값을 포함한 객체) */
+    item: TForm;
+    /** 엔티티 폼 인스턴스 (옵션) */
+    entityForm?: EntityForm<TForm>;
+    /**
+     * Compact 모드 - 아이콘 없이 깔끔한 텍스트만 표시.
+     * CardSubCollectionField 등에서 여러 필드를 나열할 때 사용.
+     */
+    compact?: boolean;
+}
+export interface ViewValueResult {
+    /** 렌더링된 React 노드 */
+    result: ReactNode | null;
+}
+export interface FieldRenderParameters<T extends object = any, TValue = any> {
+    entityForm: EntityForm<T>;
+    session?: Session;
+    /**
+     * 필드 값이 변경될 때마다 호출된다.
+     * @param value
+     * @param propagation 상위로 onChange 를 전파할 지 여부, 기본은 true, textarea 나 HTML 에디터 필드와 같은 경우 글자가 변경될 때 마다 상위 전파를 하면 안 되기 때문에 이 값을 선택적으로 설정하게 한다.
+     */
+    onChange: (value: TValue, propagation?: boolean) => void;
+    onError?: (message: string) => void;
+    clearError?: () => void;
+    required?: boolean;
+    readonly?: boolean;
+    placeHolder?: string;
+    helpText?: ReactNode;
+    subCollectionEntity?: boolean;
+    /**
+     * EntityForm을 업데이트하고 리렌더링을 트리거하는 메서드
+     * @param updater EntityForm을 업데이트하는 함수
+     */
+    updateEntityForm?: (updater: (entityForm: EntityForm<T>) => Promise<EntityForm<T>>) => Promise<void>;
+    /**
+     * EntityForm을 리셋하고 초기화 상태로 되돌리는 메서드
+     * @param delay 리로드 전 지연 시간 (밀리초)
+     * @param preserveState 현재 탭 위치 등의 상태 유지 여부
+     */
+    resetEntityForm?: (delay?: number, preserveState?: boolean) => Promise<void>;
+}
+export interface FilterRenderParameters<T extends object = any, TValue = any> {
+    entityForm: EntityForm<T>;
+    onChange: (value: TValue, op?: QueryConditionType) => void;
+    placeHolder?: string;
+    helpText?: string;
+    value?: Promise<TValue>;
+}
+export interface FieldInfoParameters<T extends object = any> {
+    entityForm?: EntityForm<T> | undefined;
+    session?: Session | undefined;
+    renderType?: RenderType | undefined;
+}

package/dist/listgrid/config/EntityField.js

@@ -0,0 +1 @@
+export {};

package/dist/listgrid/config/EntityFieldGroup.d.ts

@@ -0,0 +1,37 @@
+import { SpanValue } from '../common/type';
+import { FieldGroupInfo, FieldGroupConfig } from '../config/Config';
+export declare class EntityFieldGroup {
+    id: string;
+    label: string;
+    order: number;
+    span?: {
+        base?: SpanValue;
+        xs?: SpanValue;
+        sm?: SpanValue;
+        md?: SpanValue;
+        lg?: SpanValue;
+        xl?: SpanValue;
+    } | undefined;
+    fields: FieldGroupItem[];
+    description?: string | undefined;
+    config?: FieldGroupConfig | undefined;
+    requiredPermissions?: string[] | undefined;
+    constructor(config?: FieldGroupInfo);
+    static create(id: string, label: string, order: number): EntityFieldGroup;
+    /**
+     * 이 필드그룹을 보기 위해 필요한 권한을 설정합니다.
+     * 사용자가 지정된 권한 중 하나라도 가지고 있으면 필드그룹이 표시됩니다.
+     */
+    withRequiredPermissions(...permissions: string[]): this;
+    /**
+     * 사용자가 이 필드그룹을 볼 수 있는 권한이 있는지 확인합니다.
+     * requiredPermissions가 없거나 비어있으면 true를 반환합니다.
+     * 사용자가 requiredPermissions 중 하나라도 가지고 있으면 true를 반환합니다.
+     */
+    isPermitted(userPermissions?: string[]): boolean;
+    clone(): EntityFieldGroup;
+}
+export interface FieldGroupItem {
+    name: string;
+    order: number;
+}

package/dist/listgrid/config/EntityFieldGroup.js

@@ -0,0 +1,55 @@
+export class EntityFieldGroup {
+    constructor(config) {
+        this.fields = [];
+        this.id = config?.id ?? 'default';
+        this.order = config?.order ?? 100;
+        this.label = config?.label ?? '기본 정보';
+        this.description = config?.description;
+        this.config = config?.config;
+        this.requiredPermissions = config?.requiredPermissions;
+    }
+    static create(id, label, order) {
+        return new EntityFieldGroup({ id, label, order });
+    }
+    /**
+     * 이 필드그룹을 보기 위해 필요한 권한을 설정합니다.
+     * 사용자가 지정된 권한 중 하나라도 가지고 있으면 필드그룹이 표시됩니다.
+     */
+    withRequiredPermissions(...permissions) {
+        if (!this.requiredPermissions) {
+            this.requiredPermissions = [];
+        }
+        const uniquePermissions = new Set([...this.requiredPermissions, ...permissions]);
+        this.requiredPermissions = Array.from(uniquePermissions);
+        return this;
+    }
+    /**
+     * 사용자가 이 필드그룹을 볼 수 있는 권한이 있는지 확인합니다.
+     * requiredPermissions가 없거나 비어있으면 true를 반환합니다.
+     * 사용자가 requiredPermissions 중 하나라도 가지고 있으면 true를 반환합니다.
+     */
+    isPermitted(userPermissions) {
+        if (!this.requiredPermissions || this.requiredPermissions.length === 0) {
+            return true;
+        }
+        if (!userPermissions || userPermissions.length === 0) {
+            return false;
+        }
+        return this.requiredPermissions.some((permission) => userPermissions.includes(permission));
+    }
+    clone() {
+        const cloned = new EntityFieldGroup({
+            id: this.id,
+            label: this.label,
+            order: this.order,
+            description: this.description,
+            config: this.config,
+        });
+        cloned.fields = [...this.fields];
+        cloned.span = this.span;
+        cloned.requiredPermissions = this.requiredPermissions
+            ? [...this.requiredPermissions]
+            : undefined;
+        return cloned;
+    }
+}

package/dist/listgrid/config/EntityForm.d.ts

@@ -0,0 +1,101 @@
+import { EntityFormActionResult, FieldType } from './Config';
+import { EntityField } from './EntityField';
+import { ListableFormField } from '../components/fields/abstract';
+import { ResponseData } from '../api';
+import { Session } from '../auth';
+import { EntityFormExtensions } from './form/EntityFormExtensions';
+import { FieldError, SubmitFormData } from './EntityFormTypes';
+import { ValidateResult } from '../validations/Validation';
+export declare class EntityForm<T extends object = any> extends EntityFormExtensions<T> {
+    constructor(name: string, url: string);
+    clone(includeValue?: boolean): EntityForm<T>;
+    cloneWithEntityForm(entityForm: EntityForm<T>, includeValue?: boolean): EntityForm<T>;
+    executeOnChanges(fieldName: string): Promise<void>;
+    merge(origin: EntityForm<T>): this;
+    setFetchedValue<K extends keyof T & string>(fieldName: K, value: T[K]): this;
+    setFetchedValue(fieldName: string, value: any): this;
+    withAppendAdvancedSearchFields(...fields: ListableFormField<any>[]): this;
+    /**
+     * ViewEntityForm 에서 최초 setEntityForm 을 할 때 initialize 를 호출해야 한다.
+     */
+    initialize(props: {
+        session?: Session;
+        list?: boolean;
+    }): Promise<EntityFormActionResult>;
+    /**
+     * 필드, 필드그룹, 탭의 숨김 상태를 설정합니다.
+     *
+     * 이 메소드는 세 가지 타입의 숨김 처리를 통합하여 제공합니다:
+     * - FIELD: 개별 필드나 컬렉션의 숨김 상태 설정
+     * - GROUP: 특정 탭 내 필드그룹의 모든 필드를 일괄 숨김 처리
+     * - TAB: 탭 전체와 그 하위 모든 필드를 일괄 숨김 처리
+     *
+     * @param props 숨김 설정 옵션 또는 필드명 (기존 호환성용)
+     * @param props.type 숨김 대상 타입 ('FIELD' | 'GROUP' | 'TAB')
+     * @param props.hidden 숨김 여부 (true: 숨김, false: 표시)
+     * @param props.fieldName [FIELD 타입] 대상 필드 또는 컬렉션의 이름
+     * @param props.tabId [GROUP/TAB 타입] 대상 탭 ID
+     * @param props.fieldGroupId [GROUP 타입] 대상 필드그룹 ID
+     * @param hidden 기존 API 호환성을 위한 숨김 여부 (props가 string일 때만 사용)
+     *
+     * @returns EntityForm 인스턴스 (메소드 체이닝 지원)
+     *
+     * @example
+     * // 개별 필드 숨김
+     * entityForm.withHidden({ type: 'FIELD', hidden: true, fieldName: 'email' });
+     *
+     * @example
+     * // 필드그룹 전체 숨김
+     * entityForm.withHidden({
+     *   type: 'GROUP',
+     *   hidden: true,
+     *   tabId: 'education',
+     *   fieldGroupId: 'university'
+     * });
+     *
+     * @example
+     * // 탭 전체 숨김
+     * entityForm.withHidden({ type: 'TAB', hidden: true, tabId: 'advancedSettings' });
+     *
+     * @example
+     * // 기존 API 호환성 (deprecated)
+     * entityForm.withHidden('fieldName', true);
+     *
+     * @since 1.0.0
+     */
+    withHidden(props: {
+        type: 'FIELD';
+        hidden: boolean;
+        fieldName: string;
+    } | {
+        type: 'GROUP';
+        hidden: boolean;
+        tabId: string;
+        fieldGroupId: string;
+    } | {
+        type: 'TAB';
+        hidden: boolean;
+        tabId: string;
+    } | string, hidden?: boolean): this;
+    delete(): Promise<EntityFormActionResult>;
+    deleteAll(idList: (string | number | bigint | null | undefined)[]): Promise<EntityFormActionResult>;
+    getFields(type?: FieldType, orderByView?: boolean): EntityField[];
+    withOverrideSubmitData(fn: (entityForm: EntityForm<T>, data: any) => Promise<{
+        data: any;
+        modifiedFields?: string[];
+        removePrevious?: boolean;
+        error?: boolean;
+        errors?: FieldError[];
+    }>): this;
+    setFetchedValues(entity: Partial<T> | any): Promise<EntityForm<T>>;
+    fetchData(fetchUrl?: string): Promise<ResponseData>;
+    internalSave(session?: Session, skipValidation?: boolean, forceIncludeExceptOnSave?: boolean): Promise<EntityFormActionResult>;
+    save(session?: Session, skipValidation?: boolean, forceIncludeExceptOnSave?: boolean): Promise<EntityFormActionResult>;
+    getSubmitFormData(forceIncludeExceptOnSave?: boolean): Promise<SubmitFormData>;
+    validate(props?: {
+        fieldNames?: string[] | undefined;
+        session?: Session | undefined;
+    }): Promise<FieldError[]>;
+    withCheckDuplicate(fieldName: string, checkDuplicate: (entityForm: EntityForm<T>, value: string) => Promise<ValidateResult>): this;
+    withFieldToLayout(layout: 'full' | 'half'): this;
+}