@headless-adminapp/app 0.0.17-alpha.57 → 0.0.17-alpha.61

package/app/LayoutProvider.js

@@ -40,6 +40,6 @@ const defaultDataService = {
     },
 };
 const LayoutProvider = ({ authPlaceholder, authProps, dataService = defaultDataService, fileService, localeProps, metadataProps, queryClient = defaults_1.queryClient, routeProps, children, containers: { DialogContainer, ProgressIndicatorContainer, ToastNotificationContainer, }, }) => {
-    return ((0, jsx_runtime_1.jsx)(route_1.RouteProvider, { ...routeProps, children: (0, jsx_runtime_1.jsx)(react_query_1.QueryClientProvider, { client: queryClient, children: (0, jsx_runtime_1.jsx)(locale_1.LocaleProvider, { ...localeProps, children: (0, jsx_runtime_1.jsx)(metadata_1.MetadataProvider, { ...metadataProps, children: (0, jsx_runtime_1.jsx)(transport_1.DataServiceContext.Provider, { value: dataService, children: (0, jsx_runtime_1.jsx)(context_1.FileServiceContext.Provider, { value: fileService ?? context_1.noopFileService, children: (0, jsx_runtime_1.jsx)(dialog_1.DialogProvider, { children: (0, jsx_runtime_1.jsx)(progress_indicator_1.ProgressIndicatorProvider, { children: (0, jsx_runtime_1.jsxs)(toast_notification_1.ToastNotificationProvider, { children: [(0, jsx_runtime_1.jsx)(DialogContainer, {}), (0, jsx_runtime_1.jsx)(ProgressIndicatorContainer, {}), (0, jsx_runtime_1.jsx)(ToastNotificationContainer, {}), (0, jsx_runtime_1.jsx)(auth_1.AuthProvider, { ...authProps, children: (0, jsx_runtime_1.jsx)(AuthWrapper_1.AuthWrapper, { Placeholder: authPlaceholder, children: (0, jsx_runtime_1.jsx)(recordset_1.RecordSetProvider, { children: children }) }) })] }) }) }) }) }) }) }) }) }));
+    return ((0, jsx_runtime_1.jsx)(route_1.RouteProvider, { ...routeProps, children: (0, jsx_runtime_1.jsx)(react_query_1.QueryClientProvider, { client: queryClient, children: (0, jsx_runtime_1.jsx)(locale_1.LocaleProvider, { ...localeProps, children: (0, jsx_runtime_1.jsx)(metadata_1.MetadataProvider, { ...metadataProps, children: (0, jsx_runtime_1.jsx)(transport_1.DataServiceContext.Provider, { value: dataService, children: (0, jsx_runtime_1.jsx)(context_1.FileServiceContext.Provider, { value: fileService ?? null, children: (0, jsx_runtime_1.jsx)(dialog_1.DialogProvider, { children: (0, jsx_runtime_1.jsx)(progress_indicator_1.ProgressIndicatorProvider, { children: (0, jsx_runtime_1.jsxs)(toast_notification_1.ToastNotificationProvider, { children: [(0, jsx_runtime_1.jsx)(DialogContainer, {}), (0, jsx_runtime_1.jsx)(ProgressIndicatorContainer, {}), (0, jsx_runtime_1.jsx)(ToastNotificationContainer, {}), (0, jsx_runtime_1.jsx)(auth_1.AuthProvider, { ...authProps, children: (0, jsx_runtime_1.jsx)(AuthWrapper_1.AuthWrapper, { Placeholder: authPlaceholder, children: (0, jsx_runtime_1.jsx)(recordset_1.RecordSetProvider, { children: children }) }) })] }) }) }) }) }) }) }) }) }));
 };
 exports.LayoutProvider = LayoutProvider;

package/dataform/DataFormProvider/CustomHookExecuter.d.ts

@@ -0,0 +1,5 @@
+interface CustomHookExecuterProps {
+    useHookFn: (() => void) | undefined | null;
+}
+export declare function CustomHookExecuter({ useHookFn, }: Readonly<CustomHookExecuterProps>): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dataform/DataFormProvider/CustomHookExecuter.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomHookExecuter = CustomHookExecuter;
+const jsx_runtime_1 = require("react/jsx-runtime");
+function CustomHookExecuter({ useHookFn, }) {
+    if (!useHookFn) {
+        return null;
+    }
+    return (0, jsx_runtime_1.jsx)(CustomHookExecuterInternal, { useHookFn: useHookFn });
+}
+function CustomHookExecuterInternal({ useHookFn, }) {
+    useHookFn();
+    return null;
+}

package/dataform/DataFormProvider/DataResolver.d.ts

@@ -1,5 +1,7 @@
-import { Form } from '@headless-adminapp/core/experience/form';
-import { Schema, SchemaAttributes } from '@headless-adminapp/core/schema';
-export declare function getControls(form: Form): (import("@headless-adminapp/core/experience/form/SectionControl").SectionSubgridControl | import("@headless-adminapp/core/experience/form/SectionControl").SectionQuickViewControl<SchemaAttributes> | import("@headless-adminapp/core/experience/form").SectionEditableGridControl<SchemaAttributes> | import("@headless-adminapp/core/experience/form/SectionControl").SectionSpacerControl | import("@headless-adminapp/core/experience/form/SectionControl").SectionStatndardControl<SchemaAttributes>)[];
-export declare function getColumns(form: Form, schema: Schema): string[];
-export declare function DataResolver(): null;
+import { SchemaAttributes } from '@headless-adminapp/core/schema';
+import { RetriveRecordFn } from './types';
+interface DataResolverProps<SA extends SchemaAttributes> {
+    retriveRecordFn: RetriveRecordFn<SA>;
+}
+export declare function DataResolver<SA extends SchemaAttributes>({ retriveRecordFn, }: DataResolverProps<SA>): null;
+export {};

package/dataform/DataFormProvider/DataResolver.js

@@ -1,96 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getControls = getControls;
-exports.getColumns = getColumns;
 exports.DataResolver = DataResolver;
-const transport_1 = require("@headless-adminapp/core/transport");
 const react_query_1 = require("@tanstack/react-query");
 const react_1 = require("react");
 const hooks_1 = require("../../metadata/hooks");
 const mutable_1 = require("../../mutable");
-const transport_2 = require("../../transport");
+const transport_1 = require("../../transport");
 const context_1 = require("../context");
 const hooks_2 = require("../hooks");
-function getControls(form) {
-    const controls = form.experience.tabs
-        .flatMap((tab) => tab.tabColumns)
-        .flatMap((tabColumn) => tabColumn.sections)
-        .flatMap((section) => section.controls);
-    return controls;
-}
-function getColumns(form, schema) {
-    const set = new Set([
-        ...(form.experience.includeAttributes ?? []),
-        ...(form.experience.headerControls ?? []),
-        ...getControls(form)
-            .filter((control) => control.type === 'standard')
-            .map((control) => control.attributeName),
-    ]);
-    if (schema.avatarAttribute) {
-        set.add(schema.avatarAttribute);
-    }
-    const columns = Array.from(set);
-    return columns;
-}
-async function getRecord({ recordId, dataService, form, schema, columns, schemaStore, }) {
-    let record = null;
-    try {
-        record = await dataService.retriveRecord(schema.logicalName, recordId, columns);
-    }
-    catch (error) {
-        if (error instanceof transport_1.HttpError && error.status === 404) {
-            return null;
-        }
-        throw error;
-    }
-    if (!record) {
-        return null;
-    }
-    const controls = getControls(form);
-    const editableGridControls = controls.filter((control) => control.type === 'editablegrid');
-    for (const control of editableGridControls) {
-        if (control.type !== 'editablegrid') {
-            continue;
-        }
-        const controlSchema = schemaStore.getSchema(control.logicalName);
-        const records = await dataService.retriveRecords({
-            logicalName: controlSchema.logicalName,
-            filter: {
-                type: 'and',
-                conditions: [
-                    {
-                        field: control.referenceAttribute,
-                        operator: 'eq',
-                        value: recordId,
-                    },
-                ],
-            },
-            sort: [
-                {
-                    field: controlSchema.createdAtAttribute ?? controlSchema.idAttribute,
-                    order: 'asc',
-                },
-            ],
-            limit: 5000,
-            search: '',
-            columns: [
-                controlSchema.idAttribute,
-                control.referenceAttribute,
-                ...control.attributes,
-            ],
-        });
-        record[control.attributeName] = records.records;
-    }
-    return record;
-}
-function DataResolver() {
+const utils_1 = require("./utils");
+function DataResolver({ retriveRecordFn, }) {
     const schema = (0, hooks_2.useDataFormSchema)();
     const form = (0, hooks_2.useSelectedForm)();
-    const dataService = (0, transport_2.useDataService)();
+    const dataService = (0, transport_1.useDataService)();
     const recordId = (0, hooks_2.useRecordId)();
     const { schemaStore } = (0, hooks_1.useMetadata)();
     const setState = (0, mutable_1.useContextSetValue)(context_1.DataFormContext);
-    const columns = (0, react_1.useMemo)(() => getColumns(form, schema), [form, schema]);
+    const columns = (0, react_1.useMemo)(() => (0, utils_1.getColumns)(form, schema), [form, schema]);
     const queryKey = (0, react_1.useMemo)(() => ['data', 'retriveRecord', schema.logicalName, recordId, columns], [columns, recordId, schema.logicalName]);
     const { data, refetch, isPending } = (0, react_query_1.useQuery)({
         queryKey,
@@ -98,7 +24,7 @@ function DataResolver() {
             if (!recordId) {
                 return null;
             }
-            const record = getRecord({
+            const record = retriveRecordFn({
                 columns,
                 dataService,
                 form,

package/dataform/DataFormProvider/InitialValueResolver.js

@@ -14,7 +14,7 @@ function InitialValueResolver() {
     const record = (0, mutable_1.useContextSelector)(context_1.DataFormContext, (state) => state.record);
     const formInstance = (0, hooks_1.useFormInstance)();
     const initialValues = (0, react_1.useMemo)(() => {
-        const defaultParameters = (0, defaultParameters_1.getFormDefaultParameters)(schema) ?? {};
+        const defaultParameters = (0, defaultParameters_1.getFormDefaultParameters)(schema, formConfig.experience) ?? {};
         return (0, utils_1.getInitialValues)({
             cloneRecord: undefined,
             form: formConfig,

package/dataform/DataFormProvider/getRecord.d.ts

@@ -0,0 +1,3 @@
+import { SchemaAttributes } from '@headless-adminapp/core/schema';
+import { RetriveRecordFnOptions } from './types';
+export declare function getRecord<SA extends SchemaAttributes = SchemaAttributes>({ recordId, dataService, form, schema, columns, schemaStore, }: RetriveRecordFnOptions<SA>): Promise<import("@headless-adminapp/core/transport").Data<SA> | null>;

package/dataform/DataFormProvider/getRecord.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRecord = getRecord;
+const transport_1 = require("@headless-adminapp/core/transport");
+const utils_1 = require("./utils");
+async function getRecord({ recordId, dataService, form, schema, columns, schemaStore, }) {
+    let record = null;
+    try {
+        record = await dataService.retriveRecord(schema.logicalName, recordId, columns);
+    }
+    catch (error) {
+        if (error instanceof transport_1.HttpError && error.status === 404) {
+            return null;
+        }
+        throw error;
+    }
+    if (!record) {
+        return null;
+    }
+    const controls = (0, utils_1.getControls)(form);
+    const editableGridControls = controls.filter((control) => control.type === 'editablegrid');
+    for (const control of editableGridControls) {
+        if (control.type !== 'editablegrid') {
+            continue;
+        }
+        const controlSchema = schemaStore.getSchema(control.logicalName);
+        const records = await dataService.retriveRecords({
+            logicalName: controlSchema.logicalName,
+            filter: {
+                type: 'and',
+                conditions: [
+                    {
+                        field: control.referenceAttribute,
+                        operator: 'eq',
+                        value: recordId,
+                    },
+                ],
+            },
+            sort: [
+                {
+                    field: controlSchema.createdAtAttribute ?? controlSchema.idAttribute,
+                    order: 'asc',
+                },
+            ],
+            limit: 5000,
+            search: '',
+            columns: [
+                controlSchema.idAttribute,
+                control.referenceAttribute,
+                ...control.attributes,
+            ],
+        });
+        record[control.attributeName] = records.records;
+    }
+    return record;
+}

package/dataform/DataFormProvider/index.d.ts

@@ -1,10 +1,14 @@
 import { EntityMainFormCommandItemExperience, Form } from '@headless-adminapp/core/experience/form';
 import { Schema, SchemaAttributes } from '@headless-adminapp/core/schema';
 import { PropsWithChildren } from 'react';
+import { SaveRecordFn } from '../utils/saveRecord';
+import { RetriveRecordFn } from './types';
 export interface DataFormProviderProps<S extends SchemaAttributes = SchemaAttributes> {
     schema: Schema<S>;
     form: Form<S>;
     recordId?: string;
     commands: EntityMainFormCommandItemExperience[][];
+    retriveRecordFn?: RetriveRecordFn<S>;
+    saveRecordFn?: SaveRecordFn;
 }
 export declare function DataFormProvider<S extends SchemaAttributes = SchemaAttributes>(props: PropsWithChildren<DataFormProviderProps<S>>): import("react/jsx-runtime").JSX.Element;

package/dataform/DataFormProvider/index.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataFormProvider = DataFormProvider;
 const jsx_runtime_1 = require("react/jsx-runtime");
+const store_1 = require("@headless-adminapp/app/store");
 const react_1 = require("react");
 const react_hook_form_1 = require("react-hook-form");
 const FormValidationStringContext_1 = require("../../form/FormValidationStringContext");
@@ -10,13 +11,19 @@ const useMetadata_1 = require("../../metadata/hooks/useMetadata");
 const mutable_1 = require("../../mutable");
 const context_1 = require("../context");
 const utils_1 = require("../utils");
+const saveRecord_1 = require("../utils/saveRecord");
+const CustomHookExecuter_1 = require("./CustomHookExecuter");
 const DataResolver_1 = require("./DataResolver");
+const getRecord_1 = require("./getRecord");
 const InitialValueResolver_1 = require("./InitialValueResolver");
 const ReadonlyInfoResolver_1 = require("./ReadonlyInfoResolver");
+const utils_2 = require("./utils");
 function DataFormProvider(props) {
     const { schemaStore } = (0, useMetadata_1.useMetadata)();
-    const { language } = (0, useLocale_1.useLocale)();
+    const { language, region } = (0, useLocale_1.useLocale)();
     const formValidationStrings = (0, FormValidationStringContext_1.useFormValidationStrings)();
+    const eventManager = (0, react_1.useMemo)(() => new store_1.EventManager(), []);
+    const contextKey = (0, react_1.useRef)(0);
     const [formReadOnly, setFormReadOnly] = (0, react_1.useState)(false); // A trick to provide readOnly info to formInstance
     const formInstance = (0, react_hook_form_1.useForm)({
         mode: 'all',
@@ -28,10 +35,19 @@ function DataFormProvider(props) {
             schema: props.schema,
             strings: formValidationStrings,
             formReadOnly,
+            region,
         }),
         shouldUnregister: false,
     });
+    const saveRecordFnRef = (0, react_1.useRef)(props.saveRecordFn);
+    saveRecordFnRef.current = props.saveRecordFn;
+    const saveRecordFnInternal = (0, react_1.useCallback)(async (options) => {
+        return saveRecordFnRef.current
+            ? saveRecordFnRef.current(options)
+            : (0, saveRecord_1.saveRecord)(options);
+    }, []);
     const contextValue = (0, mutable_1.useCreateContextStore)({
+        contextKey: contextKey.current,
         schema: props.schema,
         form: props.form,
         commands: props.commands,
@@ -42,14 +58,29 @@ function DataFormProvider(props) {
         // formInstance,
         // formInstanceRenderCount: 0,
         initialValues: {},
+        saveRecordFn: saveRecordFnInternal,
+        eventManager,
+        disabledControls: {},
+        requiredFields: {},
+        hiddenControls: {},
+        hiddenSections: {},
+        hiddenTabs: {},
+        formInternal: (0, utils_2.transformFormInternal)(props.form),
     });
     (0, react_1.useEffect)(() => {
         contextValue.setValue({
+            contextKey: ++contextKey.current,
             form: props.form,
             schema: props.schema,
             recordId: props.recordId,
             cloneId: undefined,
             commands: props.commands,
+            disabledControls: {},
+            requiredFields: {},
+            hiddenControls: {},
+            hiddenSections: {},
+            hiddenTabs: {},
+            formInternal: (0, utils_2.transformFormInternal)(props.form),
         });
     }, [
         props.form,
@@ -59,5 +90,5 @@ function DataFormProvider(props) {
         schemaStore,
         props.commands,
     ]);
-    return ((0, jsx_runtime_1.jsx)(context_1.DataFormContext.Provider, { value: contextValue, children: (0, jsx_runtime_1.jsxs)(react_hook_form_1.FormProvider, { ...formInstance, children: [(0, jsx_runtime_1.jsx)(DataResolver_1.DataResolver, {}), (0, jsx_runtime_1.jsx)(InitialValueResolver_1.InitialValueResolver, {}), (0, jsx_runtime_1.jsx)(ReadonlyInfoResolver_1.ReadonlyInfoResolver, { setFormReadOnly: setFormReadOnly }), props.children] }) }));
+    return ((0, jsx_runtime_1.jsx)(context_1.DataFormContext.Provider, { value: contextValue, children: (0, jsx_runtime_1.jsxs)(react_hook_form_1.FormProvider, { ...formInstance, children: [(0, jsx_runtime_1.jsx)(DataResolver_1.DataResolver, { retriveRecordFn: props.retriveRecordFn ?? getRecord_1.getRecord }), (0, jsx_runtime_1.jsx)(InitialValueResolver_1.InitialValueResolver, {}), (0, jsx_runtime_1.jsx)(ReadonlyInfoResolver_1.ReadonlyInfoResolver, { setFormReadOnly: setFormReadOnly }), (0, jsx_runtime_1.jsx)(CustomHookExecuter_1.CustomHookExecuter, { useHookFn: props.form.experience.useHookFn }), props.children] }) }));
 }

package/dataform/DataFormProvider/types.d.ts

@@ -0,0 +1,13 @@
+import { Form } from '@headless-adminapp/core/experience/form';
+import { InferredSchemaType, Schema, SchemaAttributes } from '@headless-adminapp/core/schema';
+import { ISchemaStore } from '@headless-adminapp/core/store';
+import { Data, IDataService } from '@headless-adminapp/core/transport';
+export type RetriveRecordFnOptions<SA extends SchemaAttributes> = {
+    recordId: string;
+    dataService: IDataService;
+    form: Form<SA>;
+    schema: Schema<SA>;
+    columns: (keyof SA)[];
+    schemaStore: ISchemaStore;
+};
+export type RetriveRecordFn<SA extends SchemaAttributes> = (options: RetriveRecordFnOptions<SA>) => Promise<Data<InferredSchemaType<SA>>>;

package/dataform/DataFormProvider/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dataform/DataFormProvider/utils.d.ts

@@ -0,0 +1,23 @@
+import { AttributeBase } from '@headless-adminapp/core/attributes/AttributeBase';
+import { Form, Section } from '@headless-adminapp/core/experience/form';
+import { SectionControl, SectionStatndardControl } from '@headless-adminapp/core/experience/form/SectionControl';
+import { Schema, SchemaAttributes } from '@headless-adminapp/core/schema';
+import { DataFormContextState } from '../context';
+export declare function getControls<SA extends SchemaAttributes>(form: Form<SA>): SectionControl<SA>[];
+export declare function getColumns<SA extends SchemaAttributes>(form: Form<SA>, schema: Schema<SA>): (keyof SA)[];
+export declare function transformFormInternal<SA extends SchemaAttributes>(form: Form<SA>): DataFormContextState<SA>['formInternal'];
+export declare function getIsFieldDisabled<S extends SchemaAttributes = SchemaAttributes>({ attribute, isFormReadonly, disabledFields, control, }: {
+    attribute: AttributeBase;
+    isFormReadonly: boolean | undefined;
+    disabledFields: Record<string, boolean>;
+    control: Section<S>['controls'][0];
+}): boolean;
+export declare function getIsControlHidden<S extends SchemaAttributes = SchemaAttributes>({ control, hiddenControls, }: {
+    hiddenControls: Record<string, boolean>;
+    control: Section<S>['controls'][0];
+}): boolean;
+export declare function getIsFieldRequired<S extends SchemaAttributes = SchemaAttributes>({ attribute, control, requiredFields, }: {
+    attribute: AttributeBase;
+    requiredFields: Record<string, boolean>;
+    control: SectionStatndardControl<S>;
+}): boolean;

package/dataform/DataFormProvider/utils.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getControls = getControls;
+exports.getColumns = getColumns;
+exports.transformFormInternal = transformFormInternal;
+exports.getIsFieldDisabled = getIsFieldDisabled;
+exports.getIsControlHidden = getIsControlHidden;
+exports.getIsFieldRequired = getIsFieldRequired;
+function getControls(form) {
+    const controls = form.experience.tabs
+        .flatMap((tab) => tab.tabColumns)
+        .flatMap((tabColumn) => tabColumn.sections)
+        .flatMap((section) => section.controls);
+    return controls;
+}
+function getColumns(form, schema) {
+    const set = new Set([
+        ...(form.experience.includeAttributes ?? []),
+        ...(form.experience.headerControls ?? []),
+        ...getControls(form)
+            .filter((control) => control.type === 'standard')
+            .map((control) => control.attributeName),
+    ]);
+    if (schema.avatarAttribute) {
+        set.add(schema.avatarAttribute);
+    }
+    const columns = Array.from(set);
+    return columns;
+}
+function transformFormInternal(form) {
+    const controls = getControls(form);
+    const dict = controls.reduce((acc, control) => {
+        let key = control.key;
+        if (!key && control.type === 'standard') {
+            key = control.attributeName;
+        }
+        if (key) {
+            acc[key] = control;
+        }
+        return acc;
+    }, {});
+    const sections = form.experience.tabs
+        .flatMap((tab) => tab.tabColumns)
+        .flatMap((tabColumn) => tabColumn.sections);
+    const dictBySectionKey = sections.reduce((acc, section) => {
+        acc[section.name] = section;
+        return acc;
+    }, {});
+    const tabsDict = form.experience.tabs.reduce((acc, tab) => {
+        acc[tab.name] = tab;
+        return acc;
+    }, {});
+    return {
+        controls: {
+            list: controls,
+            dict,
+        },
+        sections: {
+            list: sections,
+            dict: dictBySectionKey,
+        },
+        tabs: {
+            dict: tabsDict,
+        },
+    };
+}
+function getIsFieldDisabled({ attribute, isFormReadonly, disabledFields, control, }) {
+    let disabled = isFormReadonly ?? false;
+    if (!disabled) {
+        if (control.type === 'standard' &&
+            typeof control.attributeName === 'string' &&
+            disabledFields[control.attributeName] !== undefined) {
+            disabled = disabledFields[control.attributeName];
+        }
+        else if (control.disabled !== undefined) {
+            disabled = control.disabled;
+        }
+        else if (attribute.readonly !== undefined) {
+            disabled = attribute.readonly;
+        }
+    }
+    return disabled;
+}
+function getIsControlHidden({ control, hiddenControls, }) {
+    let hidden = control.hidden ?? false;
+    let key = control.key;
+    if (!key && control.type === 'standard') {
+        key = control.attributeName;
+    }
+    if (key && hiddenControls[key] !== undefined) {
+        hidden = hiddenControls[key];
+    }
+    return hidden;
+}
+function getIsFieldRequired({ attribute, control, requiredFields, }) {
+    const attributeName = control.attributeName;
+    let required = attribute.required ?? false;
+    if (requiredFields[attributeName] !== undefined) {
+        required = requiredFields[attributeName];
+    }
+    else if (control.required !== undefined) {
+        required = control.required;
+    }
+    return required;
+}

package/dataform/FormManager.d.ts

@@ -0,0 +1,57 @@
+import { Attribute } from '@headless-adminapp/core';
+import { Section } from '@headless-adminapp/core/experience/form';
+import { SectionControl } from '@headless-adminapp/core/experience/form/SectionControl';
+import { Tab } from '@headless-adminapp/core/experience/form/Tab';
+import { SchemaAttributes } from '@headless-adminapp/core/schema';
+import { ContextValue } from '../mutable';
+import { DataFormContextState } from './context';
+export declare class FormManager<SA extends SchemaAttributes = SchemaAttributes> {
+    private readonly contextState;
+    constructor(contextState: ContextValue<DataFormContextState<SA>>);
+    private get context();
+    getAttribute(attributeName: keyof SA): FormAttribute<SA> | null;
+    getControl<C extends Control<SA>>(name: string): C | null;
+    getSection(name: string): FormSection<SA> | null;
+    getTab(name: string): FormTab<SA> | null;
+}
+declare class FormAttribute<SA extends SchemaAttributes = SchemaAttributes> {
+    private readonly contextState;
+    private readonly attributeName;
+    private readonly attribute;
+    constructor(contextState: ContextValue<DataFormContextState<SA>>, attributeName: keyof SA, attribute: Attribute);
+    getInnerAttribute(): Attribute;
+    setRequired(state: boolean): void;
+    getRequired(): boolean;
+    resetRequired(): void;
+    getControls(): Control<SA>[];
+}
+declare class Control<SA extends SchemaAttributes = SchemaAttributes> {
+    private readonly contextState;
+    private readonly control;
+    constructor(contextState: ContextValue<DataFormContextState<SA>>, control: SectionControl<SA>);
+    private get context();
+    getKey(): string | undefined;
+    getDisabled(): boolean;
+    setDisabled(state: boolean): void;
+    resetDisabled(): void;
+    getHidden(): boolean;
+    setHidden(state: boolean): void;
+    resetHidden(): void;
+}
+declare class FormSection<SA extends SchemaAttributes = SchemaAttributes> {
+    private readonly contextState;
+    private readonly section;
+    constructor(contextState: ContextValue<DataFormContextState<SA>>, section: Section<SA>);
+    setHidden(state: boolean): void;
+    getHidden(): boolean;
+    resetHidden(): void;
+}
+declare class FormTab<SA extends SchemaAttributes = SchemaAttributes> {
+    private readonly contextState;
+    private readonly tab;
+    constructor(contextState: ContextValue<DataFormContextState<SA>>, tab: Tab<SA>);
+    setHidden(state: boolean): void;
+    getHidden(): boolean;
+    resetHidden(): void;
+}
+export {};