@strapi/admin 4.20.4 → 5.0.0-alpha.0

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

@@ -0,0 +1,34 @@
+import { ButtonProps, DialogBodyProps, DialogProps, DialogFooterProps } from '@strapi/design-system';
+interface ConfirmDialogProps extends Omit<DialogProps, 'title'>, Partial<Pick<DialogProps, 'title'>>, Pick<ButtonProps, 'variant'>, Partial<DialogFooterProps>, Pick<DialogBodyProps, 'icon'> {
+    onConfirm?: () => Promise<void> | void;
+}
+/**
+ * @beta
+ * @public
+ * @description A simple confirm dialog that out of the box can be used to confirm an action.
+ * The component can additionally be customised if required e.g. the footer actions can be
+ * completely replaced, but cannot be removed. Passing a string as the children prop will render
+ * the string as the body of the dialog. If you need more control over the body, you can pass a
+ * custom component as the children prop.
+ * @example
+ * ```tsx
+ * const DeleteAction = ({ id }) => {
+ *  const [isOpen, setIsOpen] = React.useState(false);
+ *
+ *  const [delete] = useDeleteMutation()
+ *  const handleConfirm = async () => {
+ *    await delete(id)
+ *  }
+ *
+ *  return (
+ *    <>
+ *      <Button onClick={() => setIsOpen(true)}>Delete</Button>
+ *      <ConfirmDialog onConfirm={handleConfirm} onClose={() => setIsOpen(false)} isOpen={isOpen} />
+ *    </>
+ *  )
+ * }
+ * ```
+ */
+declare const ConfirmDialog: ({ children, icon, onClose, onConfirm, variant, startAction, endAction, ...props }: ConfirmDialogProps) => import("react/jsx-runtime").JSX.Element;
+export { ConfirmDialog };
+export type { ConfirmDialogProps };

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

@@ -0,0 +1,12 @@
+import { FlexProps } from '@strapi/design-system';
+interface ContentBoxProps {
+    title?: string;
+    subtitle?: string;
+    icon?: FlexProps['children'];
+    iconBackground?: FlexProps['background'];
+    endAction?: FlexProps['children'];
+    titleEllipsis?: boolean;
+}
+declare const ContentBox: ({ title, subtitle, icon, iconBackground, endAction, titleEllipsis, }: ContentBoxProps) => import("react/jsx-runtime").JSX.Element;
+export { ContentBox };
+export type { ContentBoxProps };

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

@@ -0,0 +1,31 @@
+/**
+ * This component will render DescriptionComponents that return objects e.g. `cm.apis.addEditViewPanel`
+ * these descriptions are still treated like components because users can use react hooks in them.
+ *
+ * Rendering them normally by mapping etc. causes mutliple render issues.
+ */
+import * as React from 'react';
+interface DescriptionComponent<Props, Description> {
+    (props: Props): Description | null;
+}
+interface DescriptionComponentRendererProps<Props = any, Description = any> {
+    children: (descriptions: Array<Description & {
+        id: string;
+    }>) => React.ReactNode;
+    descriptions: DescriptionComponent<Props, Description>[];
+    props: Props;
+}
+/**
+ * @internal
+ *
+ * @description This component takes an array of DescriptionComponents, which are react components that return objects as opposed to JSX.
+ * We render these in their own isolated memoized component and use an update function to push the data back out to the parent.
+ * Saving it in a ref, and then "forcing" an update of the parent component to render the children of this component with the new data.
+ *
+ * The DescriptionCompoonents can take props and use react hooks hence why we render them as if they were a component. The update
+ * function is throttled and managed to avoid erroneous updates where we could wait a single tick to update the entire UI, which
+ * creates less "popping" from functions being called in rapid succession.
+ */
+declare const DescriptionComponentRenderer: <Props, Description>({ children, props, descriptions, }: DescriptionComponentRendererProps<Props, Description>) => import("react/jsx-runtime").JSX.Element;
+export { DescriptionComponentRenderer };
+export type { DescriptionComponentRendererProps, DescriptionComponent };

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

@@ -0,0 +1,6 @@
+/**
+ * @description this stops the app from going white, and instead shows the error message.
+ * But it could be improved for sure.
+ */
+declare const ErrorElement: () => import("react/jsx-runtime").JSX.Element;
+export { ErrorElement };

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

@@ -0,0 +1,83 @@
+import * as React from 'react';
+import { MainField } from '../content-manager/utils/attributes';
+import { InputProps } from './Form';
+interface FilterFormData {
+    name: string;
+    filter: string;
+    value?: string;
+}
+interface FitlersContextValue {
+    disabled: boolean;
+    onChange: (data: FilterFormData) => void;
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    setTriggerNode: (node: HTMLButtonElement | null) => void;
+    triggerNode: HTMLButtonElement | null;
+    options: Filters.Filter[];
+}
+interface RootProps extends Partial<Pick<FitlersContextValue, 'disabled' | 'onChange' | 'options' | 'open'>> {
+    children: React.ReactNode;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+declare const Filters: {
+    List: () => import("react/jsx-runtime").JSX.Element | null;
+    Popover: () => import("react/jsx-runtime").JSX.Element | null;
+    Root: ({ children, disabled, onChange, onOpenChange, open: openProp, defaultOpen, options, }: RootProps) => import("react/jsx-runtime").JSX.Element;
+    Trigger: React.ForwardRefExoticComponent<Filters.TriggerProps & React.RefAttributes<HTMLButtonElement>>;
+};
+declare namespace Filters {
+    interface Filter {
+        input?: React.ComponentType<ValueInputProps>;
+        label: string;
+        /**
+         * the name of the attribute we use to display the actual name e.g. relations
+         * are just ids, so we use the mainField to display something meaninginful by
+         * looking at the target's schema
+         */
+        mainField?: MainField;
+        name: string;
+        operators?: Array<{
+            label: string;
+            value: string;
+        }>;
+        options?: Array<{
+            label?: string;
+            value: string;
+        }> | string[];
+        type: InputProps['type'] | 'relation' | 'custom';
+    }
+    interface ValueInputProps extends Omit<Filter, 'label'> {
+        ['aria-label']: string;
+    }
+    type Props = RootProps;
+    interface TriggerProps {
+        label?: string;
+    }
+    interface Query {
+        filters?: {
+            /**
+             * Typically, a filter will be:
+             * ```ts
+             * {
+             *  [attributeName]: {
+             *    [operator]: value
+             *  }
+             * }
+             * ```
+             * However, for relation items it becomes more nested.
+             * ```ts
+             * {
+             *  [attributeName]: {
+             *    [relationTargetAttribute]: {
+             *     [operator]: value
+             *    }
+             *  }
+             * }
+             */
+            $and?: Array<Record<string, Record<string, string | Record<string, string>>>>;
+        };
+        page?: number;
+    }
+}
+export { Filters };

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

@@ -0,0 +1,71 @@
+import * as React from 'react';
+import type { InputProps as InputPropsImpl, StringProps, EnumerationProps } from './FormInputs/types';
+import type * as Yup from 'yup';
+type InputProps = InputPropsImpl | StringProps | EnumerationProps;
+interface FormValues {
+    [field: string]: any;
+}
+interface FormContextValue<TFormValues extends FormValues = FormValues> extends FormState<TFormValues> {
+    disabled: boolean;
+    initialValues: TFormValues;
+    modified: boolean;
+    /**
+     * The default behaviour is to add the row to the end of the array, if you want to add it to a
+     * specific index you can pass the index.
+     */
+    addFieldRow: (field: string, value: any, addAtIndex?: number) => void;
+    moveFieldRow: (field: string, fromIndex: number, toIndex: number) => void;
+    onChange: (eventOrPath: React.ChangeEvent<any> | string, value?: any) => void;
+    removeFieldRow: (field: string, removeAtIndex?: number) => void;
+    resetForm: () => void;
+    setErrors: (errors: FormErrors<TFormValues>) => void;
+    setSubmitting: (isSubmitting: boolean) => void;
+    setValues: (values: TFormValues) => void;
+    validate: () => Promise<{
+        data: TFormValues;
+        errors?: never;
+    } | {
+        data?: never;
+        errors: FormErrors<TFormValues>;
+    }>;
+}
+declare const useForm: <Selected>(consumerName: string, selector: (value: FormContextValue<FormValues>) => Selected) => Selected;
+interface FormHelpers<TFormValues extends FormValues = FormValues> extends Pick<FormContextValue<TFormValues>, 'setErrors' | 'setValues' | 'resetForm'> {
+}
+interface FormProps<TFormValues extends FormValues = FormValues> extends Partial<Pick<FormContextValue<TFormValues>, 'disabled' | 'initialValues'>> {
+    children: React.ReactNode | ((props: Pick<FormContextValue<TFormValues>, 'disabled' | 'errors' | 'isSubmitting' | 'modified' | 'values' | 'resetForm' | 'onChange'>) => React.ReactNode);
+    method: 'POST' | 'PUT';
+    onSubmit?: (values: TFormValues, helpers: FormHelpers<TFormValues>) => Promise<void> | void;
+    validationSchema?: Yup.AnySchema;
+}
+/**
+ * @alpha
+ * @description A form component that handles form state, validation and submission.
+ * It can additionally handle nested fields and arrays. To access the data you can either
+ * use the generic useForm hook or the useField hook when providing the name of your field.
+ */
+declare const Form: <TFormValues extends FormValues>(p: FormProps<TFormValues> & {
+    ref?: React.Ref<HTMLFormElement> | undefined;
+}) => React.ReactElement;
+type FormErrors<TFormValues extends FormValues = FormValues> = {
+    [Key in keyof TFormValues]?: TFormValues[Key] extends any[] ? TFormValues[Key][number] extends object ? FormErrors<TFormValues[Key][number]>[] | string | string[] : string : TFormValues[Key] extends object ? FormErrors<TFormValues[Key]> : string;
+};
+interface FormState<TFormValues extends FormValues = FormValues> {
+    /**
+     * TODO: make this a better type explaining errors could be nested because it follows the same
+     * structure as the values.
+     */
+    errors: FormErrors<TFormValues>;
+    isSubmitting: boolean;
+    values: TFormValues;
+}
+interface FieldValue<TValue = any> {
+    error?: string;
+    initialValue: TValue;
+    onChange: (eventOrPath: React.ChangeEvent<any> | string, value?: TValue) => void;
+    value: TValue;
+}
+declare const useField: <TValue = any>(path: string) => FieldValue<TValue | undefined>;
+declare const Blocker: () => import("react/jsx-runtime").JSX.Element | null;
+export { Form, Blocker, useField, useForm };
+export type { FormHelpers, FormProps, FormValues, FormContextValue, FormState, FieldValue, InputProps, };

package/dist/admin/src/components/FormInputs/Boolean.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { InputProps } from './types';
+declare const BooleanInput: import("react").ForwardRefExoticComponent<InputProps & import("react").RefAttributes<HTMLInputElement>>;
+export { BooleanInput };

package/dist/admin/src/components/FormInputs/Checkbox.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { InputProps } from './types';
+declare const CheckboxInput: import("react").ForwardRefExoticComponent<InputProps & import("react").RefAttributes<HTMLInputElement>>;
+export { CheckboxInput };

package/dist/admin/src/components/FormInputs/Date.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { InputProps } from './types';
+declare const DateInput: import("react").ForwardRefExoticComponent<InputProps & import("react").RefAttributes<HTMLInputElement>>;
+export { DateInput };

package/dist/admin/src/components/FormInputs/DateTime.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { InputProps } from './types';
+declare const DateTimeInput: import("react").ForwardRefExoticComponent<InputProps & import("react").RefAttributes<HTMLInputElement>>;
+export { DateTimeInput };

package/dist/admin/src/components/FormInputs/Email.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { StringProps } from './types';
+export declare const EmailInput: import("react").ForwardRefExoticComponent<StringProps & import("react").RefAttributes<any>>;

package/dist/admin/src/components/FormInputs/Enumeration.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { EnumerationProps } from './types';
+export declare const EnumerationInput: import("react").ForwardRefExoticComponent<EnumerationProps & import("react").RefAttributes<any>>;

package/dist/admin/src/components/FormInputs/Json.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import { InputProps } from './types';
+/**
+ * TODO: fix the ref type when the design system is fixed.
+ */
+export declare const JsonInput: import("react").ForwardRefExoticComponent<InputProps & import("react").RefAttributes<any>>;

package/dist/admin/src/components/FormInputs/Number.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { InputProps } from './types';
+declare const NumberInputImpl: import("react").ForwardRefExoticComponent<InputProps & import("react").RefAttributes<HTMLInputElement>>;
+export { NumberInputImpl as NumberInput };

package/dist/admin/src/components/FormInputs/Password.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { StringProps } from './types';
+export declare const PasswordInput: import("react").ForwardRefExoticComponent<StringProps & import("react").RefAttributes<any>>;

package/dist/admin/src/components/FormInputs/Renderer.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import type { InputProps } from '../Form';
+/**
+ * @internal This needs to be tested before being exposed as a public API.
+ * @experimental
+ * @description A generic form renderer for Strapi forms. Similar to GenericInputs but with a different API.
+ * The entire component is memoized to avoid re-renders in large forms.
+ */
+declare const InputRenderer: import("react").MemoExoticComponent<import("react").ForwardRefExoticComponent<InputProps & import("react").RefAttributes<any>>>;
+export { InputRenderer };

package/dist/admin/src/components/FormInputs/String.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import { type InputProps } from '../Form';
+/**
+ * TODO: fix the ref type when the design system is fixed.
+ */
+export declare const StringInput: import("react").ForwardRefExoticComponent<InputProps & import("react").RefAttributes<any>>;

package/dist/admin/src/components/FormInputs/Textarea.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import type { StringProps } from './types';
+export declare const TextareaInput: import("react").ForwardRefExoticComponent<StringProps & import("react").RefAttributes<any>>;

package/dist/admin/src/components/FormInputs/Time.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { InputProps } from './types';
+declare const TimeInput: import("react").ForwardRefExoticComponent<InputProps & import("react").RefAttributes<HTMLInputElement>>;
+export { TimeInput };

package/dist/admin/src/components/FormInputs/types.d.ts

@@ -0,0 +1,32 @@
+import type { ComponentPropsWithoutRef, ReactNode } from 'react';
+import type { Attribute } from '@strapi/types';
+interface EnumerationProps extends Omit<InputProps, 'options' | 'type'> {
+    options: Array<{
+        disabled?: boolean;
+        hidden?: boolean;
+        label?: string;
+        value: string;
+    }>;
+    type: 'enumeration';
+}
+interface StringProps extends Omit<InputProps, 'autoComplete' | 'type'>, Pick<ComponentPropsWithoutRef<'input'>, 'autoComplete'> {
+    type: Extract<Attribute.Kind, 'text' | 'string' | 'password' | 'email'>;
+}
+/**
+ * These props exist on all form inputs, they're not unique to the CM.
+ * The concept is that these inputs can be used in a generic renderer that is shared
+ * between the numerous forms across Strapi.
+ */
+interface InputProps {
+    'aria-label'?: string;
+    autoComplete?: never;
+    disabled?: boolean;
+    hint?: ReactNode;
+    label?: ReactNode;
+    name: string;
+    placeholder?: string;
+    required?: boolean;
+    options?: never;
+    type: Exclude<Attribute.Kind, 'enumeration' | 'media' | 'blocks' | 'richtext' | 'uid' | 'dynamiczone' | 'component' | 'relation' | 'text' | 'string' | 'password' | 'email'> | 'checkbox';
+}
+export type { EnumerationProps, InputProps, StringProps };

package/dist/admin/src/components/GuidedTour/Provider.d.ts

@@ -1,6 +1,43 @@
 import * as React from 'react';
+declare const GUIDED_TOUR_KEYS: {
+    readonly GUIDED_TOUR_COMPLETED_STEPS: "GUIDED_TOUR_COMPLETED_STEPS";
+    readonly GUIDED_TOUR_CURRENT_STEP: "GUIDED_TOUR_CURRENT_STEP";
+    readonly GUIDED_TOUR_SKIPPED: "GUIDED_TOUR_SKIPPED";
+};
+type SectionKey = keyof GuidedTourContextValue['guidedTourState'];
+type StepKey = keyof GuidedTourContextValue['guidedTourState'][SectionKey];
+type Step = `${SectionKey}.${StepKey}`;
+interface GuidedTourContextValue {
+    currentStep: Step | null;
+    guidedTourState: {
+        contentTypeBuilder: {
+            create: boolean;
+            success: boolean;
+        };
+        contentManager: {
+            create: boolean;
+            success: boolean;
+        };
+        apiTokens: {
+            create: boolean;
+            success: boolean;
+        };
+        transferTokens: {
+            create: boolean;
+            success: boolean;
+        };
+    };
+    isGuidedTourVisible: boolean;
+    isSkipped: boolean;
+    setCurrentStep: (step: Step | null) => void | null;
+    setGuidedTourVisibility: (isVisible: boolean) => void;
+    setSkipped: (isSkipped: boolean) => void;
+    setStepState: (step: Step, state: boolean) => void;
+    startSection: (section: SectionKey) => void;
+}
+declare const useGuidedTour: <Selected>(consumerName: string, selector: (value: GuidedTourContextValue) => Selected) => Selected;
 interface GuidedTourProviderProps {
     children: React.ReactNode;
 }
 declare const GuidedTourProvider: ({ children }: GuidedTourProviderProps) => import("react/jsx-runtime").JSX.Element;
-export { GuidedTourProvider };
+export { GuidedTourProvider, useGuidedTour, GuidedTourContextValue, GUIDED_TOUR_KEYS };

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

@@ -0,0 +1,38 @@
+import * as React from 'react';
+import { type EmptyStateLayoutProps } from '@strapi/design-system';
+import { Permission } from '../../../shared/contracts/shared';
+interface LoadingProps {
+    /**
+     * @default 'Loading content.'
+     */
+    children?: React.ReactNode;
+}
+interface ErrorProps extends Partial<EmptyStateLayoutProps> {
+}
+interface NoPermissionsProps extends Partial<EmptyStateLayoutProps> {
+}
+interface NoDataProps extends Partial<EmptyStateLayoutProps> {
+}
+export interface ProtectProps {
+    /**
+     * The children to render if the user has the required permissions.
+     * If providing a function, it will be called with an object containing
+     * the permissions the user has based on the array you passed to the component.
+     */
+    children: React.ReactNode | ((args: {
+        permissions: Permission[];
+    }) => React.ReactNode);
+    /**
+     * The permissions the user needs to have to access the content.
+     */
+    permissions?: Array<Omit<Partial<Permission>, 'action'> & Pick<Permission, 'action'>>;
+}
+declare const Page: {
+    Error: (props: ErrorProps) => import("react/jsx-runtime").JSX.Element;
+    Loading: ({ children }: LoadingProps) => import("react/jsx-runtime").JSX.Element;
+    NoPermissions: (props: NoPermissionsProps) => import("react/jsx-runtime").JSX.Element;
+    Protect: ({ permissions, children }: ProtectProps) => string | number | boolean | Iterable<React.ReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined;
+    NoData: (props: NoDataProps) => import("react/jsx-runtime").JSX.Element;
+};
+export { Page };
+export type { ErrorProps, LoadingProps, NoPermissionsProps };

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

@@ -0,0 +1,55 @@
+import * as React from 'react';
+import type { Pagination as PaginationApi } from '../../../shared/contracts/shared';
+interface RootProps {
+    children: React.ReactNode;
+    /**
+     * @default 0
+     * @description the total number of pages
+     * that exist in the dataset.
+     */
+    pageCount?: PaginationApi['pageCount'];
+    /**
+     * @default 1
+     * @description the initial page number.
+     */
+    defaultPage?: PaginationApi['page'];
+    /**
+     * @default 10
+     * @description the initial number of items to display
+     */
+    defaultPageSize?: PaginationApi['pageSize'];
+    /**
+     * @description a callback that is called when the page size changes.
+     */
+    onPageSizeChange?: (pageSize: string) => void;
+    /**
+     * @default 0
+     * @description the total number of items in the dataset.
+     */
+    total?: PaginationApi['total'];
+}
+declare const Pagination: {
+    Root: React.ForwardRefExoticComponent<RootProps & React.RefAttributes<HTMLDivElement>>;
+    Links: ({ boundaryCount, siblingCount }: Pagination.LinksProps) => import("react/jsx-runtime").JSX.Element | null;
+    PageSize: ({ options }: Pagination.PageSizeProps) => import("react/jsx-runtime").JSX.Element | null;
+};
+declare namespace Pagination {
+    interface Props extends RootProps {
+    }
+    interface PageSizeProps {
+        options?: string[];
+    }
+    interface LinksProps {
+        /**
+         * @default 1
+         * @description Number of always visible pages at the beginning and end.
+         */
+        boundaryCount?: number;
+        /**
+         * @default 1
+         * @description Number of always visible pages before and after the current page.
+         */
+        siblingCount?: number;
+    }
+}
+export { Pagination };

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

@@ -1,5 +1,8 @@
+import * as React from 'react';
 /**
  * TODO: this isn't great, and we really should focus on fixing this.
  */
-declare const PluginsInitializer: () => import("react/jsx-runtime").JSX.Element;
+declare const PluginsInitializer: ({ children }: {
+    children: React.ReactNode;
+}) => string | number | boolean | Iterable<React.ReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined;
 export { PluginsInitializer };

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

@@ -1,7 +1,6 @@
 import * as React from 'react';
-import { RouteProps } from 'react-router-dom';
-interface PrivateRouteProps extends Omit<RouteProps, 'render' | 'component'> {
+interface PrivateRouteProps {
     children: React.ReactNode;
 }
-declare const PrivateRoute: ({ children, ...rest }: PrivateRouteProps) => import("react/jsx-runtime").JSX.Element;
+declare const PrivateRoute: ({ children }: PrivateRouteProps) => string | number | boolean | Iterable<React.ReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined;
 export { PrivateRoute };

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

@@ -1,11 +1,10 @@
 import * as React from 'react';
-import { CustomFieldsProviderProps, LibraryProviderProps, StrapiAppProviderProps } from '@strapi/helper-plugin';
-import { LanguageProviderProps } from './LanguageProvider';
-import { ThemeProps } from './Theme';
 import type { Store } from '../core/store/configure';
-interface ProvidersProps extends Pick<LanguageProviderProps, 'messages'>, Pick<CustomFieldsProviderProps, 'customFields'>, Pick<LibraryProviderProps, 'components' | 'fields'>, Pick<StrapiAppProviderProps, 'getPlugin' | 'getAdminInjectedComponents' | 'menu' | 'plugins' | 'runHookParallel' | 'runHookSeries' | 'runHookWaterfall' | 'settings'>, Pick<ThemeProps, 'themes'> {
+import type { StrapiApp } from '../StrapiApp';
+interface ProvidersProps {
     children: React.ReactNode;
+    strapi: StrapiApp;
     store: Store;
 }
-declare const Providers: ({ children, components, customFields, fields, getAdminInjectedComponents, getPlugin, menu, messages, plugins, runHookParallel, runHookSeries, runHookWaterfall, settings, store, themes, }: ProvidersProps) => import("react/jsx-runtime").JSX.Element;
+declare const Providers: ({ children, strapi, store }: ProvidersProps) => import("react/jsx-runtime").JSX.Element;
 export { Providers };

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

@@ -0,0 +1,28 @@
+import * as React from 'react';
+import { Duration } from 'date-fns';
+interface CustomInterval {
+    unit: keyof Duration;
+    text: string;
+    threshold: number;
+}
+interface RelativeTimeProps extends React.ComponentPropsWithoutRef<'time'> {
+    timestamp: Date;
+    customIntervals?: CustomInterval[];
+}
+/**
+ * Displays the relative time between a given timestamp and the current time.
+ * You can display a custom message for given time intervals by passing an array of custom intervals.
+ *
+ * @example
+ * ```jsx
+ * <caption>Display "last hour" if the timestamp is less than an hour ago</caption>
+ * <RelativeTime
+ *  timestamp={new Date('2021-01-01')}
+ *  customIntervals={[
+ *   { unit: 'hours', threshold: 1, text: 'last hour' },
+ *  ]}
+ * ```
+ */
+declare const RelativeTime: React.ForwardRefExoticComponent<RelativeTimeProps & React.RefAttributes<HTMLTimeElement>>;
+export { RelativeTime };
+export type { CustomInterval, RelativeTimeProps };

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

@@ -0,0 +1,11 @@
+import { TrackingEvent } from '../features/Tracking';
+interface SearchInputProps {
+    disabled?: boolean;
+    label: string;
+    placeholder?: string;
+    trackedEvent?: TrackingEvent['name'] | null;
+    trackedEventDetails?: TrackingEvent['properties'];
+}
+declare const SearchInput: ({ disabled, label, placeholder, trackedEvent, trackedEventDetails, }: SearchInputProps) => import("react/jsx-runtime").JSX.Element;
+export { SearchInput };
+export type { SearchInputProps };