@strapi/admin 4.15.0 → 4.15.1

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

@@ -0,0 +1,185 @@
+export declare const ADMIN_PERMISSIONS_CE: {
+    contentManager: {
+        main: never[];
+        collectionTypesConfigurations: {
+            action: string;
+            subject: null;
+        }[];
+        componentsConfigurations: {
+            action: string;
+            subject: null;
+        }[];
+        singleTypesConfigurations: {
+            action: string;
+            subject: null;
+        }[];
+    };
+    marketplace: {
+        main: {
+            action: string;
+            subject: null;
+        }[];
+        read: {
+            action: string;
+            subject: null;
+        }[];
+    };
+    settings: {
+        roles: {
+            main: {
+                action: string;
+                subject: null;
+            }[];
+            create: {
+                action: string;
+                subject: null;
+            }[];
+            delete: {
+                action: string;
+                subject: null;
+            }[];
+            read: {
+                action: string;
+                subject: null;
+            }[];
+            update: {
+                action: string;
+                subject: null;
+            }[];
+        };
+        users: {
+            main: {
+                action: string;
+                subject: null;
+            }[];
+            create: {
+                action: string;
+                subject: null;
+            }[];
+            delete: {
+                action: string;
+                subject: null;
+            }[];
+            read: {
+                action: string;
+                subject: null;
+            }[];
+            update: {
+                action: string;
+                subject: null;
+            }[];
+        };
+        webhooks: {
+            main: {
+                action: string;
+                subject: null;
+            }[];
+            create: {
+                action: string;
+                subject: null;
+            }[];
+            delete: {
+                action: string;
+                subject: null;
+            }[];
+            read: {
+                action: string;
+                subject: null;
+            }[];
+            update: {
+                action: string;
+                subject: null;
+            }[];
+        };
+        'api-tokens': {
+            main: {
+                action: string;
+                subject: null;
+            }[];
+            create: {
+                action: string;
+                subject: null;
+            }[];
+            delete: {
+                action: string;
+                subject: null;
+            }[];
+            read: {
+                action: string;
+                subject: null;
+            }[];
+            update: {
+                action: string;
+                subject: null;
+            }[];
+            regenerate: {
+                action: string;
+                subject: null;
+            }[];
+        };
+        'transfer-tokens': {
+            main: {
+                action: string;
+                subject: null;
+            }[];
+            create: {
+                action: string;
+                subject: null;
+            }[];
+            delete: {
+                action: string;
+                subject: null;
+            }[];
+            read: {
+                action: string;
+                subject: null;
+            }[];
+            update: {
+                action: string;
+                subject: null;
+            }[];
+            regenerate: {
+                action: string;
+                subject: null;
+            }[];
+        };
+        'project-settings': {
+            read: {
+                action: string;
+                subject: null;
+            }[];
+            update: {
+                action: string;
+                subject: null;
+            }[];
+        };
+    };
+};
+export declare const HOOKS: {
+    /**
+     * Hook that allows to mutate the displayed headers of the list view table
+     * @constant
+     * @type {string}
+     */
+    INJECT_COLUMN_IN_TABLE: string;
+    /**
+     * Hook that allows to mutate the CM's collection types links pre-set filters
+     * @constant
+     * @type {string}
+     */
+    MUTATE_COLLECTION_TYPES_LINKS: string;
+    /**
+     * Hook that allows to mutate the CM's edit view layout
+     * @constant
+     * @type {string}
+     */
+    MUTATE_EDIT_VIEW_LAYOUT: string;
+    /**
+     * Hook that allows to mutate the CM's single types links pre-set filters
+     * @constant
+     * @type {string}
+     */
+    MUTATE_SINGLE_TYPES_LINKS: string;
+};
+export declare const ACTION_SET_APP_RUNTIME_STATUS = "StrapiAdmin/APP/SET_APP_RUNTIME_STATUS";
+export declare const ACTION_SET_ADMIN_PERMISSIONS = "StrapiAdmin/App/SET_ADMIN_PERMISSIONS";

package/dist/admin/src/contexts/admin.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import type { StrapiApp } from '../StrapiApp';
+interface AdminContextValue {
+    getAdminInjectedComponents: StrapiApp['getAdminInjectedComponents'];
+}
+declare const AdminContextProvider: {
+    (props: AdminContextValue & {
+        children: React.ReactNode;
+    }): JSX.Element;
+    displayName: string;
+};
+declare const useAdmin: () => AdminContextValue;
+export { AdminContextProvider, useAdmin };
+export type { AdminContextValue };

package/dist/admin/src/contexts/apiTokenPermissions.d.ts

@@ -0,0 +1,36 @@
+import * as React from 'react';
+import { Entity } from '@strapi/types';
+interface PseudoEvent {
+    target: {
+        value: string;
+    };
+}
+interface ApiTokenPermissionsContextValue {
+    selectedAction: string[] | null;
+    routes: string[];
+    selectedActions: string[];
+    data: {
+        allActionsIds: Entity.ID[];
+        permissions: {
+            apiId: string;
+            label: string;
+            controllers: {
+                controller: string;
+                actions: {
+                    actionId: string;
+                    action: string;
+                };
+            }[];
+        }[];
+    };
+    onChange: ({ target: { value } }: PseudoEvent) => void;
+    onChangeSelectAll: ({ target: { value } }: PseudoEvent) => void;
+    setSelectedAction: ({ target: { value } }: PseudoEvent) => void;
+}
+interface ApiTokenPermissionsContextProviderProps extends ApiTokenPermissionsContextValue {
+    children: React.ReactNode[];
+}
+declare const ApiTokenPermissionsProvider: ({ children, ...rest }: ApiTokenPermissionsContextProviderProps) => import("react/jsx-runtime").JSX.Element;
+declare const useApiTokenPermissions: () => ApiTokenPermissionsContextValue;
+export { ApiTokenPermissionsProvider, useApiTokenPermissions };
+export type { ApiTokenPermissionsContextValue, ApiTokenPermissionsContextProviderProps };

package/dist/admin/src/contexts/configuration.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="react" />
+export interface ConfigurationContextValue {
+    logos: {
+        auth: {
+            custom?: string | null;
+            default: string;
+        };
+        menu: {
+            custom?: string | null;
+            default: string;
+        };
+    };
+    showTutorials: boolean;
+    showReleaseNotification: boolean;
+    updateProjectSettings: (settings: {
+        authLogo?: string;
+        menuLogo?: string;
+    }) => void;
+}
+declare const ConfigurationContextProvider: {
+    (props: ConfigurationContextValue & {
+        children: import("react").ReactNode;
+    }): JSX.Element;
+    displayName: string;
+};
+declare const useConfiguration: () => ConfigurationContextValue;
+export { ConfigurationContextProvider, useConfiguration };

package/dist/admin/src/contexts/themeToggle.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="react" />
+import { DefaultTheme } from 'styled-components';
+type ThemeName = 'light' | 'dark' | 'system';
+type NonSystemThemeName = Exclude<ThemeName, 'system'>;
+interface ThemeToggleContextContextValue {
+    currentTheme?: ThemeName;
+    onChangeTheme?: (nextTheme: ThemeName) => void;
+    themes?: {
+        dark: DefaultTheme;
+        light: DefaultTheme;
+    };
+    systemTheme?: NonSystemThemeName;
+}
+declare const ThemeToggleContextProvider: {
+    (props: ThemeToggleContextContextValue & {
+        children: import("react").ReactNode;
+    }): JSX.Element;
+    displayName: string;
+};
+declare const useThemeToggle: () => ThemeToggleContextContextValue;
+export { ThemeToggleContextProvider, useThemeToggle };
+export type { ThemeName, NonSystemThemeName, ThemeToggleContextContextValue };

package/dist/admin/src/core/apis/Components.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+export interface Component {
+    name: string;
+    Component: React.ComponentType;
+}
+export declare class Components {
+    components: Record<Component['name'], Component['Component']>;
+    constructor();
+    add(component: Component): void;
+}

package/dist/admin/src/core/apis/CustomFields.d.ts

@@ -0,0 +1,8 @@
+import type { CustomField, CustomFieldUID } from '@strapi/helper-plugin';
+export declare class CustomFields {
+    customFields: Record<CustomFieldUID, CustomField>;
+    constructor();
+    register(customFields: CustomField | CustomField[]): void;
+    getAll(): Record<CustomFieldUID, CustomField>;
+    get(uid: CustomFieldUID): CustomField | undefined;
+}

package/dist/admin/src/core/apis/Fields.d.ts

@@ -0,0 +1,10 @@
+import * as React from 'react';
+export interface Field {
+    type: string;
+    Component: React.ComponentType;
+}
+export declare class Fields {
+    fields: Record<Field['type'], Field['Component']>;
+    constructor();
+    add(field: Field): void;
+}

package/dist/admin/src/core/apis/Middlewares.d.ts

@@ -0,0 +1,9 @@
+import { Middleware } from '@reduxjs/toolkit';
+import { RootState } from '../store/configure';
+type TypedMiddleware = () => Middleware<object, RootState>;
+declare class Middlewares {
+    middlewares: Array<TypedMiddleware>;
+    constructor();
+    add(middleware: TypedMiddleware): void;
+}
+export { Middlewares, TypedMiddleware as Middleware };

package/dist/admin/src/core/apis/Plugin.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="react" />
+import { Plugin as IPlugin } from '@strapi/helper-plugin';
+export interface PluginConfig extends Pick<IPlugin, 'apis' | 'initializer' | 'injectionZones' | 'isReady' | 'name'> {
+    id: string;
+}
+export declare class Plugin implements IPlugin {
+    apis: PluginConfig['apis'];
+    initializer: PluginConfig['initializer'];
+    injectionZones: PluginConfig['injectionZones'];
+    isReady: PluginConfig['isReady'];
+    name: PluginConfig['name'];
+    pluginId: PluginConfig['id'];
+    constructor(pluginConf: PluginConfig);
+    getInjectedComponents(containerName: string, blockName: string): {
+        name: string;
+        Component: import("react").ComponentType<{}>;
+    }[];
+    injectComponent(containerName: string, blockName: string, component: ReturnType<IPlugin['getInjectedComponents']>[number]): void;
+}

package/dist/admin/src/core/apis/Reducers.d.ts

@@ -0,0 +1,10 @@
+import { Reducer, ReducersMapObject } from '@reduxjs/toolkit';
+interface ReducerConstructorArgs {
+    appReducers?: ReducersMapObject;
+}
+export declare class Reducers {
+    reducers: ReducersMapObject;
+    constructor({ appReducers }?: ReducerConstructorArgs);
+    add(reducerName: string, reducer: Reducer): void;
+}
+export {};

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

@@ -0,0 +1,29 @@
+import { Middleware, Reducer } from '@reduxjs/toolkit';
+/**
+ * @description This is the main store configuration function, injected Reducers use our legacy app.addReducer API,
+ * which we're trying to phase out. App Middlewares could potentially be improved...?
+ */
+declare const configureStoreImpl: (appMiddlewares?: Array<() => Middleware>, injectedReducers?: Record<string, Reducer>) => import("@reduxjs/toolkit/dist/configureStore").ToolkitStore<{
+    readonly admin_app: import("../../reducer").State;
+    readonly rbacProvider: import("../../components/RBACProvider").RBACState;
+    readonly 'content-manager_app': unknown;
+    readonly 'content-manager_listView': unknown;
+    readonly 'content-manager_rbacManager': unknown;
+    readonly 'content-manager_editViewLayoutManager': unknown;
+    readonly 'content-manager_editViewCrudReducer': unknown;
+}, import("redux").AnyAction, import("@reduxjs/toolkit").ThunkMiddleware<{
+    readonly admin_app: import("../../reducer").State;
+    readonly rbacProvider: import("../../components/RBACProvider").RBACState;
+    readonly 'content-manager_app': unknown;
+    readonly 'content-manager_listView': unknown;
+    readonly 'content-manager_rbacManager': unknown;
+    readonly 'content-manager_editViewLayoutManager': unknown;
+    readonly 'content-manager_editViewCrudReducer': unknown;
+}, import("redux").AnyAction>[]>;
+type Store = ReturnType<typeof configureStoreImpl> & {
+    asyncReducers: Record<string, Reducer>;
+    injectReducer: (key: string, asyncReducer: Reducer) => void;
+};
+type RootState = ReturnType<Store['getState']>;
+export { configureStoreImpl as configureStore };
+export type { RootState, Store };

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

@@ -0,0 +1,37 @@
+import { Selector } from '@reduxjs/toolkit';
+import { TypedUseSelectorHook } from 'react-redux';
+import type { RootState, Store } from './configure';
+type AppDispatch = Store['dispatch'];
+declare const useTypedDispatch: () => AppDispatch;
+declare const useTypedStore: () => Store;
+declare const useTypedSelector: TypedUseSelectorHook<RootState>;
+declare const createTypedSelector: <TResult>(selector: (state: {
+    readonly admin_app: import("../../reducer").State;
+    readonly rbacProvider: import("../../components/RBACProvider").RBACState;
+    readonly 'content-manager_app': unknown;
+    readonly 'content-manager_listView': unknown;
+    readonly 'content-manager_rbacManager': unknown;
+    readonly 'content-manager_editViewLayoutManager': unknown;
+    readonly 'content-manager_editViewCrudReducer': unknown;
+}, ...params: any[]) => TResult) => ((state: {
+    readonly admin_app: import("../../reducer").State;
+    readonly rbacProvider: import("../../components/RBACProvider").RBACState;
+    readonly 'content-manager_app': unknown;
+    readonly 'content-manager_listView': unknown;
+    readonly 'content-manager_rbacManager': unknown;
+    readonly 'content-manager_editViewLayoutManager': unknown;
+    readonly 'content-manager_editViewCrudReducer': unknown;
+}) => TResult) & import("reselect").OutputSelectorFields<(args_0: {
+    readonly admin_app: import("../../reducer").State;
+    readonly rbacProvider: import("../../components/RBACProvider").RBACState;
+    readonly 'content-manager_app': unknown;
+    readonly 'content-manager_listView': unknown;
+    readonly 'content-manager_rbacManager': unknown;
+    readonly 'content-manager_editViewLayoutManager': unknown;
+    readonly 'content-manager_editViewCrudReducer': unknown;
+}) => TResult, {
+    clearCache: () => void;
+}> & {
+    clearCache: () => void;
+};
+export { useTypedDispatch, useTypedStore, useTypedSelector, createTypedSelector };

package/dist/admin/src/core/utils/basename.d.ts

@@ -0,0 +1 @@
+export declare const getBasename: () => string;

package/dist/admin/src/core/utils/createHook.d.ts

@@ -0,0 +1,10 @@
+export type Handler = (...args: any[]) => any;
+export declare const createHook: () => {
+    register(fn: Handler): void;
+    delete(handler: Handler): void;
+    runWaterfall<T>(args: T, store?: any): T;
+    runWaterfallAsync<T_1>(args: T_1, store?: any): Promise<T_1>;
+    runSeries<T_2 extends any[]>(...args: T_2): any[];
+    runSeriesAsync<T_3 extends any[]>(...args: T_3): Promise<any[]>;
+    runParallel<T_4 extends any[]>(...args: T_4): Promise<any[]>;
+};

package/dist/admin/src/hooks/__mocks__/useAdminUsers.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="jest" />
+export declare const useAdminUsers: jest.Mock<any, any, any>;

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

@@ -0,0 +1,2 @@
+/// <reference types="jest" />
+export declare const useContentTypes: jest.Mock<any, any, any>;

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

@@ -0,0 +1,13 @@
+import type { FindAll, FindOne } from '../../../shared/contracts/roles';
+export type APIRolesQueryParams = FindOne.Request['params'] | (FindAll.Request['query'] & {
+    id?: never;
+});
+export declare const useAdminRoles: (params?: APIRolesQueryParams, queryOptions?: {}) => {
+    roles: (import("../../../shared/contracts/shared").SanitizedAdminRole & {
+        usersCount?: number | undefined;
+    })[];
+    error: unknown;
+    isError: boolean;
+    isLoading: boolean;
+    refetch: <TPageData>(options?: (import("react-query").RefetchOptions & import("react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("react-query").QueryObserverResult<FindOne.Response | FindAll.Response, unknown>>;
+};

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

@@ -0,0 +1,19 @@
+import * as Users from '../../../shared/contracts/user';
+export type APIUsersQueryParams = Users.FindOne.Params | (Users.FindAll.Request['query'] & {
+    id?: never;
+});
+export declare function useAdminUsers(params?: APIUsersQueryParams, queryOptions?: {}): {
+    users: import("../../../shared/contracts/shared").SanitizedAdminUser[];
+    pagination: boolean | null;
+    isLoading: boolean;
+    isError: boolean;
+    refetch: <TPageData>(options?: (import("react-query").RefetchOptions & import("react-query").RefetchQueryFilters<TPageData>) | undefined) => Promise<import("react-query").QueryObserverResult<import("../../../shared/contracts/shared").SanitizedAdminUser | {
+        results: import("../../../shared/contracts/shared").SanitizedAdminUser[];
+        pagination: {
+            page: number;
+            pageSize: number;
+            pageCount: number;
+            total: number;
+        };
+    }, unknown>>;
+};

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

@@ -0,0 +1,7 @@
+import { Component, ContentType } from '../../../shared/schema';
+export declare function useContentTypes(): {
+    isLoading: boolean;
+    components: Component[];
+    collectionTypes: ContentType[];
+    singleTypes: ContentType[];
+};

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

@@ -0,0 +1 @@
+export declare function useDebounce<TValue>(value: TValue, delay: number): TValue;

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

@@ -0,0 +1,6 @@
+export interface UseEnterpriseOptions<TCEData, TEEData, TCombinedData> {
+    defaultValue?: TCEData | TEEData | null;
+    combine?: (ceData: TCEData, eeData: TEEData) => TCEData | TEEData | TCombinedData;
+    enabled?: boolean;
+}
+export declare function useEnterprise<TCEData, TEEData, TCombinedData = unknown>(ceData: TCEData, eeCallback: () => Promise<TEEData>, { defaultValue, combine, enabled, }?: UseEnterpriseOptions<TCEData, TEEData, TCombinedData>): TCEData | TEEData | TCombinedData | null;

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

@@ -0,0 +1,10 @@
+import { Reducer } from '@reduxjs/toolkit';
+/**
+ * Inject a new reducer into the global redux-store.
+ *
+ * @export
+ * @param {string} namespace - Store namespace of the injected reducer
+ * @param {Function} reducer - Reducer function
+ * @return void
+ */
+export declare function useInjectReducer(namespace: string, reducer: Reducer): void;

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

@@ -0,0 +1 @@
+export declare const useLicenseLimitNotification: () => null;

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

@@ -0,0 +1,9 @@
+import { StrapiAppContextValue } from '@strapi/helper-plugin';
+type MenuItem = StrapiAppContextValue['menu'][number];
+export interface Menu {
+    generalSectionLinks: MenuItem[];
+    pluginsSectionLinks: MenuItem[];
+    isLoading: boolean;
+}
+declare const useMenu: () => Menu;
+export { useMenu };

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

@@ -0,0 +1,2 @@
+export * from './components/DefaultDocument';
+export * from './render';

package/dist/admin/src/layouts/AppLayout.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+interface AppLayoutProps {
+    children: React.ReactNode;
+    sideNav: React.ReactNode;
+}
+export declare const AppLayout: ({ children, sideNav }: AppLayoutProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/layouts/UnauthenticatedLayout.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+export declare const Column: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, import("@strapi/design-system").FlexProps<"div">, never>;
+interface LayoutContentProps {
+    children: React.ReactNode;
+}
+export declare const LayoutContent: ({ children }: LayoutContentProps) => import("react/jsx-runtime").JSX.Element;
+interface UnauthenticatedLayoutProps {
+    children: React.ReactNode;
+}
+export declare const UnauthenticatedLayout: ({ children }: UnauthenticatedLayoutProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/admin/src/pages/Admin.d.ts

@@ -0,0 +1,7 @@
+/**
+ *
+ * Admin
+ *
+ */
+declare const Admin: () => import("react/jsx-runtime").JSX.Element;
+export { Admin };

package/dist/admin/src/pages/HomePage.d.ts

@@ -0,0 +1,3 @@
+declare const HomePageCE: () => import("react/jsx-runtime").JSX.Element;
+declare const HomePage: () => import("react/jsx-runtime").JSX.Element | null;
+export { HomePage, HomePageCE };

package/dist/admin/src/pages/InstalledPluginsPage.d.ts

@@ -0,0 +1,3 @@
+declare const InstalledPluginsPage: () => import("react/jsx-runtime").JSX.Element;
+declare const ProtectedInstalledPluginsPage: () => import("react/jsx-runtime").JSX.Element;
+export { ProtectedInstalledPluginsPage, InstalledPluginsPage };

package/dist/admin/src/pages/InternalErrorPage.d.ts

@@ -0,0 +1,7 @@
+/**
+ * InternalErrorPage
+ *
+ * This is the page we show when the user gets a 500 error
+ *
+ */
+export declare const InternalErrorPage: () => import("react/jsx-runtime").JSX.Element;

package/dist/admin/src/pages/Marketplace/MarketplacePage.d.ts

@@ -0,0 +1,19 @@
+import { SortSelectProps } from './components/SortSelect';
+type NpmPackageType = 'plugin' | 'provider';
+interface MarketplacePageQuery {
+    collections?: string[];
+    categories?: string[];
+    npmPackageType?: NpmPackageType;
+    page?: number;
+    pageSize?: number;
+    search?: string;
+    sort?: SortSelectProps['sortQuery'];
+}
+interface TabQuery {
+    plugin: MarketplacePageQuery;
+    provider: MarketplacePageQuery;
+}
+declare const MarketplacePage: () => import("react/jsx-runtime").JSX.Element;
+declare const ProtectedMarketplacePage: () => import("react/jsx-runtime").JSX.Element;
+export { MarketplacePage, ProtectedMarketplacePage };
+export type { NpmPackageType, MarketplacePageQuery, TabQuery };

package/dist/admin/src/pages/Marketplace/components/NpmPackageCard.d.ts

@@ -0,0 +1,13 @@
+import { AppInfoContextValue } from '@strapi/helper-plugin';
+import type { Plugin, Provider } from '../hooks/useMarketplaceData';
+import type { NpmPackageType } from '../MarketplacePage';
+interface NpmPackageCardProps extends Pick<AppInfoContextValue, 'useYarn'> {
+    npmPackage: Plugin | Provider;
+    isInstalled: boolean;
+    isInDevelopmentMode: AppInfoContextValue['autoReload'];
+    npmPackageType: NpmPackageType;
+    strapiAppVersion: AppInfoContextValue['strapiVersion'];
+}
+declare const NpmPackageCard: ({ npmPackage, isInstalled, useYarn, isInDevelopmentMode, npmPackageType, strapiAppVersion, }: NpmPackageCardProps) => import("react/jsx-runtime").JSX.Element;
+export { NpmPackageCard };
+export type { NpmPackageCardProps };

package/dist/admin/src/pages/Marketplace/components/NpmPackagesFilters.d.ts

@@ -0,0 +1,13 @@
+import type { Categories, Collections, FilterTypes } from '../hooks/useMarketplaceData';
+import type { NpmPackageType, MarketplacePageQuery } from '../MarketplacePage';
+interface NpmPackagesFiltersProps {
+    handleSelectClear: (type: FilterTypes) => void;
+    handleSelectChange: (update: Partial<MarketplacePageQuery>) => void;
+    npmPackageType: NpmPackageType;
+    possibleCategories: Partial<Record<Categories, number>>;
+    possibleCollections: Partial<Record<Collections, number>>;
+    query: MarketplacePageQuery;
+}
+declare const NpmPackagesFilters: ({ handleSelectClear, handleSelectChange, npmPackageType, possibleCategories, possibleCollections, query, }: NpmPackagesFiltersProps) => import("react/jsx-runtime").JSX.Element;
+export { NpmPackagesFilters };
+export type { NpmPackagesFiltersProps };

package/dist/admin/src/pages/Marketplace/components/NpmPackagesGrid.d.ts

@@ -0,0 +1,13 @@
+import { AppInfoContextValue } from '@strapi/helper-plugin';
+import { NpmPackageCardProps } from './NpmPackageCard';
+import type { Plugin, Provider } from '../hooks/useMarketplaceData';
+interface NpmPackagesGridProps extends Pick<NpmPackageCardProps, 'npmPackageType' | 'useYarn'> {
+    debouncedSearch: string;
+    installedPackageNames: string[];
+    isInDevelopmentMode: AppInfoContextValue['autoReload'];
+    npmPackages?: Array<Plugin | Provider>;
+    status: 'idle' | 'loading' | 'error' | 'success';
+    strapiAppVersion?: NpmPackageCardProps['strapiAppVersion'];
+}
+declare const NpmPackagesGrid: ({ status, npmPackages, installedPackageNames, useYarn, isInDevelopmentMode, npmPackageType, strapiAppVersion, debouncedSearch, }: NpmPackagesGridProps) => import("react/jsx-runtime").JSX.Element;
+export { NpmPackagesGrid };