@strapi/admin 4.20.5 → 5.0.0-alpha.0

package/dist/admin/src/core/store/configure.d.ts

@@ -1,5 +1,6 @@
 import { Middleware, Reducer } from '@reduxjs/toolkit';
 import { RBACState } from '../../components/RBACProvider';
+import { ContentManagerAppState } from '../../content-manager/layout';
 import { AppState } from '../../reducer';
 type PreloadState = Partial<{
     admin_app: AppState;
@@ -14,29 +15,30 @@ declare const configureStoreImpl: (preloadedState?: PreloadState, appMiddlewares
     }, "ApiToken" | "LicenseLimits" | "Me" | "ProjectSettings" | "ProvidersOptions" | "ReviewWorkflow" | "ReviewWorkflowStage" | "Role" | "RolePermissions" | "TransferToken" | "User" | "Webhook", "adminApi">;
     readonly admin_app: AppState;
     readonly rbacProvider: RBACState;
-    readonly 'content-manager_app': import("../../content-manager/pages/App").ContentManagerAppState;
-    readonly 'content-manager_listView': import("../../content-manager/pages/ListViewLayoutManager").ListViewLayoutManagerState;
-    readonly 'content-manager_rbacManager': import("../../content-manager/hooks/useSyncRbac").SyncRbacState;
-    readonly 'content-manager_editViewLayoutManager': import("../../content-manager/pages/EditViewLayoutManager").EditViewLayoutManagerState;
-    readonly 'content-manager_editViewCrudReducer': import("../../content-manager/sharedReducers/crud/reducer").CrudState;
+    readonly 'content-manager_app': ContentManagerAppState;
+    readonly contentManagerApi: import("@reduxjs/toolkit/query").CombinedState<{}, "ComponentConfiguration" | "ContentTypesConfiguration" | "ContentTypeSettings" | "Document" | "InitialData" | "HistoryVersion", "contentManagerApi">;
+    readonly 'content-manager': import("redux").CombinedState<{
+        rbac: import("../../content-manager/modules/rbac").SyncRbacState;
+    }>;
 }, import("redux").AnyAction, (import("@reduxjs/toolkit").ThunkMiddleware<{
     readonly adminApi: import("@reduxjs/toolkit/query").CombinedState<{
         regenerateToken: import("@reduxjs/toolkit/query").MutationDefinition<string, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("../../utils/baseQuery").QueryArguments, unknown, import("../../utils/baseQuery").BaseQueryError>, "ApiToken" | "LicenseLimits" | "Me" | "ProjectSettings" | "ProvidersOptions" | "ReviewWorkflow" | "ReviewWorkflowStage" | "Role" | "RolePermissions" | "TransferToken" | "User" | "Webhook", import("../../../../shared/contracts/transfer").TransferToken, "adminApi">;
     }, "ApiToken" | "LicenseLimits" | "Me" | "ProjectSettings" | "ProvidersOptions" | "ReviewWorkflow" | "ReviewWorkflowStage" | "Role" | "RolePermissions" | "TransferToken" | "User" | "Webhook", "adminApi">;
     readonly admin_app: AppState;
     readonly rbacProvider: RBACState;
-    readonly 'content-manager_app': import("../../content-manager/pages/App").ContentManagerAppState;
-    readonly 'content-manager_listView': import("../../content-manager/pages/ListViewLayoutManager").ListViewLayoutManagerState;
-    readonly 'content-manager_rbacManager': import("../../content-manager/hooks/useSyncRbac").SyncRbacState;
-    readonly 'content-manager_editViewLayoutManager': import("../../content-manager/pages/EditViewLayoutManager").EditViewLayoutManagerState;
-    readonly 'content-manager_editViewCrudReducer': import("../../content-manager/sharedReducers/crud/reducer").CrudState;
+    readonly 'content-manager_app': ContentManagerAppState;
+    readonly contentManagerApi: import("@reduxjs/toolkit/query").CombinedState<{}, "ComponentConfiguration" | "ContentTypesConfiguration" | "ContentTypeSettings" | "Document" | "InitialData" | "HistoryVersion", "contentManagerApi">;
+    readonly 'content-manager': import("redux").CombinedState<{
+        rbac: import("../../content-manager/modules/rbac").SyncRbacState;
+    }>;
 }, import("redux").AnyAction> | Middleware<{}, import("@reduxjs/toolkit/query").RootState<{
     regenerateToken: import("@reduxjs/toolkit/query").MutationDefinition<string, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("../../utils/baseQuery").QueryArguments, unknown, import("../../utils/baseQuery").BaseQueryError>, "ApiToken" | "LicenseLimits" | "Me" | "ProjectSettings" | "ProvidersOptions" | "ReviewWorkflow" | "ReviewWorkflowStage" | "Role" | "RolePermissions" | "TransferToken" | "User" | "Webhook", import("../../../../shared/contracts/transfer").TransferToken, "adminApi">;
-}, string, "adminApi">, import("@reduxjs/toolkit").ThunkDispatch<any, any, import("redux").AnyAction>>)[]>;
+}, string, "adminApi">, import("@reduxjs/toolkit").ThunkDispatch<any, any, import("redux").AnyAction>> | Middleware<{}, import("@reduxjs/toolkit/query").RootState<{}, string, "contentManagerApi">, import("@reduxjs/toolkit").ThunkDispatch<any, any, import("redux").AnyAction>>)[]>;
 type Store = ReturnType<typeof configureStoreImpl> & {
     asyncReducers: Record<string, Reducer>;
     injectReducer: (key: string, asyncReducer: Reducer) => void;
 };
 type RootState = ReturnType<Store['getState']>;
+type Dispatch = Store['dispatch'];
 export { configureStoreImpl as configureStore };
-export type { RootState, AppState, RBACState, Store, PreloadState };
+export type { RootState, Dispatch, AppState, RBACState, Store, PreloadState, ContentManagerAppState, };

package/dist/admin/src/core/store/hooks.d.ts

@@ -11,33 +11,33 @@ declare const createTypedSelector: <TResult>(selector: (state: {
     }, "ApiToken" | "LicenseLimits" | "Me" | "ProjectSettings" | "ProvidersOptions" | "ReviewWorkflow" | "ReviewWorkflowStage" | "Role" | "RolePermissions" | "TransferToken" | "User" | "Webhook", "adminApi">;
     readonly admin_app: import("../../reducer").AppState;
     readonly rbacProvider: import("../../components/RBACProvider").RBACState;
-    readonly 'content-manager_app': import("../../content-manager/pages/App").ContentManagerAppState;
-    readonly 'content-manager_listView': import("../../content-manager/pages/ListViewLayoutManager").ListViewLayoutManagerState;
-    readonly 'content-manager_rbacManager': import("../../content-manager/hooks/useSyncRbac").SyncRbacState;
-    readonly 'content-manager_editViewLayoutManager': import("../../content-manager/pages/EditViewLayoutManager").EditViewLayoutManagerState;
-    readonly 'content-manager_editViewCrudReducer': import("../../content-manager/sharedReducers/crud/reducer").CrudState;
+    readonly 'content-manager_app': import("../../content-manager/layout").ContentManagerAppState;
+    readonly contentManagerApi: import("@reduxjs/toolkit/query").CombinedState<{}, "ComponentConfiguration" | "ContentTypesConfiguration" | "ContentTypeSettings" | "Document" | "InitialData" | "HistoryVersion", "contentManagerApi">;
+    readonly 'content-manager': import("redux").CombinedState<{
+        rbac: import("../../content-manager/modules/rbac").SyncRbacState;
+    }>;
 }, ...params: any[]) => TResult) => ((state: {
     readonly adminApi: import("@reduxjs/toolkit/query").CombinedState<{
         regenerateToken: import("@reduxjs/toolkit/query").MutationDefinition<string, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("../../utils/baseQuery").QueryArguments, unknown, import("../../utils/baseQuery").BaseQueryError>, "ApiToken" | "LicenseLimits" | "Me" | "ProjectSettings" | "ProvidersOptions" | "ReviewWorkflow" | "ReviewWorkflowStage" | "Role" | "RolePermissions" | "TransferToken" | "User" | "Webhook", import("../../../../shared/contracts/transfer").TransferToken, "adminApi">;
     }, "ApiToken" | "LicenseLimits" | "Me" | "ProjectSettings" | "ProvidersOptions" | "ReviewWorkflow" | "ReviewWorkflowStage" | "Role" | "RolePermissions" | "TransferToken" | "User" | "Webhook", "adminApi">;
     readonly admin_app: import("../../reducer").AppState;
     readonly rbacProvider: import("../../components/RBACProvider").RBACState;
-    readonly 'content-manager_app': import("../../content-manager/pages/App").ContentManagerAppState;
-    readonly 'content-manager_listView': import("../../content-manager/pages/ListViewLayoutManager").ListViewLayoutManagerState;
-    readonly 'content-manager_rbacManager': import("../../content-manager/hooks/useSyncRbac").SyncRbacState;
-    readonly 'content-manager_editViewLayoutManager': import("../../content-manager/pages/EditViewLayoutManager").EditViewLayoutManagerState;
-    readonly 'content-manager_editViewCrudReducer': import("../../content-manager/sharedReducers/crud/reducer").CrudState;
+    readonly 'content-manager_app': import("../../content-manager/layout").ContentManagerAppState;
+    readonly contentManagerApi: import("@reduxjs/toolkit/query").CombinedState<{}, "ComponentConfiguration" | "ContentTypesConfiguration" | "ContentTypeSettings" | "Document" | "InitialData" | "HistoryVersion", "contentManagerApi">;
+    readonly 'content-manager': import("redux").CombinedState<{
+        rbac: import("../../content-manager/modules/rbac").SyncRbacState;
+    }>;
 }) => TResult) & import("reselect").OutputSelectorFields<(args_0: {
     readonly adminApi: import("@reduxjs/toolkit/query").CombinedState<{
         regenerateToken: import("@reduxjs/toolkit/query").MutationDefinition<string, import("@reduxjs/toolkit/query").BaseQueryFn<string | import("../../utils/baseQuery").QueryArguments, unknown, import("../../utils/baseQuery").BaseQueryError>, "ApiToken" | "LicenseLimits" | "Me" | "ProjectSettings" | "ProvidersOptions" | "ReviewWorkflow" | "ReviewWorkflowStage" | "Role" | "RolePermissions" | "TransferToken" | "User" | "Webhook", import("../../../../shared/contracts/transfer").TransferToken, "adminApi">;
     }, "ApiToken" | "LicenseLimits" | "Me" | "ProjectSettings" | "ProvidersOptions" | "ReviewWorkflow" | "ReviewWorkflowStage" | "Role" | "RolePermissions" | "TransferToken" | "User" | "Webhook", "adminApi">;
     readonly admin_app: import("../../reducer").AppState;
     readonly rbacProvider: import("../../components/RBACProvider").RBACState;
-    readonly 'content-manager_app': import("../../content-manager/pages/App").ContentManagerAppState;
-    readonly 'content-manager_listView': import("../../content-manager/pages/ListViewLayoutManager").ListViewLayoutManagerState;
-    readonly 'content-manager_rbacManager': import("../../content-manager/hooks/useSyncRbac").SyncRbacState;
-    readonly 'content-manager_editViewLayoutManager': import("../../content-manager/pages/EditViewLayoutManager").EditViewLayoutManagerState;
-    readonly 'content-manager_editViewCrudReducer': import("../../content-manager/sharedReducers/crud/reducer").CrudState;
+    readonly 'content-manager_app': import("../../content-manager/layout").ContentManagerAppState;
+    readonly contentManagerApi: import("@reduxjs/toolkit/query").CombinedState<{}, "ComponentConfiguration" | "ContentTypesConfiguration" | "ContentTypeSettings" | "Document" | "InitialData" | "HistoryVersion", "contentManagerApi">;
+    readonly 'content-manager': import("redux").CombinedState<{
+        rbac: import("../../content-manager/modules/rbac").SyncRbacState;
+    }>;
 }) => TResult, {
     clearCache: () => void;
 }> & {

package/dist/admin/src/features/AppInfo.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="react" />
+interface AppInfoContextValue {
+    autoReload?: boolean;
+    communityEdition?: boolean;
+    currentEnvironment?: string;
+    dependencies?: Record<string, string>;
+    latestStrapiReleaseTag?: string;
+    nodeVersion?: string;
+    projectId?: string | null;
+    shouldUpdateStrapi?: boolean;
+    strapiVersion?: string | null;
+    useYarn?: boolean;
+    userId?: string;
+}
+declare const AppInfoProvider: {
+    (props: AppInfoContextValue & {
+        children: import("react").ReactNode;
+    }): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+}, useAppInfo: <Selected>(consumerName: string, selector: (value: AppInfoContextValue) => Selected) => Selected;
+export { AppInfoProvider, useAppInfo };
+export type { AppInfoContextValue };

package/dist/admin/src/features/BackButton.d.ts

@@ -0,0 +1,51 @@
+import * as React from 'react';
+import { LinkProps } from '@strapi/design-system/v2';
+interface HistoryState {
+    /**
+     * The history of the user's navigation within our application
+     * during their current session.
+     */
+    history: string[];
+    /**
+     * The index of the current location in the history array.
+     */
+    currentLocationIndex: number;
+    /**
+     * The current location of the user within our application.
+     */
+    currentLocation: string;
+    /**
+     * Whether the user can go back in the history.
+     */
+    canGoBack: boolean;
+}
+interface HistoryContextValue extends HistoryState {
+    /**
+     * @description Push a new state to the history. You can
+     * either pass a string or an object.
+     */
+    pushState: (path: {
+        to: string;
+        search: string;
+    } | string) => void;
+    /**
+     * @description Go back in the history. This calls `navigate(-1)` internally
+     * to keep the browser in sync with the application state.
+     */
+    goBack: () => void;
+}
+interface HistoryProviderProps {
+    children: React.ReactNode;
+}
+declare const HistoryProvider: ({ children }: HistoryProviderProps) => import("react/jsx-runtime").JSX.Element;
+interface BackButtonProps extends Pick<LinkProps, 'disabled'> {
+}
+/**
+ * @beta
+ * @description The universal back button for the Strapi application. This uses the internal history
+ * context to navigate the user back to the previous location. It can be completely disabled in a
+ * specific user case.
+ */
+declare const BackButton: React.ForwardRefExoticComponent<BackButtonProps & React.RefAttributes<HTMLAnchorElement>>;
+export { BackButton, HistoryProvider };
+export type { BackButtonProps, HistoryProviderProps, HistoryContextValue, HistoryState };

package/dist/admin/src/features/Configuration.d.ts

@@ -1,6 +1,7 @@
 import * as React from 'react';
 import { UpdateProjectSettings } from '../../../shared/contracts/admin';
 import { ConfigurationLogo } from '../services/admin';
+import type { StrapiApp } from '../StrapiApp';
 interface UpdateProjectSettingsBody {
     authLogo: ((UpdateProjectSettings.Request['body']['authLogo'] | ConfigurationLogo['custom']) & {
         rawFile?: File;
@@ -18,26 +19,19 @@ interface ConfigurationContextValue {
     showReleaseNotification: boolean;
     updateProjectSettings: (body: UpdateProjectSettingsBody) => Promise<void>;
 }
-/**
- * TODO: it would be nice if this context actually lived in redux.
- * But we'd probably need to reconcile the fact we get the data three
- * different ways and what that actually looks like.
- */
 declare const ConfigurationContextProvider: {
     (props: ConfigurationContextValue & {
         children: React.ReactNode;
     }): JSX.Element;
     displayName: string;
 }, useConfiguration: (consumerName: string) => ConfigurationContextValue;
-interface ConfigurationProviderProps extends Required<Logos> {
+interface ConfigurationProviderProps {
     children: React.ReactNode;
+    defaultAuthLogo: StrapiApp['configurations']['authLogo'];
+    defaultMenuLogo: StrapiApp['configurations']['menuLogo'];
     showReleaseNotification?: boolean;
     showTutorials?: boolean;
 }
-interface Logos {
-    menuLogo: ConfigurationContextValue['logos']['menu'];
-    authLogo: ConfigurationContextValue['logos']['auth'];
-}
-declare const ConfigurationProvider: ({ children, authLogo: defaultAuthLogo, menuLogo: defaultMenuLogo, showReleaseNotification, showTutorials, }: ConfigurationProviderProps) => import("react/jsx-runtime").JSX.Element;
+declare const ConfigurationProvider: ({ children, defaultAuthLogo, defaultMenuLogo, showReleaseNotification, showTutorials, }: ConfigurationProviderProps) => import("react/jsx-runtime").JSX.Element;
 export { ConfigurationContextProvider as _internalConfigurationContextProvider, ConfigurationProvider, useConfiguration, };
 export type { ConfigurationProviderProps, ConfigurationContextValue, ConfigurationLogo, UpdateProjectSettingsBody, };

package/dist/admin/src/features/Notifications.d.ts

@@ -0,0 +1,47 @@
+import * as React from 'react';
+interface NotificationLink {
+    label: string;
+    target?: string;
+    url: string;
+}
+interface NotificationConfig {
+    blockTransition?: boolean;
+    link?: NotificationLink;
+    message?: string;
+    onClose?: () => void;
+    timeout?: number;
+    title?: string;
+    type?: 'info' | 'warning' | 'danger' | 'success';
+}
+interface NotificationsContextValue {
+    /**
+     * Toggles a notification, wrapped in `useCallback` for a stable identity.
+     */
+    toggleNotification: (config: NotificationConfig) => void;
+}
+interface NotificationsProviderProps {
+    children: React.ReactNode;
+}
+/**
+ * @internal
+ * @description DO NOT USE. This will be removed before stable release of v5.
+ */
+declare const NotificationsProvider: ({ children }: NotificationsProviderProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * @preserve
+ * @description Returns an object to interact with the notification
+ * system. The callbacks are wrapped in `useCallback` for a stable
+ * identity.
+ *
+ * @example
+ * ```tsx
+ * import { useNotification } from '@strapi/helper-plugin';
+ *
+ * const MyComponent = () => {
+ *  const { toggleNotification } = useNotification();
+ *
+ *  return <button onClick={() => toggleNotification({ message: 'Hello world!' })}>Click me</button>;
+ */
+declare const useNotification: () => NotificationsContextValue;
+export { NotificationsProvider, useNotification };
+export type { NotificationConfig, NotificationsContextValue };

package/dist/admin/src/features/StrapiApp.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+import type { StrapiApp } from '../StrapiApp';
+interface StrapiAppContextValue extends Pick<StrapiApp, 'customFields' | 'menu' | 'getAdminInjectedComponents' | 'getPlugin' | 'plugins' | 'runHookParallel' | 'runHookSeries' | 'settings'> {
+    components: StrapiApp['library']['components'];
+    fields: StrapiApp['library']['fields'];
+    runHookWaterfall: <TData>(name: Parameters<StrapiApp['runHookWaterfall']>[0], initialValue: TData) => TData;
+}
+declare const StrapiAppProvider: {
+    (props: StrapiAppContextValue & {
+        children: import("react").ReactNode;
+    }): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+}, useStrapiApp: <Selected>(consumerName: string, selector: (value: StrapiAppContextValue) => Selected) => Selected;
+export { StrapiAppProvider, useStrapiApp };
+export type { StrapiAppContextValue };

package/dist/admin/src/features/Tracking.d.ts

@@ -0,0 +1,187 @@
+import * as React from 'react';
+import { AxiosResponse } from 'axios';
+export interface TelemetryProperties {
+    useTypescriptOnServer?: boolean;
+    useTypescriptOnAdmin?: boolean;
+    isHostedOnStrapiCloud?: boolean;
+    numberOfAllContentTypes?: number;
+    numberOfComponents?: number;
+    numberOfDynamicZones?: number;
+}
+export interface TrackingContextValue {
+    uuid?: string | boolean;
+    telemetryProperties?: TelemetryProperties;
+}
+export interface TrackingProviderProps {
+    children: React.ReactNode;
+}
+declare const TrackingProvider: ({ children }: TrackingProviderProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * We can group these events together because none have properties so there's no benefit
+ * to having them as separate types.
+ *
+ * Meanwhile those with properties have different property shapes corresponding to the specific
+ * event so understanding which properties go with which event is very helpful.
+ */
+interface EventWithoutProperties {
+    name: 'changeComponentsOrder' | 'didAccessAuthenticatedAdministration' | 'didAddComponentToDynamicZone' | 'didBulkDeleteEntries' | 'didChangeDisplayedFields' | 'didCheckDraftRelations' | 'didClickGuidedTourHomepageApiTokens' | 'didClickGuidedTourHomepageContentManager' | 'didClickGuidedTourHomepageContentTypeBuilder' | 'didClickGuidedTourStep1CollectionType' | 'didClickGuidedTourStep2ContentManager' | 'didClickGuidedTourStep3ApiTokens' | 'didClickonBlogSection' | 'didClickonCodeExampleSection' | 'didClickonReadTheDocumentationSection' | 'didClickOnTryStrapiCloudSection' | 'didClickonTutorialSection' | 'didCreateGuidedTourCollectionType' | 'didCreateGuidedTourEntry' | 'didCreateNewRole' | 'didCreateRole' | 'didDeleteToken' | 'didDuplicateRole' | 'didEditEditSettings' | 'didEditEmailTemplates' | 'didEditFieldNameOnContentType' | 'didEditListSettings' | 'didEditMediaLibraryConfig' | 'didEditNameOfContentType' | 'didGenerateGuidedTourApiTokens' | 'didGoToMarketplace' | 'didLaunchGuidedtour' | 'didMissMarketplacePlugin' | 'didNotCreateFirstAdmin' | 'didNotSaveComponent' | 'didPluginLearnMore' | 'didPublishEntry' | 'didUnpublishEntry' | 'didSaveComponent' | 'didSaveContentType' | 'didSearch' | 'didSkipGuidedtour' | 'didSubmitPlugin' | 'didSubmitProvider' | 'didUpdateConditions' | 'didSelectAllMediaLibraryElements' | 'didSelectContentTypeFieldSettings' | 'didSelectContentTypeSettings' | 'didEditAuthenticationProvider' | 'hasClickedCTBAddFieldBanner' | 'removeComponentFromDynamicZone' | 'willAddMoreFieldToContentType' | 'willBulkDeleteEntries' | 'willBulkUnpublishEntries' | 'willChangeNumberOfEntriesPerPage' | 'willCheckDraftRelations' | 'willCreateComponent' | 'willCreateComponentFromAttributesModal' | 'willCreateContentType' | 'willCreateFirstAdmin' | 'willCreateNewRole' | 'willCreateRole' | 'willCreateSingleType' | 'willCreateStage' | 'willCreateWorkflow' | 'willDeleteEntryFromList' | 'willDeleteFieldOfContentType' | 'willDuplicateRole' | 'willEditEditLayout' | 'willEditEmailTemplates' | 'willEditEntryFromButton' | 'willEditEntryFromList' | 'willEditFieldOfContentType' | 'willEditMediaLibraryConfig' | 'willEditNameOfContentType' | 'willEditNameOfSingleType' | 'willEditAuthenticationProvider' | 'willEditFieldNameOnContentType' | 'willEditStage' | 'willFilterEntries' | 'willInstallPlugin' | 'willPublishEntry' | 'willUnpublishEntry' | 'willSaveComponent' | 'willSaveContentType' | 'willSaveContentTypeLayout' | 'didEditFieldNameOnContentType' | 'didCreateRelease';
+    properties?: never;
+}
+interface DidFilterMediaLibraryElementsEvent {
+    name: 'didFilterMediaLibraryElements';
+    properties: MediaEvents['properties'] & {
+        filter: string;
+    };
+}
+interface DidSortMediaLibraryElementsEvent {
+    name: 'didSortMediaLibraryElements';
+    properties: MediaEvents['properties'] & {
+        sort: string;
+    };
+}
+interface DidCropFileEvent {
+    name: 'didCropFile';
+    properties: MediaEvents['properties'] & {
+        duplicatedFile: null | boolean;
+    };
+}
+interface DidSelectFile {
+    name: 'didSelectFile';
+    properties: MediaEvents['properties'] & {
+        source: 'url' | 'computer';
+    };
+}
+interface DidEditMediaLibraryElementsEvent {
+    name: 'didEditMediaLibraryElements';
+    properties: MediaEvents['properties'] & {
+        type: string;
+        changeLocation: string;
+    };
+}
+interface MediaEvents {
+    name: 'didSearchMediaLibraryElements' | 'didReplaceMedia' | 'didAddMediaLibraryFolders' | 'willAddMediaLibraryAssets';
+    properties: {
+        location: string;
+    };
+}
+interface DidSelectContentTypeFieldTypeEvent {
+    name: 'didSelectContentTypeFieldType';
+    properties: {
+        type?: string;
+    };
+}
+interface DidChangeModeEvent {
+    name: 'didChangeMode';
+    properties: {
+        newMode: string;
+    };
+}
+interface DidSubmitWithErrorsFirstAdminEvent {
+    name: 'didSubmitWithErrorsFirstAdmin';
+    properties: {
+        count: string;
+    };
+}
+interface WillNavigateEvent {
+    name: 'willNavigate';
+    properties: {
+        from: string;
+        to: string;
+    };
+}
+interface DidAccessTokenListEvent {
+    name: 'didAccessTokenList';
+    properties: {
+        tokenType: TokenEvents['properties']['tokenType'];
+        number: number;
+    };
+}
+interface LogoEvent {
+    name: 'didChangeLogo' | 'didClickResetLogo';
+    properties: {
+        logo: 'menu' | 'auth';
+    };
+}
+interface TokenEvents {
+    name: 'didCopyTokenKey' | 'didAddTokenFromList' | 'didEditTokenFromList' | 'willAccessTokenList' | 'willAddTokenFromList' | 'willCreateToken' | 'willDeleteToken' | 'willEditToken' | 'willEditTokenFromList';
+    properties: {
+        tokenType: 'api-token' | 'transfer-token';
+    };
+}
+interface WillModifyTokenEvent {
+    name: 'didCreateToken' | 'didEditToken';
+    properties: {
+        tokenType: TokenEvents['properties']['tokenType'];
+        type: 'custom' | 'full-access' | 'read-only' | Array<'push' | 'pull' | 'push-pull'>;
+    };
+}
+interface DeleteEntryEvents {
+    name: 'willDeleteEntry' | 'didDeleteEntry' | 'didNotDeleteEntry';
+    properties: {
+        status?: string;
+        error?: unknown;
+    };
+}
+interface CreateEntryEvents {
+    name: 'willCreateEntry' | 'didCreateEntry' | 'didNotCreateEntry';
+    properties: {
+        status?: string;
+        error?: unknown;
+    };
+}
+interface UpdateEntryEvents {
+    name: 'willEditEntry' | 'didEditEntry' | 'didNotEditEntry';
+    properties: {
+        status?: string;
+        error?: unknown;
+    };
+}
+interface DidFilterEntriesEvent {
+    name: 'didFilterEntries';
+    properties: {
+        useRelation: boolean;
+    };
+}
+interface DidPublishRelease {
+    name: 'didPublishRelease';
+    properties: {
+        totalEntries: number;
+        totalPublishedEntries: number;
+        totalUnpublishedEntries: number;
+    };
+}
+type EventsWithProperties = CreateEntryEvents | DidAccessTokenListEvent | DidChangeModeEvent | DidCropFileEvent | DeleteEntryEvents | DidEditMediaLibraryElementsEvent | DidFilterMediaLibraryElementsEvent | DidFilterEntriesEvent | DidSelectContentTypeFieldTypeEvent | DidSelectFile | DidSortMediaLibraryElementsEvent | DidSubmitWithErrorsFirstAdminEvent | LogoEvent | TokenEvents | UpdateEntryEvents | WillModifyTokenEvent | WillNavigateEvent | DidPublishRelease;
+export type TrackingEvent = EventWithoutProperties | EventsWithProperties;
+export interface UseTrackingReturn {
+    /**
+     * This type helps show all the available event names before you start typing,
+     * however autocomplete isn't great.
+     */
+    trackUsage<TEvent extends TrackingEvent>(event: TEvent['name'], properties: TEvent['properties']): Promise<null | AxiosResponse<string>>;
+    trackUsage<TEvent extends Extract<TrackingEvent, {
+        properties?: never;
+    }>>(event: TEvent['name'], properties?: never): Promise<null | AxiosResponse<string>>;
+    trackUsage<TEvent extends Extract<TrackingEvent, {
+        properties: object;
+    }>>(event: TEvent['name'], properties: TEvent['properties']): Promise<null | AxiosResponse<string>>;
+}
+/**
+ * @description Used to send amplitude events to the Strapi Tracking hub.
+ *
+ * @example
+ * ```tsx
+ * import { useTracking } from '@strapi/helper-plugin';
+ *
+ * const MyComponent = () => {
+ *  const { trackUsage } = useTracking();
+ *
+ *  const handleClick = () => {
+ *   trackUsage('my-event', { myProperty: 'myValue' });
+ *  }
+ *
+ *  return <button onClick={handleClick}>Send Event</button>
+ * }
+ * ```
+ */
+declare const useTracking: () => UseTrackingReturn;
+export { TrackingProvider, useTracking };

package/dist/admin/src/hooks/useAPIErrorHandler.d.ts

@@ -0,0 +1,96 @@
+import { AxiosError } from 'axios';
+import { IntlFormatters } from 'react-intl';
+import { NormalizeErrorOptions } from '../utils/normalizeAPIError';
+import type { ApiError } from '../types/errors';
+interface UnknownApiError {
+    /**
+     * The name of the ApiError, is always a static value.
+     */
+    name: 'UnknownError';
+    /**
+     * The error message.
+     */
+    message: string;
+    /**
+     * The error details.
+     */
+    details?: unknown;
+    /**
+     * The HTTP status code of the error.
+     */
+    status?: number;
+}
+/**
+ * The last item is the fallback error SerializedError which
+ * typically comes from redux-toolkit itself.
+ */
+interface SerializedError {
+    /**
+     * The name of the error.
+     */
+    name?: string;
+    /**
+     * The error message that explains what went wrong.
+     */
+    message?: string;
+    /**
+     * The stack trace of the error.
+     */
+    stack?: string;
+    /**
+     * A specific error code associated with the error.
+     */
+    code?: string;
+}
+/**
+ * These are the types or errors we return
+ * from the redux-toolkit data-fetching setup.
+ */
+type BaseQueryError = ApiError | UnknownApiError | SerializedError;
+/**
+ * @public
+ * @description The purpose of this hook is to offer a unified way to handle errors thrown by API endpoints, regardless of the type of error (`ValidationError`, `ApplicationErrror` ...)
+that has been thrown.
+ * @example
+ * ```tsx
+ * import * as React from 'react';
+ * import { useFetchClient, useAPIErrorHandler, useNotification } from '@strapi/admin/admin';
+ *
+ * const MyComponent = () => {
+ *   const { get } = useFetchClient();
+ *   const { formatAPIError } = useAPIErrorHandler(getTrad);
+ *   const { toggleNotification } = useNotification();
+ *
+ *   const handleDeleteItem = async () => {
+ *     try {
+ *       return await get('/admin');
+ *     } catch (error) {
+ *       toggleNotification({
+ *         type: 'danger',
+ *         message: formatAPIError(error),
+ *       });
+ *     }
+ *   };
+ *   return <button onClick={handleDeleteItem}>Delete item</button>;
+ * };
+ * ```
+ */
+export declare function useAPIErrorHandler(intlMessagePrefixCallback?: FormatAPIErrorOptions['intlMessagePrefixCallback']): {
+    /**
+     * @alpha
+     * Convert ValidationErrors from the API into an object that can be used by forms.
+     */
+    _unstableFormatValidationErrors: (error: Extract<BaseQueryError, {
+        name: 'ValidationError';
+    }>) => Record<string, string>;
+    /**
+     * @alpha
+     * This handles the errors given from `redux-toolkit`'s axios based baseQuery function.
+     */
+    _unstableFormatAPIError: (error: BaseQueryError) => string;
+    formatAPIError: (error: AxiosError<{
+        error: ApiError;
+    }, any>) => string;
+};
+type FormatAPIErrorOptions = Partial<Pick<NormalizeErrorOptions, 'intlMessagePrefixCallback'>> & Pick<IntlFormatters, 'formatMessage'>;
+export type { ApiError };

package/dist/admin/src/hooks/useContentTypes.d.ts

@@ -1,7 +1,6 @@
 import { Contracts } from '@strapi/plugin-content-manager/_internal/shared';
 export declare function useContentTypes(): {
     isLoading: boolean;
-    components: Contracts.Components.Component[];
     collectionTypes: Contracts.ContentTypes.ContentType[];
     singleTypes: Contracts.ContentTypes.ContentType[];
 };

package/dist/admin/src/hooks/useControllableState.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+type UseControllableStateParams<T> = {
+    prop?: T | undefined;
+    defaultProp?: T | undefined;
+    onChange?: (state: T) => void;
+};
+declare function useControllableState<T>({ prop, defaultProp, onChange, }: UseControllableStateParams<T>): readonly [T | undefined, React.Dispatch<React.SetStateAction<T | undefined>>];
+export { useControllableState };

package/dist/admin/src/hooks/useForceUpdate.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @internal
+ * @description Return a function that re-renders this component, if still mounted
+ * @warning DO NOT USE EXCEPT SPECIAL CASES.
+ */
+declare const useForceUpdate: () => readonly [number | undefined, () => void];
+export { useForceUpdate };

package/dist/admin/src/hooks/useInjectReducer.d.ts

@@ -1,10 +1,14 @@
 import { Reducer } from '@reduxjs/toolkit';
 /**
- * Inject a new reducer into the global redux-store.
+ * @public
+ * @description Inject a new reducer into the global redux-store.
+ * @example
+ * ```tsx
+ * import { reducer } from './local-store';
  *
- * @export
- * @param {string} namespace - Store namespace of the injected reducer
- * @param {Function} reducer - Reducer function
- * @return void
+ * const MyPlugin = () => {
+ *  useInjectReducer("plugin", reducer);
+ * }
+ * ```
  */
 export declare function useInjectReducer(namespace: string, reducer: Reducer): void;

package/dist/admin/src/hooks/useInjectionZone.d.ts

@@ -1,6 +1,2 @@
-/// <reference types="react" />
 import { InjectionZoneArea } from '../components/InjectionZone';
-export declare const useInjectionZone: (area: InjectionZoneArea) => {
-    Component: import("react").ComponentType<{}>;
-    name: string;
-}[];
+export declare const useInjectionZone: (area: InjectionZoneArea) => import("../components/InjectionZone").InjectionZoneComponent[];

package/dist/admin/src/hooks/useIsMounted.d.ts

@@ -0,0 +1,3 @@
+import * as React from 'react';
+declare const useIsMounted: () => React.MutableRefObject<boolean>;
+export { useIsMounted };