@strapi/content-type-builder 0.0.0 → 5.0.0-beta.7

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,207 @@
+import { attributesForm } from '../attributes/form';
+import { attributeTypes } from '../attributes/types';
+import { FormTypeOptions } from './utils/addItemsToFormSection';
+import { Attribute, SchemaData } from './utils/getUsedAttributeNames';
+import type { Internal } from '@strapi/types';
+type ContentType = {
+    schema: {
+        singularName: string;
+        pluralName: string;
+        collectionName: string;
+    };
+};
+export type SchemaParams = {
+    schemaAttributes: any;
+    attributeType: keyof typeof attributeTypes;
+    customFieldValidator: any;
+    reservedNames: {
+        attributes: Array<string>;
+    };
+    schemaData: any;
+    ctbFormsAPI: any;
+};
+type Base<TAttributesFormType extends 'base' | 'advanced'> = {
+    data: any;
+    type: keyof (typeof attributesForm)[TAttributesFormType];
+    step: string;
+    attributes: any;
+    extensions: any;
+    forTarget: string;
+};
+export declare const forms: {
+    customField: {
+        schema({ schemaAttributes, attributeType, customFieldValidator, reservedNames, schemaData, ctbFormsAPI, }: SchemaParams): any;
+        form: {
+            base({ customField }: any): {
+                sections: FormTypeOptions;
+            };
+            advanced({ customField, data, step, extensions, ...rest }: any): {
+                sections: FormTypeOptions;
+            };
+        };
+    };
+    attribute: {
+        schema(currentSchema: any, attributeType: keyof typeof attributeTypes, reservedNames: {
+            attributes: Array<string>;
+        }, alreadyTakenTargetContentTypeAttributes: Array<Attribute>, options: SchemaData, extensions: {
+            makeValidator: any;
+        }): any;
+        form: {
+            advanced({ data, type, step, extensions, ...rest }: Base<'advanced'>): {
+                sections: any[];
+            };
+            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: any;
+        }, extensions: any, contentTypes: Record<string, ContentType>): any;
+        form: {
+            base({ actionType }: any): {
+                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 }: any): {
+                sections: {
+                    items: any[];
+                }[];
+            };
+        };
+    };
+    component: {
+        schema(alreadyTakenAttributes: Array<Internal.UID.Component>, componentCategory: string, reservedNames: {
+            models: any;
+        }, isEditing: boolean | undefined, components: Record<string, any>, 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 }: any): {
+                sections: {
+                    sectionTitle: null;
+                    items: {
+                        name: string;
+                        type: string;
+                        intlLabel: {
+                            id: string;
+                            defaultMessage: string;
+                        };
+                    }[];
+                }[];
+            };
+        };
+    };
+    editCategory: {
+        schema(allCategories: Array<any>, initialData: any): import("yup/lib/object").OptionalObjectSchema<{
+            name: 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>>;
+        }>>;
+        form: {
+            advanced: () => {
+                sections: never[];
+            };
+            base(): {
+                sections: {
+                    sectionTitle: null;
+                    items: {
+                        autoFocus: boolean;
+                        name: string;
+                        type: string;
+                        intlLabel: {
+                            id: string;
+                            defaultMessage: string;
+                        };
+                        description: {
+                            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,11 @@
+export type SchemaData = {
+    initialData: {
+        name: string;
+        targetAttribute: any;
+    };
+    modifiedData: object;
+};
+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,4 @@
+import type { AnyAction } from '@reduxjs/toolkit';
+declare const initialState: any;
+declare const reducer: (state: any, action: AnyAction) => (base?: ((draftState: any) => any) | undefined, ...args: unknown[]) => ((draftState: any) => any) | Promise<(draftState: any) => any>;
+export { initialState, reducer };

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

@@ -0,0 +1,16 @@
+/**
+ * Direct selector to the formModal state domain
+ */
+declare const formModalDomain: () => (state: any) => any;
+/**
+ * Other specific selectors
+ */
+/**
+ * Default selector used by formModal
+ */
+export declare const makeSelectFormModal: () => ((state: any) => any) & import("reselect").OutputSelectorFields<(args_0: any) => any, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+export { formModalDomain };

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

@@ -0,0 +1,18 @@
+import type { AttributeType } from '../../../types';
+import type { Internal, Struct } from '@strapi/types';
+export type EditableContentTypeSchema = {
+    kind: Struct.ContentTypeKind;
+    name: string;
+    attributes: AttributeType[];
+};
+export type EditableContentTypeData = {
+    contentType: {
+        uid: Internal.UID.ContentType;
+        schema: EditableContentTypeSchema;
+    };
+};
+type ModifiedData = {
+    kind: Struct.ContentTypeKind;
+};
+export declare const canEditContentType: (data: Record<string, any>, 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 @@
+export declare const customFieldDefaultOptionsReducer: (acc: any, option: any) => any;

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

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

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

@@ -0,0 +1 @@
+export declare const getFormInputNames: (form: any) => any;

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) => 1 | 2;
+declare const shouldPluralizeTargetAttribute: (nature: Schema.Attribute.RelationKind.Any) => 1 | 2;
+export { shouldPluralizeName, shouldPluralizeTargetAttribute };

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

@@ -0,0 +1,42 @@
+/**
+ *
+ * FormModalEndActions
+ *
+ */
+import { SyntheticEvent } from 'react';
+type FormModalEndActionsProps = {
+    categoryName?: string;
+    deleteCategory: (categoryName: string) => void;
+    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;
+    isEditingCategory: 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;
+    onSubmitEditCategory: (e: SyntheticEvent) => 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: ({ categoryName, deleteCategory, deleteComponent, deleteContentType, isAttributeModal, isCustomFieldModal, isComponentAttribute, isComponentToDzModal, isContentTypeModal, isCreatingComponent, isCreatingComponentAttribute, isCreatingComponentInDz, isCreatingComponentWhileAddingAField, isCreatingContentType, isCreatingDz, isComponentModal, isDzAttribute, isEditingAttribute, isEditingCategory, isInFirstComponentStep, onSubmitAddComponentAttribute, onSubmitAddComponentToDz, onSubmitCreateContentType, onSubmitCreateComponent, onSubmitCreateDz, onSubmitEditAttribute, onSubmitEditCategory, 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 { SchemaType } from '../types';
+import type { Internal } from '@strapi/types';
+interface FormModalHeaderProps {
+    actionType?: string | null;
+    attributeName: string;
+    attributeType: IconByType;
+    categoryName: string;
+    contentTypeKind: IconByType;
+    dynamicZoneTarget: string;
+    forTarget: SchemaType;
+    modalType: string | null;
+    targetUid: Internal.UID.Schema;
+    customFieldUid?: string | null;
+    showBackLink?: boolean;
+}
+export declare const FormModalHeader: ({ actionType, attributeName, attributeType, categoryName, contentTypeKind, dynamicZoneTarget, forTarget, modalType, targetUid, customFieldUid, showBackLink, }: FormModalHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,22 @@
+import * as React from 'react';
+type FormModalNavigationProviderProps = {
+    children: React.ReactNode;
+};
+export type State = any;
+export type ModalEventProps = {
+    attributeType?: string;
+    customFieldUid?: string;
+    dynamicZoneTarget?: string;
+    forTarget?: string;
+    targetUid?: string;
+    attributeName?: string;
+    step?: string | null;
+    kind?: string;
+    categoryName?: string;
+    modalType?: string;
+    actionType?: string;
+    isOpen?: boolean;
+    showBackLink?: boolean;
+};
+export declare const FormModalNavigationProvider: ({ children }: FormModalNavigationProviderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/components/FormModalNavigationProvider/constants.d.ts

@@ -0,0 +1,16 @@
+declare const INITIAL_STATE_DATA: {
+    actionType: null;
+    attributeName: null;
+    attributeType: null;
+    categoryName: null;
+    dynamicZoneTarget: null;
+    forTarget: null;
+    modalType: null;
+    isOpen: boolean;
+    showBackLink: boolean;
+    kind: null;
+    step: null;
+    targetUid: null;
+    customFieldUid: null;
+};
+export { INITIAL_STATE_DATA };

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

@@ -0,0 +1,22 @@
+import { StrapiAppContextValue } from '@strapi/admin/strapi-admin';
+import type { SchemaType } from '../types';
+type ModalTitleProps = {
+    forTarget?: SchemaType;
+    step?: string;
+    kind?: string;
+    modalType?: string;
+    actionType?: string;
+};
+export declare const getModalTitleSubHeader: ({ modalType, forTarget, kind, actionType, step, }: ModalTitleProps) => string;
+type FormModalSubHeaderProps = {
+    actionType: string;
+    modalType: string;
+    forTarget: SchemaType;
+    kind?: string;
+    step?: string;
+    attributeType: string;
+    attributeName: string;
+    customField?: ReturnType<StrapiAppContextValue['customFields']['get']>;
+};
+export declare const FormModalSubHeader: ({ actionType, modalType, forTarget, kind, step, attributeType, attributeName, customField, }: FormModalSubHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,57 @@
+/**
+ * TODO: we should be using the FormRenderer from the admin to do this,
+ * but the CTB has no tests or types, so we can't refactor it safely.
+ * So we're just adding this to the tech debt.
+ */
+import * as React from 'react';
+import { type MessageDescriptor, type PrimitiveType } from 'react-intl';
+import type { Schema } from '@strapi/types';
+interface TranslationMessage extends MessageDescriptor {
+    values?: Record<string, PrimitiveType>;
+}
+interface InputOption {
+    metadatas: {
+        intlLabel: TranslationMessage;
+        disabled: boolean;
+        hidden: boolean;
+    };
+    key: string;
+    value: string;
+}
+interface CustomInputProps<TAttribute extends Schema.Attribute.AnyAttribute> extends Omit<GenericInputProps<TAttribute>, 'customInputs'> {
+    ref?: React.Ref<HTMLElement>;
+    hint?: string | React.JSX.Element | (string | React.JSX.Element)[];
+}
+interface GenericInputProps<TAttribute extends Schema.Attribute.AnyAttribute = Schema.Attribute.AnyAttribute> {
+    attribute?: TAttribute;
+    autoComplete?: string;
+    customInputs?: Record<string, React.ComponentType<CustomInputProps<TAttribute>>>;
+    description?: TranslationMessage;
+    disabled?: boolean;
+    error?: string | TranslationMessage;
+    intlLabel: TranslationMessage;
+    labelAction?: React.ReactNode;
+    name: string;
+    onChange: (payload: {
+        target: {
+            name: string;
+            value: Schema.Attribute.Value<TAttribute>;
+            type?: string;
+        };
+    }, shouldSetInitialValue?: boolean) => void;
+    options?: InputOption[];
+    placeholder?: TranslationMessage;
+    required?: boolean;
+    step?: number;
+    type: string;
+    value?: Schema.Attribute.Value<TAttribute>;
+    isNullable?: boolean;
+}
+/**
+ * we've memoized this component because we use a context to store all the data in our form in the content-manager.
+ * This then causes _every_ component to re-render because there are no selects incurring performance issues
+ * in content-types as the content-type gets more complicated.
+ */
+declare const MemoizedGenericInput: React.MemoExoticComponent<({ autoComplete, customInputs, description, disabled, intlLabel, labelAction, error, name, onChange, options, placeholder, required, step, type, value: defaultValue, isNullable, attribute, ...rest }: GenericInputProps) => import("react/jsx-runtime").JSX.Element>;
+export type { GenericInputProps, CustomInputProps };
+export { MemoizedGenericInput as GenericInput };

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

@@ -0,0 +1,13 @@
+import type { IntlLabel } from '../../types';
+export interface IconPickerProps {
+    intlLabel: IntlLabel;
+    name: string;
+    onChange: (value: {
+        target: {
+            name: string;
+            value: string;
+        };
+    }) => void;
+    value?: string;
+}
+export declare const IconPicker: ({ intlLabel, name, onChange, value }: IconPickerProps) => import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/components/IconPicker/constants.d.ts

@@ -0,0 +1,5 @@
+import * as Icons from '@strapi/icons';
+import * as Symbols from '@strapi/icons/symbols';
+export type Icon = (typeof Icons)[keyof typeof Icons] | (typeof Symbols)[keyof typeof Symbols];
+declare const COMPONENT_ICONS: Record<string, Icon>;
+export { COMPONENT_ICONS };

package/dist/admin/src/components/IconPicker/index.d.ts

@@ -0,0 +1 @@
+export * from './IconPicker';

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

@@ -0,0 +1,18 @@
+import { ComponentType } from 'react';
+import type { SchemaType } from '../types';
+import type { Internal } from '@strapi/types';
+interface ListProps {
+    addComponentToDZ?: () => void;
+    customRowComponent: ComponentType<any>;
+    editTarget: SchemaType;
+    firstLoopComponentUid?: string;
+    isFromDynamicZone?: boolean;
+    isNestedInDZComponent?: boolean;
+    isMain?: boolean;
+    items: any[];
+    secondLoopComponentUid?: string | null;
+    targetUid?: Internal.UID.Schema;
+    isSub?: boolean;
+}
+export declare const List: ({ addComponentToDZ, customRowComponent, editTarget, firstLoopComponentUid, isFromDynamicZone, isMain, isNestedInDZComponent, isSub, items, secondLoopComponentUid, targetUid, }: ListProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,22 @@
+/// <reference types="react" />
+import { IconByType } from './AttributeIcon';
+export declare const BoxWrapper: import("styled-components").IStyledComponent<"web", import("styled-components/dist/types").FastOmit<Omit<Omit<import("@strapi/design-system").BoxProps<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>>, "ref"> & import("react").RefAttributes<unknown>, "ref"> & {
+    ref?: ((instance: unknown) => void) | import("react").RefObject<unknown> | null | undefined;
+}, never>> & Omit<(<C extends import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements> = "div">(props: import("react").PropsWithoutRef<import("@strapi/design-system").BoxProps<C>> & import("react").RefAttributes<unknown>) => import("react").ReactNode), keyof import("react").Component<any, {}, any>>;
+type ListRowProps = {
+    configurable?: boolean;
+    customField?: string | null;
+    editTarget: string;
+    firstLoopComponentUid?: string | null;
+    isFromDynamicZone?: boolean;
+    name: string;
+    onClick: (editTarget: string, targetUid: string | null, attributeName: string, attributeType: string, customField: string | null) => void;
+    relation?: string;
+    repeatable?: boolean;
+    secondLoopComponentUid?: string | null;
+    target?: string | null;
+    targetUid?: string | null;
+    type: IconByType;
+};
+export declare const ListRow: import("react").MemoExoticComponent<({ configurable, customField, editTarget, firstLoopComponentUid, isFromDynamicZone, name, onClick, relation, repeatable, secondLoopComponentUid, target, targetUid, type, }: ListRowProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

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

@@ -0,0 +1,9 @@
+import type { ReactNode } from 'react';
+interface NestedTFooterProps {
+    color: string;
+    children: ReactNode;
+    icon: ReactNode;
+    onClick?: () => void;
+}
+export declare const NestedTFooter: ({ children, icon, color, ...props }: NestedTFooterProps) => import("react/jsx-runtime").JSX.Element;
+export {};