@strapi/content-type-builder 5.49.0 → 5.50.1

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

@@ -1,50 +1,77 @@
 import { attributesForm } from '../attributes/form';
 import { attributeTypes } from '../attributes/types';
-import { FormTypeOptions } from './utils/addItemsToFormSection';
+import { addItemsToFormSection, FormTypeOptions } from './utils/addItemsToFormSection';
 import { Attribute, SchemaData } from './utils/getUsedAttributeNames';
-import type { ContentType } from '../../../types';
+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: any;
-    attributeType: keyof typeof attributeTypes;
-    customFieldValidator: any;
+    schemaAttributes: Attribute[];
+    attributeType: AttributeType;
+    customFieldValidator: CustomFieldValidator;
     reservedNames: {
         attributes: Array<string>;
     };
-    schemaData: any;
-    ctbFormsAPI: any;
+    schemaData: SchemaData;
+    ctbFormsAPI: FormAPI;
 };
 type Base<TAttributesFormType extends 'base' | 'advanced'> = {
-    data: any;
+    data: FormModalData;
     type: keyof (typeof attributesForm)[TAttributesFormType];
-    step: string;
-    attributes: any;
-    extensions: any;
+    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): any;
+        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 }: any): {
+            base({ customField }: Pick<CustomFieldFormParams, "customField">): {
                 sections: FormTypeOptions;
             };
-            advanced({ customField, data, step, extensions, ...rest }: any): {
+            advanced({ customField, data, step, extensions, ...rest }: CustomFieldFormParams): {
                 sections: FormTypeOptions;
             };
         };
     };
     attribute: {
-        schema(currentSchema: any, attributeType: keyof typeof attributeTypes, reservedNames: {
+        schema(currentSchema: {
+            attributes?: Attribute[];
+        } | null | undefined, attributeType: AttributeType, reservedNames: {
             attributes: Array<string>;
         }, alreadyTakenTargetContentTypeAttributes: Array<Attribute>, options: SchemaData, extensions: {
-            makeValidator: any;
-        }): any;
+            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: any[];
+            advanced({ data, type, step, extensions, ...rest }: Base<"advanced">): {
+                sections: FormTypeOptions;
             };
-            base({ data, type, step, attributes }: Base<'base'>): {
+            base({ data, type, step, attributes }: Base<"base">): {
                 sections: {
                     sectionTitle: null;
                     items: {
@@ -61,10 +88,12 @@ export declare const forms: {
     };
     contentType: {
         schema(alreadyTakenNames: Array<string>, isEditing: boolean, ctUid: Internal.UID.ContentType, reservedNames: {
-            models: any;
-        }, extensions: any, contentTypes: Record<Internal.UID.ContentType, ContentType>): any;
+            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 }: any): {
+            base({ actionType }: {
+                actionType?: string;
+            }): {
                 sections: {
                     sectionTitle: null;
                     items: ({
@@ -98,17 +127,19 @@ export declare const forms: {
                     })[];
                 }[];
             };
-            advanced({ extensions }: any): {
+            advanced({ extensions }: {
+                extensions: FormAPI;
+            }): {
                 sections: {
-                    items: any[];
+                    items: unknown[];
                 }[];
             };
         };
     };
     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<{
+            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>;
@@ -152,7 +183,9 @@ export declare const forms: {
             advanced(): {
                 sections: unknown[];
             };
-            base({ data }: any): {
+            base({ data }: {
+                data: FormModalData;
+            }): {
                 sections: {
                     sectionTitle: null;
                     items: {

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

@@ -1,10 +1,20 @@
 export type SchemaData = {
     initialData: {
         name?: string;
-        targetAttribute?: any;
+        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;
     };
-    modifiedData: object;
 };
 export type Attribute = {
     name: string;

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

@@ -1,16 +1,65 @@
 import { type PayloadAction } from '@reduxjs/toolkit';
-import type { Schema, UID } from '@strapi/types';
+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, any>;
-    modifiedData: Record<string, any>;
-    initialData: Record<string, any>;
-    componentToCreate: Record<string, any>;
+    formErrors: Record<string, FormModalError>;
+    modifiedData: FormModalData;
+    initialData: FormModalData;
+    componentToCreate: ComponentToCreateData;
     isCreatingComponentWhileAddingAField: boolean;
 };
 declare const initialState: State;
 type OnChangePayload = {
     keys: string[];
-    value: any;
+    value: unknown;
 };
 type OnChangeRelationTargetPayload = {
     target: {
@@ -28,45 +77,45 @@ type OnChangeRelationTypePayload = {
 };
 type ResetPropsAndSetFormForAddingAnExistingCompoPayload = {
     uid: UID.Schema;
-    options?: Record<string, any>;
+    options?: Record<string, unknown>;
 };
 type ResetPropsAndSaveCurrentDataPayload = {
     uid: UID.Schema;
-    options?: Record<string, any>;
+    options?: Record<string, unknown>;
 };
 type SetDataToEditPayload = {
-    data: Record<string, any>;
+    data: FormModalData;
 };
 type SetAttributeDataSchemaPayload = {
     isEditing: true;
-    modifiedDataToSetForEditing: Record<string, any>;
+    modifiedDataToSetForEditing: FormModalData;
     uid: UID.Schema;
 } | {
     isEditing: false;
-    modifiedDataToSetForEditing: Record<string, any>;
+    modifiedDataToSetForEditing: FormModalData;
     attributeType: string;
     nameToSetForRelation: string;
     targetUid: string;
     step: string | null;
-    options?: Record<string, any>;
+    options?: Record<string, unknown>;
     uid: UID.Schema;
 };
 type SetCustomFieldDataSchemaPayload = {
     isEditing: true;
-    modifiedDataToSetForEditing: Record<string, any>;
+    modifiedDataToSetForEditing: FormModalData;
     uid: UID.Schema;
 } | {
     isEditing: false;
-    modifiedDataToSetForEditing: Record<string, any>;
-    customField: Record<string, any>;
-    options?: Record<string, any>;
+    modifiedDataToSetForEditing: FormModalData;
+    customField: CustomField;
+    options?: Record<string, unknown>;
     uid: UID.Schema;
 };
 type SetDynamicZoneDataSchemaPayload = {
-    attributeToEdit: Record<string, any>;
+    attributeToEdit: FormModalData;
 };
 type SetErrorsPayload = {
-    errors: Record<string, any>;
+    errors: Record<string, FormModalError>;
 };
 export { initialState };
 export declare const actions: import("@reduxjs/toolkit").CaseReducerActions<{
@@ -77,35 +126,58 @@ export declare const actions: import("@reduxjs/toolkit").CaseReducerActions<{
     resetPropsAndSetFormForAddingAnExistingCompo: (state: import("immer/dist/internal.js").WritableDraft<State>, action: PayloadAction<ResetPropsAndSetFormForAddingAnExistingCompoPayload>) => {
         modifiedData: {
             type: string;
-            repeatable: boolean;
+            repeatable: true;
         };
-        formErrors: Record<string, any>;
-        initialData: Record<string, any>;
-        componentToCreate: Record<string, any>;
+        formErrors: Record<string, FormModalError>;
+        initialData: FormModalData;
+        componentToCreate: ComponentToCreateData;
         isCreatingComponentWhileAddingAField: boolean;
     };
-    resetPropsAndSaveCurrentData: (state: import("immer/dist/internal.js").WritableDraft<State>, action: PayloadAction<ResetPropsAndSaveCurrentDataPayload>) => {
-        componentToCreate: any;
+    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: any;
+            displayName: string;
             type: string;
             repeatable: boolean;
         };
-        isCreatingComponentWhileAddingAField: any;
-        formErrors: Record<string, any>;
-        initialData: Record<string, any>;
+        isCreatingComponentWhileAddingAField: boolean;
+        formErrors: Record<string, FormModalError>;
+        initialData: FormModalData;
     };
     resetPropsAndSetTheFormForAddingACompoToADz: (state: import("immer/dist/internal.js").WritableDraft<State>) => {
         modifiedData: {
             createComponent: boolean;
             componentToCreate: {
-                type: string;
+                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, any>;
-        initialData: Record<string, any>;
-        componentToCreate: Record<string, any>;
+        formErrors: Record<string, FormModalError>;
+        initialData: FormModalData;
+        componentToCreate: ComponentToCreateData;
         isCreatingComponentWhileAddingAField: boolean;
     };
     setDataToEdit: (state: import("immer/dist/internal.js").WritableDraft<State>, action: PayloadAction<SetDataToEditPayload>) => void;

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

@@ -1 +1,11 @@
-export declare const customFieldDefaultOptionsReducer: (acc: any, option: any) => any;
+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/getFormInputNames.d.ts

@@ -1 +1,8 @@
-export declare const getFormInputNames: (form: any) => any;
+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

@@ -1,4 +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;
+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/FormModalHeader.d.ts

@@ -1,5 +1,5 @@
 import { IconByType } from './AttributeIcon';
-import type { Internal } from '@strapi/types';
+import type { Internal, Struct } from '@strapi/types';
 type BaseProps = {
     actionType?: string | null;
     attributeName: string;
@@ -10,12 +10,9 @@ type BaseProps = {
     customFieldUid?: string | null;
     showBackLink?: boolean;
 };
-type FormModalHeaderProps = BaseProps & ({
-    forTarget: 'component';
-    targetUid: Internal.UID.Component;
-} | {
-    forTarget: 'contentType';
-    targetUid: Internal.UID.ContentType;
-});
+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

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import type { State, SelectFieldPayload, SelectCustomFieldPayload, NavigateToChooseAttributeModalPayload, NavigateToAddCompoToDZModalPayload, OpenModalAddComponentsToDZPayload, OpenModalEditFieldPayload, OpenModalEditCustomFieldPayload, OpenModalEditSchemaPayload, OpenModalAddFieldPayload } from './FormModalNavigationProvider';
+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;
@@ -9,7 +9,7 @@ export type FormModalNavigationContextValue = State & {
     onNavigateToAddCompoToDZModal: (options: NavigateToAddCompoToDZModalPayload) => void;
     onOpenModalAddComponentsToDZ: (options: OpenModalAddComponentsToDZPayload) => void;
     onNavigateToCreateComponentStep2: () => void;
-    onOpenModalCreateSchema: (options: State) => void;
+    onOpenModalCreateSchema: (options: OpenModalCreateSchemaPayload) => void;
     onOpenModalEditField: (options: OpenModalEditFieldPayload) => void;
     onOpenModalEditCustomField: (options: OpenModalEditCustomFieldPayload) => void;
     onOpenModalEditSchema: (options: OpenModalEditSchemaPayload) => void;

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

@@ -1,11 +1,25 @@
-/// <reference types="react" />
 import type { Internal, Struct } from '@strapi/types';
 type FormModalNavigationProviderProps = {
     children: React.ReactNode;
 };
 export type Tab = 'basic' | 'advanced';
 export type ModalType = 'chooseAttribute' | 'edit' | 'attribute' | 'customField' | 'addComponentToDynamicZone' | 'contentType' | 'component';
-export type State = Record<string, any>;
+export type ActionType = 'create' | 'edit' | null;
+export type State = {
+    actionType: Exclude<ActionType, null>;
+    attributeName: string;
+    attributeType: string;
+    dynamicZoneTarget: string;
+    forTarget: Struct.ModelType;
+    modalType: ModalType | null;
+    isOpen: boolean;
+    showBackLink: boolean;
+    kind: Struct.ContentTypeKind;
+    step: string | null;
+    targetUid: Internal.UID.Schema;
+    customFieldUid: string;
+    activeTab: Tab;
+};
 export declare const INITIAL_STATE_DATA: State;
 export type SelectCustomFieldPayload = {
     attributeType: string;
@@ -50,5 +64,6 @@ export type NavigateToChooseAttributeModalPayload = {
 export type NavigateToAddCompoToDZModalPayload = {
     dynamicZoneTarget: string;
 };
+export type OpenModalCreateSchemaPayload = Pick<State, 'actionType' | 'forTarget' | 'kind' | 'modalType'>;
 export declare const FormModalNavigationProvider: ({ children }: FormModalNavigationProviderProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -18,6 +18,11 @@ interface InputOption {
     key: string;
     value: string;
 }
+type ConditionField = {
+    name: string;
+    type: string;
+    enum?: string[];
+};
 interface CustomInputProps<TAttribute extends Schema.Attribute.AnyAttribute = Schema.Attribute.AnyAttribute> {
     attribute?: TAttribute;
     autoComplete?: string;
@@ -31,7 +36,7 @@ interface CustomInputProps<TAttribute extends Schema.Attribute.AnyAttribute = Sc
     onChange: (payload: {
         target: {
             name: string;
-            value: Schema.Attribute.Value<TAttribute>;
+            value?: unknown;
             type?: string;
         };
     }, shouldSetInitialValue?: boolean) => void;
@@ -41,10 +46,10 @@ interface CustomInputProps<TAttribute extends Schema.Attribute.AnyAttribute = Sc
     required?: boolean;
     step?: number;
     type: string;
-    value?: Schema.Attribute.Value<TAttribute>;
+    value?: unknown;
     autoFocus?: boolean;
     attributeName?: string;
-    conditionFields?: Record<string, boolean>;
+    conditionFields?: ConditionField[];
 }
 interface GenericInputProps<TAttribute extends Schema.Attribute.AnyAttribute = Schema.Attribute.AnyAttribute> {
     attribute?: TAttribute;
@@ -59,7 +64,7 @@ interface GenericInputProps<TAttribute extends Schema.Attribute.AnyAttribute = S
     onChange: (payload: {
         target: {
             name: string;
-            value: Schema.Attribute.Value<TAttribute>;
+            value?: unknown;
             type?: string;
         };
     }, shouldSetInitialValue?: boolean) => void;
@@ -69,17 +74,17 @@ interface GenericInputProps<TAttribute extends Schema.Attribute.AnyAttribute = S
     required?: boolean;
     step?: number;
     type: string;
-    value?: Schema.Attribute.Value<TAttribute>;
+    value?: unknown;
     isNullable?: boolean;
     autoFocus?: boolean;
     attributeName?: string;
-    conditionFields?: Record<string, boolean>;
+    conditionFields?: ConditionField[];
 }
 /**
  * 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, onDelete, options, placeholder, required, step, type, value: defaultValue, isNullable, autoFocus, attribute, attributeName, conditionFields, ...rest }: GenericInputProps) => import("react/jsx-runtime").JSX.Element>;
+declare const MemoizedGenericInput: React.MemoExoticComponent<({ autoComplete, customInputs, description, disabled, intlLabel, labelAction, error, name, onChange, onDelete, options, placeholder, required, step, type, value: defaultValue, isNullable: _isNullable, autoFocus, attribute, attributeName, conditionFields, ...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

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

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

@@ -1,14 +1,13 @@
-/// <reference types="react" />
 import type { Component, ContentType } from '../types';
 import type { UID } from '@strapi/types';
 export declare const ListGrid: import("styled-components/dist/types").IStyledComponentBase<"web", import("styled-components").FastOmit<Omit<import("@strapi/design-system").TransientBoxProps & {
-    children?: import("react").ReactNode;
+    children?: React.ReactNode;
 } & import("@strapi/design-system/dist/types").AsProp<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>> & Omit<Omit<any, "ref">, "children" | keyof import("@strapi/design-system/dist/types").AsProp<C> | keyof import("@strapi/design-system").TransientBoxProps> & {
     ref?: any;
 }, "ref"> & {
     ref?: any;
 }, never> & Partial<Pick<Omit<import("@strapi/design-system").TransientBoxProps & {
-    children?: import("react").ReactNode;
+    children?: React.ReactNode;
 } & import("@strapi/design-system/dist/types").AsProp<import("react").ElementType<any, keyof import("react").JSX.IntrinsicElements>> & Omit<Omit<any, "ref">, "children" | keyof import("@strapi/design-system/dist/types").AsProp<C> | keyof import("@strapi/design-system").TransientBoxProps> & {
     ref?: any;
 }, "ref"> & {

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

@@ -1,21 +1,13 @@
-import type { IntlLabel } from '../types';
-interface Description {
-    id: string;
-    defaultMessage: string;
-    values?: Record<string, any>;
-}
+import type { FormChangeHandler, IntlLabel } from '../types';
 interface PluralNameProps {
-    description?: Description;
+    description?: IntlLabel;
     error?: string;
     intlLabel: IntlLabel;
-    modifiedData: Record<string, any>;
+    modifiedData: {
+        displayName?: string;
+    };
     name: string;
-    onChange: (value: {
-        target: {
-            name: string;
-            value: string;
-        };
-    }) => void;
+    onChange: FormChangeHandler<string>;
     value?: string;
 }
 export declare const PluralName: ({ description, error, intlLabel, modifiedData, name, onChange, value, }: PluralNameProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -1,8 +1,17 @@
+import type { FormChangeHandler } from '../../types';
+import type { Schema } from '@strapi/types';
 interface RelationProps {
-    formErrors: Record<string, any>;
+    formErrors: Record<string, {
+        id?: string;
+    } | undefined>;
     mainBoxHeader: string;
-    modifiedData: Record<string, any>;
-    onChange: (value: any) => void;
+    modifiedData: {
+        name?: string;
+        relation?: Schema.Attribute.RelationKind.Any;
+        target?: string;
+        targetAttribute?: string | null;
+    };
+    onChange: FormChangeHandler;
     naturePickerType: string;
     targetUid: string;
 }

package/dist/admin/src/components/Relation/RelationField/RelationField.d.ts

@@ -1,11 +1,12 @@
+import type { FormChangeHandler } from '../../../types';
 import type { Internal } from '@strapi/types';
 interface RelationFormBoxProps {
     disabled?: boolean;
-    error?: Record<string, any>;
+    error?: string | null;
     header?: string;
     isMain?: boolean;
     name: string;
-    onChange: (value: any) => void;
+    onChange: FormChangeHandler;
     oneThatIsCreatingARelationWithAnother?: string;
     target?: Internal.UID.ContentType;
     value?: string;