@akbarsafari00/bonyan-content-type-builder 5.52.1-fa.2

package/dist/admin/src/components/FormModal/dynamiczoneForm.d.ts

@@ -0,0 +1,68 @@
+export declare const dynamiczoneForm: {
+    advanced: {
+        default(): {
+            sections: unknown[];
+        };
+    };
+    base: {
+        createComponent(): {
+            sections: {
+                sectionTitle: null;
+                items: {
+                    name: string;
+                    type: string;
+                    intlLabel: {
+                        id: string;
+                        defaultMessage: string;
+                    };
+                }[];
+            }[];
+        };
+        default(): {
+            sections: ({
+                sectionTitle: null;
+                items: {
+                    intlLabel: {
+                        id: string;
+                        defaultMessage: string;
+                    };
+                    name: string;
+                    type: string;
+                    size: number;
+                    radios: {
+                        title: {
+                            id: string;
+                            defaultMessage: string;
+                        };
+                        description: {
+                            id: string;
+                            defaultMessage: string;
+                        };
+                        value: boolean;
+                    }[];
+                }[];
+            } | {
+                sectionTitle: null;
+                items: ({
+                    type: string;
+                    size: number;
+                    intlLabel: {
+                        id: string;
+                        defaultMessage: string;
+                    };
+                    name: string;
+                    isMultiple?: undefined;
+                } | {
+                    name: string;
+                    type: string;
+                    intlLabel: {
+                        id: string;
+                        defaultMessage: string;
+                    };
+                    isMultiple: boolean;
+                    size?: undefined;
+                })[];
+            })[];
+        };
+    };
+};

package/dist/admin/src/components/FormModal/forms/forms.d.ts

@@ -0,0 +1,204 @@
+import { attributesForm } from '../attributes/form';
+import { attributeTypes } from '../attributes/types';
+import { addItemsToFormSection, FormTypeOptions } from './utils/addItemsToFormSection';
+import { Attribute, SchemaData } from './utils/getUsedAttributeNames';
+import type { Component, ContentType } from '../../../types';
+import type { FormAPI } from '../../../utils/formAPI';
+import type { FormModalData } from '../reducer';
+import type { Internal } from '@strapi/types';
+type AttributeType = keyof typeof attributeTypes;
+type CustomFieldFormOptions = Parameters<typeof addItemsToFormSection>[0];
+type CustomFieldValidator = Parameters<FormAPI['makeCustomFieldValidator']>[1];
+type CustomField = {
+    type: AttributeType;
+    options?: {
+        base?: CustomFieldFormOptions;
+        advanced?: CustomFieldFormOptions;
+        validator?: CustomFieldValidator;
+    };
+};
+export type SchemaParams = {
+    schemaAttributes: Attribute[];
+    attributeType: AttributeType;
+    customFieldValidator: CustomFieldValidator;
+    reservedNames: {
+        attributes: Array<string>;
+    };
+    schemaData: SchemaData;
+    ctbFormsAPI: FormAPI;
+};
+type Base<TAttributesFormType extends 'base' | 'advanced'> = {
+    data: FormModalData;
+    type: keyof (typeof attributesForm)[TAttributesFormType];
+    step: string | null;
+    attributes: Attribute[];
+    extensions: FormAPI;
+    forTarget: string;
+};
+type CustomFieldFormParams = {
+    customField: CustomField;
+    data?: FormModalData;
+    step?: string | null;
+    extensions: FormAPI;
+} & Record<string, unknown>;
+export declare const forms: {
+    customField: {
+        schema({ schemaAttributes, attributeType, customFieldValidator, reservedNames, schemaData, ctbFormsAPI, }: SchemaParams): import("yup/lib/object").OptionalObjectSchema<import("yup/lib/object").ObjectShape, Record<string, any>, import("yup/lib/object").TypeOfShape<import("yup/lib/object").ObjectShape>>;
+        form: {
+            base({ customField }: Pick<CustomFieldFormParams, "customField">): {
+                sections: FormTypeOptions;
+            };
+            advanced({ customField, data, step, extensions, ...rest }: CustomFieldFormParams): {
+                sections: FormTypeOptions;
+            };
+        };
+    };
+    attribute: {
+        schema(currentSchema: {
+            attributes?: Attribute[];
+        } | null | undefined, attributeType: AttributeType, reservedNames: {
+            attributes: Array<string>;
+        }, alreadyTakenTargetContentTypeAttributes: Array<Attribute>, options: SchemaData, extensions: {
+            makeValidator: FormAPI["makeValidator"];
+        }): import("yup/lib/object").OptionalObjectSchema<import("yup/lib/object").ObjectShape, Record<string, any>, import("yup/lib/object").TypeOfShape<import("yup/lib/object").ObjectShape>> | import("yup/lib/object").OptionalObjectSchema<{
+            name: import("yup/lib/string").RequiredStringSchema<string | undefined, Record<string, any>>;
+            type: import("yup/lib/string").RequiredStringSchema<string | undefined, Record<string, any>>;
+        }, Record<string, any>, import("yup/lib/object").TypeOfShape<{
+            name: import("yup/lib/string").RequiredStringSchema<string | undefined, Record<string, any>>;
+            type: import("yup/lib/string").RequiredStringSchema<string | undefined, Record<string, any>>;
+        }>>;
+        form: {
+            advanced({ data, type, step, extensions, ...rest }: Base<"advanced">): {
+                sections: FormTypeOptions;
+            };
+            base({ data, type, step, attributes }: Base<"base">): {
+                sections: {
+                    sectionTitle: null;
+                    items: {
+                        name: string;
+                        type: string;
+                        intlLabel: {
+                            id: string;
+                            defaultMessage: string;
+                        };
+                    }[];
+                }[];
+            };
+        };
+    };
+    contentType: {
+        schema(alreadyTakenNames: Array<string>, isEditing: boolean, ctUid: Internal.UID.ContentType, reservedNames: {
+            models: string[];
+        }, extensions: FormAPI, contentTypes: Record<Internal.UID.ContentType, ContentType>): import("yup/lib/object").OptionalObjectSchema<import("yup/lib/object").ObjectShape, Record<string, any>, import("yup/lib/object").TypeOfShape<import("yup/lib/object").ObjectShape>>;
+        form: {
+            base({ actionType }: {
+                actionType?: string;
+            }): {
+                sections: {
+                    sectionTitle: null;
+                    items: ({
+                        name: string;
+                        type: string;
+                        intlLabel: {
+                            id: string;
+                            defaultMessage: string;
+                        };
+                    } | {
+                        description: {
+                            id: string;
+                            defaultMessage: string;
+                        };
+                        intlLabel: {
+                            id: string;
+                            defaultMessage: string;
+                        };
+                        name: string;
+                        type: string;
+                        size?: undefined;
+                    } | {
+                        type: string;
+                        size: number;
+                        intlLabel: {
+                            id: string;
+                            defaultMessage: string;
+                        };
+                        name: string;
+                        description?: undefined;
+                    })[];
+                }[];
+            };
+            advanced({ extensions }: {
+                extensions: FormAPI;
+            }): {
+                sections: {
+                    items: unknown[];
+                }[];
+            };
+        };
+    };
+    component: {
+        schema(alreadyTakenAttributes: Array<Internal.UID.Component>, componentCategory: string, reservedNames: {
+            models: string[];
+        }, isEditing: boolean | undefined, components: Record<Internal.UID.Component, Component>, componentDisplayName: string, compoUid?: Internal.UID.Component | null): import("yup/lib/object").OptionalObjectSchema<{
+            displayName: import("yup/lib/string").RequiredStringSchema<string | undefined, Record<string, any>>;
+            category: import("yup/lib/string").RequiredStringSchema<string | undefined, Record<string, any>>;
+            icon: import("yup").StringSchema<string | undefined, Record<string, any>, string | undefined>;
+        }, Record<string, any>, import("yup/lib/object").TypeOfShape<{
+            displayName: import("yup/lib/string").RequiredStringSchema<string | undefined, Record<string, any>>;
+            category: import("yup/lib/string").RequiredStringSchema<string | undefined, Record<string, any>>;
+            icon: import("yup").StringSchema<string | undefined, Record<string, any>, string | undefined>;
+        }>>;
+        form: {
+            advanced(): {
+                sections: unknown[];
+            };
+            base(): {
+                sections: ({
+                    sectionTitle: null;
+                    items: {
+                        name: string;
+                        type: string;
+                        intlLabel: {
+                            id: string;
+                            defaultMessage: string;
+                        };
+                    }[];
+                } | {
+                    sectionTitle: null;
+                    items: {
+                        name: string;
+                        type: string;
+                        size: number;
+                        intlLabel: {
+                            id: string;
+                            defaultMessage: string;
+                        };
+                    }[];
+                })[];
+            };
+        };
+    };
+    addComponentToDynamicZone: {
+        form: {
+            advanced(): {
+                sections: unknown[];
+            };
+            base({ data }: {
+                data: FormModalData;
+            }): {
+                sections: {
+                    sectionTitle: null;
+                    items: {
+                        name: string;
+                        type: string;
+                        intlLabel: {
+                            id: string;
+                            defaultMessage: string;
+                        };
+                    }[];
+                }[];
+            };
+        };
+    };
+};
+export {};

package/dist/admin/src/components/FormModal/forms/utils/addItemsToFormSection.d.ts

@@ -0,0 +1,38 @@
+type SectionTitle = {
+    id: string;
+    defaultMessage: string;
+};
+type Item = {
+    intlLabel: {
+        id: string;
+        defaultMessage: string;
+    };
+    description?: {
+        id: string;
+        defaultMessage: string;
+    };
+    name: string;
+    type: string;
+    value?: string;
+    options?: {
+        key: string;
+        value: string;
+        metadatas: {
+            intlLabel: {
+                id: string;
+                defaultMessage: string;
+            };
+        };
+    }[];
+};
+type FormTypeOption = {
+    sectionTitle: SectionTitle | null;
+    items: Item[];
+};
+export type FormTypeOptions = Array<FormTypeOption>;
+/**
+ * @description
+ * Adds form options to the default section or as a new section
+ */
+export declare const addItemsToFormSection: (formTypeOptions: FormTypeOptions | Item[], sections: FormTypeOptions) => void;
+export {};

package/dist/admin/src/components/FormModal/forms/utils/createCollectionName.d.ts

@@ -0,0 +1,2 @@
+declare const createComponentCollectionName: (name: string, category: string) => string;
+export { createComponentCollectionName };

package/dist/admin/src/components/FormModal/forms/utils/getUsedAttributeNames.d.ts

@@ -0,0 +1,22 @@
+export type SchemaData = {
+    initialData: {
+        name?: string;
+        targetAttribute?: string | null;
+        [key: string]: unknown;
+    };
+    modifiedData: {
+        createComponent?: boolean;
+        enum?: string[];
+        name?: string;
+        relation?: string;
+        repeatable?: boolean;
+        targetAttribute?: string | null;
+        targetField?: string;
+        type?: string;
+        [key: string]: unknown;
+    };
+};
+export type Attribute = {
+    name: string;
+};
+export declare const getUsedAttributeNames: (attributes: Array<Attribute>, schemaData: SchemaData) => Array<string>;

package/dist/admin/src/components/FormModal/reducer.d.ts

@@ -0,0 +1,188 @@
+import { type PayloadAction } from '@reduxjs/toolkit';
+import type { Schema, Struct, UID } from '@strapi/types';
+import type { MessageDescriptor, PrimitiveType } from 'react-intl';
+type FormModalError = MessageDescriptor & {
+    values?: Record<string, PrimitiveType>;
+};
+export type ComponentToCreateData = Record<string, unknown> & {
+    type?: 'component';
+    displayName?: string;
+    icon?: string;
+    category?: string;
+};
+export type FormModalData = Record<string, unknown> & {
+    allowedTypes?: string[];
+    category?: string;
+    component?: UID.Component;
+    components?: UID.Component[];
+    componentToCreate?: ComponentToCreateData;
+    conditions?: unknown;
+    createComponent?: boolean;
+    default?: unknown;
+    displayName?: string;
+    draftAndPublish?: boolean;
+    enum?: string[];
+    icon?: string;
+    kind?: Struct.ContentTypeKind;
+    multiple?: boolean;
+    name?: string;
+    options?: object;
+    pluralName?: string;
+    pluginOptions?: object;
+    relation?: Schema.Attribute.RelationKind.Any;
+    repeatable?: boolean;
+    required?: boolean;
+    singularName?: string;
+    target?: string | null;
+    targetAttribute?: string | null;
+    type?: string;
+};
+type CustomFieldOption = {
+    items?: CustomFieldOption[];
+    name?: string;
+    defaultValue?: unknown;
+};
+type CustomField = {
+    type: string;
+    options?: {
+        base?: CustomFieldOption[];
+        advanced?: CustomFieldOption[];
+    };
+};
+export type State = {
+    formErrors: Record<string, FormModalError>;
+    modifiedData: FormModalData;
+    initialData: FormModalData;
+    componentToCreate: ComponentToCreateData;
+    isCreatingComponentWhileAddingAField: boolean;
+};
+declare const initialState: State;
+type OnChangePayload = {
+    keys: string[];
+    value: unknown;
+};
+type OnChangeRelationTargetPayload = {
+    target: {
+        oneThatIsCreatingARelationWithAnother: string;
+        selectedContentTypeFriendlyName: string;
+        targetContentTypeAllowedRelations: Schema.Attribute.RelationKind.Any[] | null;
+        value: string;
+    };
+};
+type OnChangeRelationTypePayload = {
+    target: {
+        oneThatIsCreatingARelationWithAnother: string;
+        value: Schema.Attribute.RelationKind.Any;
+    };
+};
+type ResetPropsAndSetFormForAddingAnExistingCompoPayload = {
+    uid: UID.Schema;
+    options?: Record<string, unknown>;
+};
+type ResetPropsAndSaveCurrentDataPayload = {
+    uid: UID.Schema;
+    options?: Record<string, unknown>;
+};
+type SetDataToEditPayload = {
+    data: FormModalData;
+};
+type SetAttributeDataSchemaPayload = {
+    isEditing: true;
+    modifiedDataToSetForEditing: FormModalData;
+    uid: UID.Schema;
+} | {
+    isEditing: false;
+    modifiedDataToSetForEditing: FormModalData;
+    attributeType: string;
+    nameToSetForRelation: string;
+    targetUid: string;
+    step: string | null;
+    options?: Record<string, unknown>;
+    uid: UID.Schema;
+};
+type SetCustomFieldDataSchemaPayload = {
+    isEditing: true;
+    modifiedDataToSetForEditing: FormModalData;
+    uid: UID.Schema;
+} | {
+    isEditing: false;
+    modifiedDataToSetForEditing: FormModalData;
+    customField: CustomField;
+    options?: Record<string, unknown>;
+    uid: UID.Schema;
+};
+type SetDynamicZoneDataSchemaPayload = {
+    attributeToEdit: FormModalData;
+};
+type SetErrorsPayload = {
+    errors: Record<string, FormModalError>;
+};
+export { initialState };
+export declare const actions: import("@reduxjs/toolkit").CaseReducerActions<{
+    onChange: (state: import("immer/dist/internal.js").WritableDraft<State>, action: PayloadAction<OnChangePayload>) => void;
+    onChangeRelationTarget: (state: import("immer/dist/internal.js").WritableDraft<State>, action: PayloadAction<OnChangeRelationTargetPayload>) => void;
+    onChangeRelationType: (state: import("immer/dist/internal.js").WritableDraft<State>, action: PayloadAction<OnChangeRelationTypePayload>) => void;
+    resetProps: () => State;
+    resetPropsAndSetFormForAddingAnExistingCompo: (state: import("immer/dist/internal.js").WritableDraft<State>, action: PayloadAction<ResetPropsAndSetFormForAddingAnExistingCompoPayload>) => {
+        modifiedData: {
+            type: string;
+            repeatable: true;
+        };
+        formErrors: Record<string, FormModalError>;
+        initialData: FormModalData;
+        componentToCreate: ComponentToCreateData;
+        isCreatingComponentWhileAddingAField: boolean;
+    };
+    resetPropsAndSaveCurrentData: (state: import("immer/dist/internal.js").WritableDraft<State>, action: PayloadAction<ResetPropsAndSaveCurrentDataPayload>) => State | {
+        componentToCreate: import("immer/dist/internal.js").WritableDraft<ComponentToCreateData>;
+        modifiedData: {
+            component: `${string}.${string}`;
+            displayName: string;
+            type: string;
+            repeatable: boolean;
+        };
+        isCreatingComponentWhileAddingAField: boolean;
+        formErrors: Record<string, FormModalError>;
+        initialData: FormModalData;
+    };
+    resetPropsAndSetTheFormForAddingACompoToADz: (state: import("immer/dist/internal.js").WritableDraft<State>) => {
+        modifiedData: {
+            createComponent: boolean;
+            componentToCreate: {
+                type: "component";
+            };
+            allowedTypes?: string[] | undefined;
+            category?: string | undefined;
+            component?: UID.Component | undefined;
+            components?: UID.Component[] | undefined;
+            conditions?: unknown;
+            default?: unknown;
+            displayName?: string | undefined;
+            draftAndPublish?: boolean | undefined;
+            enum?: string[] | undefined;
+            icon?: string | undefined;
+            kind?: Struct.ContentTypeKind | undefined;
+            multiple?: boolean | undefined;
+            name?: string | undefined;
+            options?: object | undefined;
+            pluralName?: string | undefined;
+            pluginOptions?: object | undefined;
+            relation?: Schema.Attribute.RelationKind.Any | undefined;
+            repeatable?: boolean | undefined;
+            required?: boolean | undefined;
+            singularName?: string | undefined;
+            target?: string | null | undefined;
+            targetAttribute?: string | null | undefined;
+            type?: string | undefined;
+        };
+        formErrors: Record<string, FormModalError>;
+        initialData: FormModalData;
+        componentToCreate: ComponentToCreateData;
+        isCreatingComponentWhileAddingAField: boolean;
+    };
+    setDataToEdit: (state: import("immer/dist/internal.js").WritableDraft<State>, action: PayloadAction<SetDataToEditPayload>) => void;
+    setAttributeDataSchema: (state: import("immer/dist/internal.js").WritableDraft<State>, action: PayloadAction<SetAttributeDataSchemaPayload>) => void;
+    setCustomFieldDataSchema: (state: import("immer/dist/internal.js").WritableDraft<State>, action: PayloadAction<SetCustomFieldDataSchemaPayload>) => void;
+    setDynamicZoneDataSchema: (state: import("immer/dist/internal.js").WritableDraft<State>, action: PayloadAction<SetDynamicZoneDataSchemaPayload>) => void;
+    setErrors: (state: import("immer/dist/internal.js").WritableDraft<State>, action: PayloadAction<SetErrorsPayload>) => void;
+}, "formModal">, reducer: import("redux").Reducer<State>;

package/dist/admin/src/components/FormModal/utils/canEditContentType.d.ts

@@ -0,0 +1,18 @@
+import type { AnyAttribute, ContentType } from '../../../types';
+import type { Internal, Struct } from '@strapi/types';
+export type EditableContentTypeSchema = {
+    kind: Struct.ContentTypeKind;
+    name: string;
+    attributes: AnyAttribute[];
+};
+export type EditableContentTypeData = {
+    contentType: {
+        uid: Internal.UID.ContentType;
+        schema: EditableContentTypeSchema;
+    };
+};
+type ModifiedData = {
+    kind?: Struct.ContentTypeKind;
+};
+export declare const canEditContentType: (type: ContentType, modifiedData: ModifiedData) => boolean;
+export {};

package/dist/admin/src/components/FormModal/utils/createUid.d.ts

@@ -0,0 +1,4 @@
+import type { Internal } from '@strapi/types';
+declare const createUid: (name: string) => Internal.UID.ContentType;
+declare const createComponentUid: (name: string, category: string) => Internal.UID.Component;
+export { createComponentUid, createUid };

package/dist/admin/src/components/FormModal/utils/customFieldDefaultOptionsReducer.d.ts

@@ -0,0 +1,11 @@
+type CustomFieldDefaultOption = {
+    name: string;
+    defaultValue: unknown;
+};
+type CustomFieldOption = {
+    items?: CustomFieldOption[];
+    name?: string;
+    defaultValue?: unknown;
+};
+export declare const customFieldDefaultOptionsReducer: (acc: CustomFieldDefaultOption[], option: CustomFieldOption) => CustomFieldDefaultOption[];
+export {};

package/dist/admin/src/components/FormModal/utils/getAttributesToDisplay.d.ts

@@ -0,0 +1,4 @@
+import type { IconByType } from '../../AttributeIcon';
+import type { NestedComponent } from '../../DataManager/utils/retrieveNestedComponents';
+import type { Internal } from '@strapi/types';
+export declare const getAttributesToDisplay: (dataTarget: string | undefined, targetUid: Internal.UID.Schema, nestedComponents: Array<NestedComponent>) => IconByType[][];

package/dist/admin/src/components/FormModal/utils/getFormInputNames.d.ts

@@ -0,0 +1,8 @@
+type FormInput = {
+    name?: string;
+};
+type FormSection = {
+    items: FormInput[];
+};
+export declare const getFormInputNames: (form: FormSection[]) => string[];
+export {};

package/dist/admin/src/components/FormModal/utils/relations.d.ts

@@ -0,0 +1,4 @@
+import type { Schema } from '@strapi/types';
+declare const shouldPluralizeName: (nature?: Schema.Attribute.RelationKind.Any) => 2 | 1;
+declare const shouldPluralizeTargetAttribute: (nature?: Schema.Attribute.RelationKind.Any) => 2 | 1;
+export { shouldPluralizeName, shouldPluralizeTargetAttribute };

package/dist/admin/src/components/FormModalEndActions.d.ts

@@ -0,0 +1,38 @@
+/**
+ *
+ * FormModalEndActions
+ *
+ */
+import { SyntheticEvent } from 'react';
+type FormModalEndActionsProps = {
+    deleteComponent: () => void;
+    deleteContentType: () => void;
+    isAttributeModal: boolean;
+    isCustomFieldModal: boolean;
+    isComponentAttribute: boolean;
+    isComponentModal: boolean;
+    isComponentToDzModal: boolean;
+    isContentTypeModal: boolean;
+    isCreatingComponent: boolean;
+    isCreatingComponentAttribute: boolean;
+    isCreatingComponentInDz: boolean;
+    isCreatingComponentWhileAddingAField: boolean;
+    isCreatingContentType: boolean;
+    isCreatingDz: boolean;
+    isDzAttribute: boolean;
+    isEditingAttribute: boolean;
+    isInFirstComponentStep: boolean;
+    onSubmitAddComponentAttribute: (e: SyntheticEvent, shouldContinue: boolean) => void;
+    onSubmitAddComponentToDz: (e: SyntheticEvent, shouldContinue: boolean) => void;
+    onSubmitCreateContentType: (e: SyntheticEvent, shouldContinue: boolean) => void;
+    onSubmitCreateComponent: (e: SyntheticEvent, shouldContinue: boolean) => void;
+    onSubmitCreateDz: (e: SyntheticEvent, shouldContinue: boolean) => void;
+    onSubmitEditAttribute: (e: SyntheticEvent, shouldContinue: boolean) => void;
+    onSubmitEditComponent: (e: SyntheticEvent, shouldContinue: boolean) => void;
+    onSubmitEditContentType: (e: SyntheticEvent, shouldContinue: boolean) => void;
+    onSubmitEditCustomFieldAttribute: (e: SyntheticEvent, shouldContinue: boolean) => void;
+    onSubmitEditDz: (e: SyntheticEvent, shouldContinue: boolean) => void;
+    onClickFinish: () => void;
+};
+export declare const FormModalEndActions: ({ deleteComponent, deleteContentType, isAttributeModal, isCustomFieldModal, isComponentAttribute, isComponentToDzModal, isContentTypeModal, isCreatingComponent, isCreatingComponentAttribute, isCreatingComponentInDz, isCreatingComponentWhileAddingAField, isCreatingContentType, isCreatingDz, isComponentModal, isDzAttribute, isEditingAttribute, isInFirstComponentStep, onSubmitAddComponentAttribute, onSubmitAddComponentToDz, onSubmitCreateContentType, onSubmitCreateComponent, onSubmitCreateDz, onSubmitEditAttribute, onSubmitEditComponent, onSubmitEditContentType, onSubmitEditCustomFieldAttribute, onSubmitEditDz, onClickFinish, }: FormModalEndActionsProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/admin/src/components/FormModalHeader.d.ts

@@ -0,0 +1,18 @@
+import { IconByType } from './AttributeIcon';
+import type { Internal, Struct } from '@strapi/types';
+type BaseProps = {
+    actionType?: string | null;
+    attributeName: string;
+    attributeType: IconByType;
+    contentTypeKind: IconByType;
+    dynamicZoneTarget: string;
+    modalType: string | null;
+    customFieldUid?: string | null;
+    showBackLink?: boolean;
+};
+type FormModalHeaderProps = BaseProps & {
+    forTarget: Struct.ModelType;
+    targetUid: Internal.UID.Schema;
+};
+export declare const FormModalHeader: ({ actionType, attributeName, attributeType, contentTypeKind, dynamicZoneTarget, forTarget, modalType, targetUid, customFieldUid, showBackLink, }: FormModalHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/components/FormModalNavigation/FormModalNavigationContext.d.ts

@@ -0,0 +1,19 @@
+import * as React from 'react';
+import type { State, SelectFieldPayload, SelectCustomFieldPayload, NavigateToChooseAttributeModalPayload, NavigateToAddCompoToDZModalPayload, OpenModalAddComponentsToDZPayload, OpenModalEditFieldPayload, OpenModalEditCustomFieldPayload, OpenModalEditSchemaPayload, OpenModalAddFieldPayload, OpenModalCreateSchemaPayload } from './FormModalNavigationProvider';
+export type FormModalNavigationContextValue = State & {
+    onCloseModal: () => void;
+    onOpenModalAddField: (options: OpenModalAddFieldPayload) => void;
+    onClickSelectField: (option: SelectFieldPayload) => void;
+    onClickSelectCustomField: (option: SelectCustomFieldPayload) => void;
+    onNavigateToChooseAttributeModal: (options: NavigateToChooseAttributeModalPayload) => void;
+    onNavigateToAddCompoToDZModal: (options: NavigateToAddCompoToDZModalPayload) => void;
+    onOpenModalAddComponentsToDZ: (options: OpenModalAddComponentsToDZPayload) => void;
+    onNavigateToCreateComponentStep2: () => void;
+    onOpenModalCreateSchema: (options: OpenModalCreateSchemaPayload) => void;
+    onOpenModalEditField: (options: OpenModalEditFieldPayload) => void;
+    onOpenModalEditCustomField: (options: OpenModalEditCustomFieldPayload) => void;
+    onOpenModalEditSchema: (options: OpenModalEditSchemaPayload) => void;
+    setFormModalNavigationState: (value: React.SetStateAction<State>) => void;
+    setActiveTab: (value: State['activeTab']) => void;
+};
+export declare const FormModalNavigationContext: React.Context<FormModalNavigationContextValue>;