@rchemist/listgrid 0.2.6

package/dist/listgrid/config/form/EntityFormActions.js

@@ -0,0 +1,459 @@
+import { EntityFormData } from './EntityFormData';
+import { AbstractManyToOneField, FormField, ListableFormField, OptionalField, } from '../../components/fields/abstract';
+import { StatusCreatedAtFieldPreset, StatusCreatedAndUpdatedAtFieldPreset, ActiveField, } from '../../components/fields/Preset';
+import { DEFAULT_TAB_INFO, DEFAULT_FIELD_GROUP_INFO, STATUS_TAB_INFO, } from '../../config/Config';
+import { EntityTab } from '../../config/EntityTab';
+import { SubCollectionField } from '../../config/SubCollectionField';
+import { isTrue } from '../../utils/BooleanUtil';
+import { StringField } from '../../components/fields/StringField';
+import { EntityForm } from '../../config/EntityForm';
+import { DataTransferConfig, DataField } from '../../transfer/Type';
+import { isEmpty } from '../../utils/CompareUtil';
+export class EntityFormActions extends EntityFormData {
+    constructor(name, url) {
+        super(name, url);
+    }
+    getListableFieldOrder(field) {
+        const listConfig = field.listConfig;
+        if (listConfig?.order !== undefined) {
+            return listConfig.order;
+        }
+        let order = field.order ?? 0;
+        const tab = this.getTab(field.getTabId());
+        if (tab) {
+            order = tab.order * 1000000 + order;
+            const fieldGroup = this.getFieldGroup(tab.id, field.getFieldGroupId());
+            if (fieldGroup) {
+                order = fieldGroup.order * 10000 + order;
+            }
+        }
+        return order;
+    }
+    /**
+     * Alert 메시지를 제거합니다.
+     * @param includePersistent persistent 메시지도 제거할지 여부 (true면 persistent 메시지도 제거)
+     * @returns EntityForm 인스턴스
+     */
+    clearAlertMessages(includePersistent = false) {
+        if (includePersistent) {
+            // persistent 메시지도 포함하여 모두 제거
+            this.alertMessages = [];
+        }
+        else {
+            // persistent가 true인 메시지만 남기고 제거
+            this.alertMessages = this.alertMessages.filter((msg) => msg.persistent === true);
+        }
+        return this;
+    }
+    /**
+     * Alert 메시지를 추가합니다.
+     * @param messages 추가할 Alert 메시지 배열
+     * @returns EntityForm 인스턴스
+     */
+    withAlertMessages(messages) {
+        // 기존 메시지 중 같은 key가 없는 것만 유지
+        const existingKeys = new Set(messages.map((m) => m.key));
+        const filteredExisting = this.alertMessages.filter((m) => !existingKeys.has(m.key));
+        // 새 메시지와 합치기
+        this.alertMessages = [...filteredExisting, ...messages];
+        return this;
+    }
+    /**
+     * 특정 키의 Alert 메시지를 제거합니다.
+     * @param key 제거할 메시지의 키
+     * @returns EntityForm 인스턴스
+     */
+    removeAlertMessage(key) {
+        this.alertMessages = this.alertMessages.filter((msg) => msg.key !== key);
+        return this;
+    }
+    withExcludeListFields(...excludeListFields) {
+        if (this.excludeListFields) {
+            // 중복 제거 후 추가
+            const fieldsSet = new Set([...this.excludeListFields, ...excludeListFields]);
+            this.excludeListFields = [...fieldsSet];
+        }
+        return this;
+    }
+    /**
+     * 현재 Alert 메시지들을 반환합니다.
+     * @returns Alert 메시지 배열
+     */
+    getAlertMessages() {
+        return [...this.alertMessages];
+    }
+    /**
+     * 모든 메시지를 제거합니다. (현재는 Alert 메시지만 지원)
+     * @param includePersistent persistent 메시지도 제거할지 여부 (true면 persistent 메시지도 제거)
+     * @returns EntityForm 인스턴스
+     */
+    clearAllMessages(includePersistent = false) {
+        // Alert 메시지 제거
+        this.clearAlertMessages(includePersistent);
+        // TODO: Toast, SweetAlert 메시지 지원 추가 필요
+        return this;
+    }
+    withListConfig(fieldName, config) {
+        const field = this.getField(fieldName);
+        if (field !== undefined && field instanceof ListableFormField) {
+            field.withListConfig(config);
+        }
+        return this;
+    }
+    withCreatedAtField() {
+        return this.addFields(StatusCreatedAtFieldPreset);
+    }
+    withCreatedAndUpdatedAtFields() {
+        return this.addFields(StatusCreatedAndUpdatedAtFieldPreset);
+    }
+    addFields(props) {
+        if (props.items.length === 0) {
+            return this;
+        }
+        const tab = props.tab ?? DEFAULT_TAB_INFO;
+        const fieldGroup = props.fieldGroup ?? DEFAULT_FIELD_GROUP_INFO;
+        const overwrite = props.overwrite ?? false; // 기본값은 false (중복 필드 추가 방지)
+        let entityTab;
+        if (this.hasTab(tab.id)) {
+            entityTab = this.getTab(tab.id);
+        }
+        else {
+            // create entityTab
+            entityTab = new EntityTab(tab);
+            this.tabs.set(tab.id, entityTab);
+        }
+        for (const field of props.items) {
+            // 중복 체크: overwrite가 false이고 이미 필드가 존재하면 건너뛴다
+            if (!overwrite) {
+                if (field instanceof FormField && this.fields.has(field.name)) {
+                    continue; // 이미 존재하는 필드는 추가하지 않음
+                }
+                else if (field instanceof SubCollectionField && this.collections.has(field.name)) {
+                    continue; // 이미 존재하는 컬렉션은 추가하지 않음
+                }
+            }
+            entityTab.addField(fieldGroup, field);
+            const target = field.withTabId(tab.id).withFieldGroupId(fieldGroup.id).clone();
+            if (target instanceof FormField) {
+                // field 의 tabInfo, fieldGroupInfo 를 설정한다.
+                this.fields.set(field.name, target);
+            }
+            else if (field instanceof SubCollectionField) {
+                this.collections.set(field.name, target);
+            }
+        }
+        return this;
+    }
+    removeField(fieldName) {
+        this.fields.delete(fieldName);
+    }
+    /**
+     * Field 와 Collection 모두 EntityItem 을 인수로 받기 때문에 둘 간의 차이는 없다.
+     * @param props
+     */
+    addCollections(props) {
+        return this.addFields(props);
+    }
+    useListFields(...fieldNames) {
+        if (fieldNames.length === 0) {
+            return this;
+        }
+        for (const fieldName of fieldNames) {
+            const field = this.getField(fieldName);
+            if (field && field instanceof ListableFormField) {
+                field.useListField();
+            }
+        }
+        return this;
+    }
+    /**
+     * ListGrid 를 그릴 때 getListField() 를 호출하면 자동으로 리스트 필드를 만든다.
+     */
+    getListFields() {
+        const listFields = [];
+        const excludeFields = this.excludeListFields ?? [];
+        let temp = undefined;
+        Array.from(this.fields.values()).forEach((field) => {
+            // exclude 로 저징된 필드가 아닌 경우에만 ListGridField 로 지정한다.
+            if (field instanceof ListableFormField && !excludeFields.includes(field.getName())) {
+                if (field.isSupportList()) {
+                    listFields.push(field);
+                }
+                // 설정된 리스트 필드가 하나도 없는 경우를 대비해 첫번째 리스트 필드에 대해 따로 저장해 둔다.
+                if (temp === undefined) {
+                    temp = field;
+                }
+            }
+        });
+        if (listFields.length === 0) {
+            // 하나도 없는 경우에는 에러
+            if (temp === undefined) {
+                throw new Error('There is no list field');
+            }
+            listFields.push(temp);
+        }
+        // sort by listFields[0].getListConfig()?.order
+        listFields.sort((a, b) => {
+            const aOrder = this.getListableFieldOrder(a);
+            const bOrder = this.getListableFieldOrder(b);
+            return aOrder - bOrder;
+        });
+        return listFields;
+    }
+    getFilterableFields() {
+        const filterFields = [];
+        let temp = undefined;
+        let manyToOneAdded = false;
+        Array.from(this.fields.values()).forEach((field) => {
+            // exclude 로 저징된 필드가 아닌 경우에만 ListGridField 로 지정한다.
+            if (field instanceof ListableFormField) {
+                if (field.isFilterable()) {
+                    filterFields.push(field);
+                    // 이 필드의 type 이 manyToOne 인 경우에는 그 필드의 EntityForm 설정을 찾아서 name 필드가 있다면 검색 필터에 추가로 지정해 준다.
+                    if (field instanceof AbstractManyToOneField &&
+                        !('includeUser' in field && isTrue(field.includeUser))) {
+                        const entityForm = field.getEntityForm();
+                        if (entityForm && entityForm.hasField('name')) {
+                            const originNameField = entityForm.getField('name');
+                            if (originNameField instanceof ListableFormField &&
+                                isTrue(originNameField.getListConfig()?.filterable)) {
+                                const nameField = new StringField(field.name + '.name', field.order + 1)
+                                    .withLabel(field.getLabel() + ' 이름')
+                                    .withViewHidden()
+                                    .withListConfig({
+                                    order: field.listConfig?.order ? field.listConfig.order + 1 : field.order + 1,
+                                    support: false,
+                                    filterable: true,
+                                    sortable: false,
+                                    quickSearch: true,
+                                    op: 'LIKE',
+                                });
+                                filterFields.push(nameField);
+                                manyToOneAdded = true;
+                            }
+                        }
+                    }
+                    // UserField with includeUser=true 체크
+                    if (field instanceof AbstractManyToOneField &&
+                        'includeUser' in field &&
+                        isTrue(field.includeUser)) {
+                        const entityForm = field.getEntityForm();
+                        if (entityForm && entityForm.hasField('user.name')) {
+                            const nameField = new StringField(field.name + '.user.name', field.order + 1)
+                                .withLabel(field.getLabel() + ' 이름')
+                                .withViewHidden()
+                                .withListConfig({
+                                order: field.listConfig?.order ? field.listConfig.order + 1 : 0,
+                                support: false,
+                                filterable: true,
+                                sortable: false,
+                                quickSearch: true,
+                                op: 'LIKE',
+                            });
+                            filterFields.push(nameField);
+                            manyToOneAdded = true;
+                        }
+                    }
+                }
+                // 설정된 리스트 필드가 하나도 없는 경우를 대비해 첫번째 리스트 필드에 대해 따로 저장해 둔다.
+                if (temp === undefined) {
+                    temp = field;
+                }
+            }
+        });
+        if (filterFields.length === 0) {
+            // 하나도 없는 경우에는 에러
+            if (temp === undefined) {
+                throw new Error('There is no list field');
+            }
+            filterFields.push(temp);
+        }
+        // manyToOneAdded 라면 filterFields 중에 중복된 값이 있는지 확인한다.
+        if (manyToOneAdded) {
+            const filteredFields = [];
+            for (const field of filterFields) {
+                if (!filteredFields.some((f) => f.getName() === field.getName())) {
+                    filteredFields.push(field);
+                }
+            }
+            filterFields.splice(0, filterFields.length, ...filteredFields);
+        }
+        // sort by listFields[0].getListConfig()?.order
+        filterFields.sort((a, b) => {
+            const aOrder = this.getListableFieldOrder(a);
+            const bOrder = this.getListableFieldOrder(b);
+            return aOrder - bOrder;
+        });
+        return filterFields;
+    }
+    getViewOrder(tabId, fieldGroupId, fieldOrder) {
+        const tab = this.getTab(tabId);
+        if (tab) {
+            const fieldGroup = tab.fieldGroups.find((group) => group.id === fieldGroupId);
+            if (fieldGroup) {
+                return tab.order * 10000 + fieldGroup.order * 1000 + fieldOrder;
+            }
+        }
+        return fieldOrder;
+    }
+    withDataTransferConfig(props) {
+        const config = new DataTransferConfig(props, this.getUrl());
+        if (!config.export) {
+            config.withExportUrl(this.getUrl());
+        }
+        if (!config.exportFileName) {
+            config.withExportFileName(this.title?.title ?? this.name);
+        }
+        if (props.fieldNames && props.fieldNames.length > 0) {
+            const dataFields = this.getDataFields(props.fieldNames);
+            if (dataFields.length > 0) {
+                config.setDataFields(dataFields);
+            }
+        }
+        else {
+            // 모든 필드가 export 또는 import 대상이 되어야 한다.
+            // 하지만 이 메소드가 field 가 생성되기 전 호출될 수도 있으므로 여기에서 필드를 조회해서는 안 된다.
+            // export.fields 가 셋팅이 안 된 경우 EntityForm 에서 따로 정보를 가져와야 한다.
+        }
+        this.dataTransferConfig = config;
+        return this;
+    }
+    getDataFields(fieldNames, dataTransferRules) {
+        const dataFields = [];
+        fieldNames.forEach((fieldName) => {
+            const field = this.getField(fieldName);
+            if (field) {
+                const dataField = DataField.create({
+                    name: field.name,
+                    label: field.label !== undefined && typeof field.label === 'string' ? field.label : field.name,
+                    type: field.type,
+                    dataTransferRule: dataTransferRules?.get(field.name),
+                });
+                if (field instanceof OptionalField) {
+                    dataField.withOptions(field.options ?? []);
+                }
+                dataFields.push(dataField);
+            }
+        });
+        return dataFields;
+    }
+    async getExportableFields() {
+        if (this.dataTransferConfig !== undefined) {
+            if (this.dataTransferConfig.isSupportExport()) {
+                // export 를 지원하는 경우에만 필드를 리턴할 수 있다.
+                if (isEmpty(this.dataTransferConfig.export?.fields)) {
+                    return await this.getDataFieldsFromFields();
+                }
+                else {
+                    return this.dataTransferConfig.export?.fields;
+                }
+            }
+        }
+        return undefined;
+    }
+    async getImportableFields() {
+        if (this.dataTransferConfig !== undefined) {
+            if (this.dataTransferConfig.isSupportImport()) {
+                // export 를 지원하는 경우에만 필드를 리턴할 수 있다.
+                if (isEmpty(this.dataTransferConfig.export?.fields)) {
+                    return await this.getDataFieldsFromFields();
+                }
+                else {
+                    return this.dataTransferConfig.import?.fields;
+                }
+            }
+        }
+        return undefined;
+    }
+    async getDataFieldsFromFields() {
+        if (!(this instanceof EntityForm)) {
+            throw new Error('EntityFormActions.getDataFieldsFromFields() can only be called on EntityForm');
+        }
+        const dataFields = [];
+        const fields = [...this.fields.values()];
+        // sort fields by field.order
+        fields.sort((a, b) => a.order - b.order); // sort by order
+        for (const field of fields) {
+            const required = await field.isRequired({ entityForm: this });
+            const dataField = DataField.create({
+                name: field.getName(),
+                label: field.label !== undefined && typeof field.label === 'string'
+                    ? field.label
+                    : field.getName(),
+                type: field.type,
+                options: field instanceof OptionalField ? (field.options ?? []) : undefined,
+                required: required,
+            });
+            dataFields.push(dataField);
+        }
+        // sort dataFields
+        return dataFields;
+    }
+    async getDataTransferConfig() {
+        if (this.dataTransferConfig) {
+            const defaultFields = await this.getDataFieldsFromFields();
+            this.dataTransferConfig.validateDataFields(defaultFields);
+            return this.dataTransferConfig;
+        }
+        return undefined;
+    }
+    withFilterable(fieldName, filterable = true) {
+        const field = this.getField(fieldName);
+        if (field !== undefined && field instanceof ListableFormField) {
+            field.withFilterable(filterable);
+        }
+        return this;
+    }
+    withNeverDelete(neverDelete = true) {
+        this.neverDelete = neverDelete;
+        if (neverDelete) {
+            this.removeField('active');
+            this.addFields({
+                tab: STATUS_TAB_INFO,
+                items: [ActiveField().withModifyOnly()],
+            });
+            this.withOnInitialize(async (entityForm) => {
+                if (entityForm.getRenderType() === 'update') {
+                    const active = await entityForm.getValue('active');
+                    if (isTrue(active, true)) {
+                        entityForm.withHidden('active', true);
+                    }
+                }
+                return entityForm;
+            });
+        }
+        return this;
+    }
+    withStatusCreatedAndUpdatedAtField() {
+        this.addFields(StatusCreatedAndUpdatedAtFieldPreset);
+        return this;
+    }
+    withStatusCreatedAtField() {
+        this.addFields(StatusCreatedAtFieldPreset);
+        return this;
+    }
+    getCreateStep() {
+        if (this.createStep) {
+            const steps = [];
+            for (const step of this.createStep) {
+                if (!isTrue(step.hidden)) {
+                    steps.push(step);
+                }
+            }
+            return steps;
+        }
+        else {
+            return undefined;
+        }
+    }
+    setCreateStep(createStep) {
+        if (createStep) {
+            createStep.sort((a, b) => a.order - b.order);
+        }
+        this.createStep = createStep;
+    }
+    withCreateStep(createStep) {
+        this.setCreateStep(createStep);
+        return this;
+    }
+}

package/dist/listgrid/config/form/EntityFormBase.d.ts

@@ -0,0 +1,204 @@
+import { Session } from '../../auth';
+import { ResponseData } from '../../api';
+import { ReactNode } from 'react';
+import { ListableFormField } from '../../components/fields/abstract';
+import { PostFetchListData } from '../../components/list/types/ViewListGrid.types';
+import { ClientExtensionConfig, ExtensionPoint } from '../../extensions/EntityFormExtension.types';
+import { DataTransferConfig } from '../../transfer/Type';
+import { CreateStep, EntityFormActionResult, FieldGroupConfig, HelpTextType, ManageEntityForm, ModifyEntityFormFunc, ModifyFetchedEntityFormFunc, OnInitializeFunc, RenderType, TooltipType } from '../../config/Config';
+import { EntityField } from '../../config/EntityField';
+import { EntityForm } from '../../config/EntityForm';
+import { EntityFormButtonType } from '../../config/EntityFormButton';
+import { AlertMessage, FieldError } from '../../config/EntityFormTypes';
+import { EntityTab } from '../../config/EntityTab';
+import { SubCollectionField } from '../../config/SubCollectionField';
+import { EntityFieldGroup } from '../../config/EntityFieldGroup';
+import { SelectOption } from '../../form/Type';
+export declare abstract class EntityFormBase<T extends object = any> {
+    constructor(name: string, url: string);
+    version: string;
+    revisionEntityName?: string | undefined;
+    parentId?: string | undefined;
+    id?: string | undefined;
+    name: string;
+    title?: {
+        title?: string;
+        field?: string;
+        view?: (entityForm: EntityForm<T>) => Promise<ReactNode>;
+    } | undefined;
+    url: string;
+    menuUrl?: string | undefined;
+    readonly?: boolean | undefined;
+    session?: Session | undefined;
+    createStep?: CreateStep[] | undefined;
+    manageEntityForm: ManageEntityForm;
+    tabs: Map<string, EntityTab>;
+    fields: Map<string, EntityField>;
+    collections: Map<string, SubCollectionField>;
+    errors?: FieldError[] | undefined;
+    shouldReload?: boolean | undefined;
+    dataPreloaded?: boolean | undefined;
+    fetchedEntity?: T | undefined;
+    alertMessages: AlertMessage[];
+    fieldValidationStates: Map<string, {
+        validated: boolean;
+        message?: string;
+        color?: string;
+    }>;
+    appendAdvancedSearchFields?: ListableFormField<any>[] | undefined;
+    clientExtensions: Map<ExtensionPoint, ClientExtensionConfig[]>;
+    excludeListFields?: string[] | undefined;
+    sessionRequired?: boolean | undefined;
+    cacheKeyFunc?: ((entityForm: EntityForm<T>) => string) | undefined;
+    onChanges?: ModifyEntityFormFunc<T>[] | undefined;
+    onFetchData?: ModifyFetchedEntityFormFunc<T>[] | undefined;
+    onInitialize?: OnInitializeFunc<T>[] | undefined;
+    onFetchListData?: PostFetchListData[] | undefined;
+    onSave?: ((entityForm: EntityForm<T>) => Promise<EntityFormActionResult>) | undefined;
+    postSave?: ((result: EntityFormActionResult) => Promise<void>) | undefined;
+    postDelete?: ((entityForm: EntityForm<T>, idList?: any[]) => Promise<void>) | undefined;
+    overrideSubmitData?: ((entityForm: EntityForm<T>, data: any) => Promise<{
+        data: any;
+        modifiedFields?: string[];
+        removePrevious?: boolean;
+        error?: boolean;
+        errors?: FieldError[];
+    }>) | undefined;
+    /**
+     * Data 를 fetch 할 때 로직을 오버라이드 한다.
+     * overrideFetchData 가 정의되어 있으면 메소드 fetchData 의 최상단에서 오버라이드 된다.
+     */
+    overrideFetchData?: ((url: string, entityForm: EntityForm<T>) => Promise<ResponseData>) | undefined;
+    /**
+     * data upload / download 설정
+     */
+    dataTransferConfig?: DataTransferConfig | undefined;
+    /**
+     * 삭제는 안 되고 active 값만 변경되는 경우
+     * 삭제 모달의 메시지가 변경된다.
+     */
+    neverDelete?: boolean | undefined;
+    /**
+     * EntityForm 상태에 따른 동적 버튼 추가
+     * EntityFormButton 또는 EntityFormReactNodeButton 타입을 반환
+     */
+    buttons?: ((entityForm: EntityForm<T>) => Promise<EntityFormButtonType[]>)[] | undefined;
+    /**
+     * ViewEntityForm 할 때 사용할 수 있다.
+     * 엔티티폼을 커스텀으로 표시하게 하는데 필요한 여러 정보를 자유롭게 사용할 수 있다.
+     * 이 정보는 저장 용도로는 사용되지 않는다.
+     */
+    attributes?: Map<string, unknown> | undefined;
+    /**
+     * ViewEntityForm에서 헤더 버튼과 Alert 영역 사이에 표시될 커스텀 영역
+     * sticky 포지셔닝으로 스크롤 시 상단에 고정됨
+     */
+    headerArea?: ((entityForm: EntityForm<T>) => Promise<ReactNode>) | undefined;
+    reload(): Promise<void>;
+    abstract initialize(props: {
+        session?: Session;
+        list?: boolean;
+    }): Promise<EntityFormActionResult>;
+    abstract clone(includeValue?: boolean): EntityFormBase<T>;
+    withMenuUrl(menuUrl?: string): this;
+    withUrl(url: string): this;
+    withTitle(title?: string | {
+        title?: string;
+        field?: string;
+        view?: (entityForm: EntityForm<T>) => Promise<ReactNode>;
+    }): this;
+    withParentId(parentId?: string): this;
+    withId(id?: string): this;
+    getId(): string | undefined;
+    getRenderType(): RenderType;
+    /**
+     * ID 와 URL 이 모두 존재해야만 FETCH 가 가능하다.
+     */
+    isAbleFetch(): boolean;
+    getUrl(): string;
+    getFetchUrl(): string;
+    isSessionRequired(): boolean;
+    withPostSave(postSave: (result: EntityFormActionResult) => Promise<void>): this;
+    withPostDelete(postDelete: (entityForm: EntityForm<T>, idList?: any[]) => Promise<void>): this;
+    getTitle(append?: string, appendPostfix?: boolean): Promise<string>;
+    private getTitlePostfix;
+    hasField(name: string): boolean;
+    getField<K extends keyof T & string>(name: K): EntityField | undefined;
+    getField(name: string): EntityField | undefined;
+    getCollection(name: string): SubCollectionField | undefined;
+    getValue<K extends keyof T & string>(name: K): Promise<T[K]>;
+    getValue(name: string): Promise<any>;
+    getFetchedEntity(): T | undefined;
+    getValues(): Promise<Partial<T> & Record<string, any>>;
+    hasTab(id: string): boolean;
+    getTab(tabId: string): EntityTab | undefined;
+    getViewableTabs(includeHide?: boolean, createStepFields?: string[], session?: Session): Promise<EntityTab[]>;
+    /**
+     * 모든 탭 목록을 반환합니다 (순서대로 정렬됨)
+     */
+    getTabs(): EntityTab[];
+    /**
+     * 지정한 탭들을 제거합니다
+     * @param tabsToRemove 제거할 탭 배열 또는 탭 ID 배열
+     */
+    removeTabs(tabsToRemove: (EntityTab | string)[]): this;
+    /**
+     * 지정한 탭을 제거합니다
+     * @param tab 제거할 탭 또는 탭 ID
+     */
+    removeTab(tab: EntityTab | string): this;
+    getFieldGroup(tabId: string, fieldGroupId: string): EntityFieldGroup | undefined;
+    getViewableFieldGroups(props: {
+        tabId: string;
+        session?: Session | undefined;
+        createStepFields?: string[] | undefined;
+    }): Promise<string[]>;
+    isViewableFieldGroup(props: {
+        tabId: string;
+        fieldGroupId: string;
+        session?: Session | undefined;
+        createStepFields?: string[] | undefined;
+    }): Promise<boolean>;
+    getVisibleFields(tabId: string, fieldGroupId: string, session?: Session, createStepFields?: string[]): Promise<{
+        fieldGroup?: EntityFieldGroup;
+        fields?: EntityField[];
+    }>;
+    getVisibleCollections(tabId: string, fieldGroupId: string, session?: Session): Promise<{
+        fieldGroup?: EntityFieldGroup;
+        collections?: SubCollectionField[];
+    }>;
+    getSession(): Session | undefined;
+    withSession(session: Session): this;
+    withShouldReload(shouldReload?: boolean): this;
+    withFieldGroupConfig(tabId: string, fieldGroupId: string, config: FieldGroupConfig): this;
+    getLabel(name: string): ReactNode;
+    getHelpText(name: string, session?: Session): Promise<ReactNode>;
+    withHelpText(name: string, helpText: HelpTextType): this;
+    withTooltip(name: string, tooltip: TooltipType): this;
+    withReadonly(name: string, readonly: boolean): this;
+    withOptions(name: string, options: SelectOption[]): this;
+    /**
+     * 특정 tab 의 하위의 모든 fields 를 하나의 [] 로 리턴, 필드그룹의 표시 순서를 고려해 field 의 order 를 변경하며 clone 을 통해 원래 필드에 영향을 주지 않는다.
+     * @param tabId
+     */
+    getTabFields(tabId: string): EntityField[];
+    withRevisionEntityName(revisionEntityName: string): this;
+    getRevisionEntityName(): string;
+    withButtons(buttons: (entityForm: EntityForm<T>) => Promise<EntityFormButtonType[]>): this;
+    withOnChanges(...onChanges: ModifyEntityFormFunc<T>[]): this;
+    withOnFetchData(...onLoad: ModifyFetchedEntityFormFunc<T>[]): this;
+    withOnInitialize(...onInitialize: OnInitializeFunc<T>[]): this;
+    withOnPostFetchListData(...postFetchListData: PostFetchListData[]): this;
+    withOnSave(onSave?: (entityForm: EntityForm<T>) => Promise<EntityFormActionResult>): this;
+    withAttributes(attributes?: Map<string, unknown>): this;
+    withHeaderArea(headerArea: (entityForm: EntityForm<T>) => Promise<ReactNode>): this;
+    getAttributes(): Map<string, unknown>;
+    putAttribute(key: string, value: unknown): this;
+    removeAttribute(key: string): this;
+    hasAttribute(key: string): boolean;
+    addAttributeToField(fieldName: string, key: string, value: unknown): void;
+    removeAttributeToField(fieldName: string, key: string): void;
+    getFieldAttributes(fieldName: string): Map<string, unknown> | undefined;
+    setReadOnly(readonly?: boolean): void;
+    setRevisionEntityNameIfBlank(path: string): void;
+}