@wordpress/core-data 7.45.0 → 7.45.1-next.v.202605131032.0

package/build-types/index.d.ts

@@ -1,134 +1,76 @@
+import * as selectors from './selectors';
 /**
  * Store definition for the code data namespace.
  *
  * @see https://github.com/WordPress/gutenberg/blob/HEAD/packages/data/README.md#createReduxStore
  */
-export const store: import("@wordpress/data").StoreDescriptor<import("@wordpress/data").ReduxStoreConfig<any, {
-    __unstableAcquireStoreLock: (store: any, path: any, { exclusive }: {
-        exclusive: any;
-    }) => () => Promise<any>;
-    __unstableReleaseStoreLock: (lock: any) => () => void;
-    receiveUserQuery(queryID: string, users: any[] | any): any;
+export declare const store: import("@wordpress/data").StoreDescriptor<import("@wordpress/data").ReduxStoreConfig<unknown, {
+    receiveUserQuery(queryID: string, users: Array | any): any;
     receiveCurrentUser(currentUser: any): any;
-    addEntities(entities: any[]): any;
-    receiveEntityRecords(kind: string, name: string, records: any[] | any, query?: any | null, invalidateCache?: boolean | null, edits?: any | null, meta?: any | null): any;
+    addEntities(entities: Array): any;
+    receiveEntityRecords(kind: string, name: string, records: Array | any, query?: any | null, invalidateCache?: boolean | null, edits?: any | null, meta?: any | null): any;
     receiveCurrentTheme(currentTheme: any): any;
     __experimentalReceiveCurrentGlobalStylesId(currentGlobalStylesId: string): any;
     __experimentalReceiveThemeBaseGlobalStyles(stylesheet: string, globalStyles: any): any;
-    __experimentalReceiveThemeGlobalStyleVariations(stylesheet: string, variations: any[]): any;
+    __experimentalReceiveThemeGlobalStyleVariations(stylesheet: string, variations: Array): any;
     receiveThemeSupports(): any;
-    receiveThemeGlobalStyleRevisions(currentId: number, revisions: any[]): any;
+    receiveThemeGlobalStyleRevisions(currentId: number, revisions: Array): any;
     receiveEmbedPreview(url: string, preview: any): any;
-    receiveUploadPermissions(hasUploadPermissions: boolean): any;
-    receiveUserPermission(key: string, isAllowed: boolean): any;
-    receiveUserPermissions(permissions: {
-        [x: string]: boolean;
-    }): any;
-    receiveAutosaves(postId: number, autosaves: any[] | any): any;
-    receiveNavigationFallbackId(fallbackId: integer): any;
-    receiveDefaultTemplateId(query: any, templateId: string): any;
-    setSyncConnectionStatus(kind: string, name: string, key: number | string | null, status: any | null): any;
     deleteEntityRecord: (kind: string, name: string, recordId: number | string, query: any | null, { __unstableFetch, throwOnError }?: {
-        __unstableFetch?: Function | undefined;
-        throwOnError?: boolean | undefined;
+        __unstableFetch?: Function;
+        throwOnError?: boolean;
     }) => ({ dispatch, resolveSelect }: {
         dispatch: any;
         resolveSelect: any;
     }) => Promise<boolean | undefined>;
     editEntityRecord: (kind: string, name: string, recordId: number | string, edits: any, options?: {
-        undoIgnore?: boolean | undefined;
+        undoIgnore?: boolean;
     }) => any;
     clearEntityRecordEdits: (kind: string, name: string, recordId: number | string) => any;
     undo: () => ({ select, dispatch }: {
-        select: any;
         dispatch: any;
+        select: any;
     }) => void;
     redo: () => ({ select, dispatch }: {
-        select: any;
         dispatch: any;
+        select: any;
     }) => void;
     __unstableCreateUndoLevel: () => any;
-    saveEntityRecord: (kind: string, name: string, record: any, { isAutosave, __unstableFetch, throwOnError, }?: {
-        isAutosave?: boolean | undefined;
-        __unstableFetch?: Function | undefined;
-        throwOnError?: boolean | undefined;
+    saveEntityRecord: (kind: string, name: string, record: any, options?: {
+        isAutosave?: boolean;
+        __unstableFetch?: Function;
+        throwOnError?: boolean;
     }) => ({ select, resolveSelect, dispatch }: {
-        select: any;
-        resolveSelect: any;
         dispatch: any;
+        resolveSelect: any;
+        select: any;
     }) => Promise<any>;
-    __experimentalBatch: (requests: any[]) => (thunkArgs: any) => Promise<any>;
+    __experimentalBatch: (requests: Array) => (thunkArgs: any) => Promise;
     saveEditedEntityRecord: (kind: string, name: string, recordId: any, options?: any | undefined) => ({ select, dispatch, resolveSelect }: {
-        select: any;
         dispatch: any;
         resolveSelect: any;
-    }) => Promise<any>;
-    __experimentalSaveSpecifiedEntityEdits: (kind: string, name: string, recordId: number | string, itemsToSave: any[], options: any) => ({ select, dispatch, resolveSelect }: {
         select: any;
+    }) => Promise<any>;
+    __experimentalSaveSpecifiedEntityEdits: (kind: string, name: string, recordId: number | string, itemsToSave: Array, options: any) => ({ select, dispatch, resolveSelect }: {
         dispatch: any;
         resolveSelect: any;
+        select: any;
     }) => Promise<any>;
-    receiveRevisions: (kind: string, name: string, recordKey: number | string, records: any[] | any, query: any | null, invalidateCache: (boolean | null) | undefined, meta: any | null) => ({ dispatch, resolveSelect }: {
+    receiveUploadPermissions(hasUploadPermissions: boolean): any;
+    receiveUserPermission(key: string, isAllowed: boolean): any;
+    receiveUserPermissions(permissions: Record<string, boolean>): any;
+    receiveAutosaves(postId: number, autosaves: Array | any): any;
+    receiveNavigationFallbackId(fallbackId: integer): any;
+    receiveDefaultTemplateId(query: any, templateId: string): any;
+    receiveRevisions: (kind: string, name: string, recordKey: number | string, records: Array | any, query: any | null, invalidateCache: (boolean | null) | undefined, meta: any | null) => ({ dispatch, resolveSelect }: {
         dispatch: any;
         resolveSelect: any;
     }) => Promise<void>;
-    saveComment: (data: Partial<import("./entity-types").Comment<"edit">>, options?: {
-        throwOnError?: boolean;
-    }) => Promise<void>;
-    saveGlobalStyles: (data: Partial<import("./entity-types").GlobalStylesRevision<"edit">>, options?: {
-        throwOnError?: boolean;
-    }) => Promise<void>;
-    saveMedia: (data: Partial<import("./entity-types").Attachment<"edit">>, options?: {
-        throwOnError?: boolean;
-    }) => Promise<void>;
-    saveMenu: (data: Partial<import("./entity-types").NavMenu<"edit">>, options?: {
-        throwOnError?: boolean;
-    }) => Promise<void>;
-    saveMenuItem: (data: Partial<import("./entity-types").NavMenuItem<"edit">>, options?: {
-        throwOnError?: boolean;
-    }) => Promise<void>;
-    saveMenuLocation: (data: Partial<import("./entity-types").MenuLocation<"edit">>, options?: {
-        throwOnError?: boolean;
-    }) => Promise<void>;
-    savePlugin: (data: Partial<import("./entity-types").Plugin<"edit">>, options?: {
-        throwOnError?: boolean;
-    }) => Promise<void>;
-    savePostType: (data: Partial<import("./entity-types").Type<"edit">>, options?: {
-        throwOnError?: boolean;
-    }) => Promise<void>;
-    saveRevision: (data: Partial<import("./entity-types").PostRevision<"edit">>, options?: {
-        throwOnError?: boolean;
-    }) => Promise<void>;
-    saveSidebar: (data: Partial<import("./entity-types").Sidebar<"edit">>, options?: {
-        throwOnError?: boolean;
-    }) => Promise<void>;
-    saveSite: (data: Partial<import("./entity-types").Settings<"edit">>, options?: {
-        throwOnError?: boolean;
-    }) => Promise<void>;
-    saveStatus: (data: Partial<import("./entity-types").PostStatusObject<"edit">>, options?: {
-        throwOnError?: boolean;
-    }) => Promise<void>;
-    saveTaxonomy: (data: Partial<import("./entity-types").Taxonomy<"edit">>, options?: {
-        throwOnError?: boolean;
-    }) => Promise<void>;
-    saveTerm: (data: Partial<import("./entity-types").Term<"edit">>, options?: {
-        throwOnError?: boolean;
-    }) => Promise<void>;
-    saveTheme: (data: Partial<import("./entity-types").Theme<"edit">>, options?: {
-        throwOnError?: boolean;
-    }) => Promise<void>;
-    saveUnstableBase: (data: Partial<import("./entity-types").UnstableBase<"edit">>, options?: {
-        throwOnError?: boolean;
-    }) => Promise<void>;
-    saveUser: (data: Partial<import("./entity-types").User<"edit">>, options?: {
-        throwOnError?: boolean;
-    }) => Promise<void>;
-    saveWidget: (data: Partial<import("./entity-types").Widget<"edit">>, options?: {
-        throwOnError?: boolean;
-    }) => Promise<void>;
-    saveWidgetType: (data: Partial<import("./entity-types").WidgetType<"edit">>, options?: {
-        throwOnError?: boolean;
-    }) => Promise<void>;
+    setSyncConnectionStatus(kind: string, name: string, key: number | string | null, status: any | null): any;
+    __unstableAcquireStoreLock: (store: any, path: any, { exclusive }: {
+        exclusive: any;
+    }) => () => Promise<unknown>;
+    __unstableReleaseStoreLock: (lock: any) => () => void;
     deleteComment: (id: number | string, query?: {
         [x: string]: any;
     }, options?: {
@@ -224,17 +166,100 @@ export const store: import("@wordpress/data").StoreDescriptor<import("@wordpress
     }, options?: {
         throwOnError?: boolean;
     }) => Promise<void>;
+    saveComment: (data: Partial<import("./entity-types").Comment<"edit">>, options?: {
+        throwOnError?: boolean;
+    }) => Promise<void>;
+    saveGlobalStyles: (data: Partial<import("./entity-types").GlobalStylesRevision<"edit">>, options?: {
+        throwOnError?: boolean;
+    }) => Promise<void>;
+    saveMedia: (data: Partial<import("./entity-types").Attachment<"edit">>, options?: {
+        throwOnError?: boolean;
+    }) => Promise<void>;
+    saveMenu: (data: Partial<import("./entity-types").NavMenu<"edit">>, options?: {
+        throwOnError?: boolean;
+    }) => Promise<void>;
+    saveMenuItem: (data: Partial<import("./entity-types").NavMenuItem<"edit">>, options?: {
+        throwOnError?: boolean;
+    }) => Promise<void>;
+    saveMenuLocation: (data: Partial<import("./entity-types").MenuLocation<"edit">>, options?: {
+        throwOnError?: boolean;
+    }) => Promise<void>;
+    savePlugin: (data: Partial<import("./entity-types").Plugin<"edit">>, options?: {
+        throwOnError?: boolean;
+    }) => Promise<void>;
+    savePostType: (data: Partial<import("./entity-types").Type<"edit">>, options?: {
+        throwOnError?: boolean;
+    }) => Promise<void>;
+    saveRevision: (data: Partial<import("./entity-types").PostRevision<"edit">>, options?: {
+        throwOnError?: boolean;
+    }) => Promise<void>;
+    saveSidebar: (data: Partial<import("./entity-types").Sidebar<"edit">>, options?: {
+        throwOnError?: boolean;
+    }) => Promise<void>;
+    saveSite: (data: Partial<import("./entity-types").Settings<"edit">>, options?: {
+        throwOnError?: boolean;
+    }) => Promise<void>;
+    saveStatus: (data: Partial<import("./entity-types").PostStatusObject<"edit">>, options?: {
+        throwOnError?: boolean;
+    }) => Promise<void>;
+    saveTaxonomy: (data: Partial<import("./entity-types").Taxonomy<"edit">>, options?: {
+        throwOnError?: boolean;
+    }) => Promise<void>;
+    saveTerm: (data: Partial<import("./entity-types").Term<"edit">>, options?: {
+        throwOnError?: boolean;
+    }) => Promise<void>;
+    saveTheme: (data: Partial<import("./entity-types").Theme<"edit">>, options?: {
+        throwOnError?: boolean;
+    }) => Promise<void>;
+    saveUnstableBase: (data: Partial<import("./entity-types").UnstableBase<"edit">>, options?: {
+        throwOnError?: boolean;
+    }) => Promise<void>;
+    saveUser: (data: Partial<import("./entity-types").User<"edit">>, options?: {
+        throwOnError?: boolean;
+    }) => Promise<void>;
+    saveWidget: (data: Partial<import("./entity-types").Widget<"edit">>, options?: {
+        throwOnError?: boolean;
+    }) => Promise<void>;
+    saveWidgetType: (data: Partial<import("./entity-types").WidgetType<"edit">>, options?: {
+        throwOnError?: boolean;
+    }) => Promise<void>;
 }, {
+    isRequestingEmbedPreview: {
+        (state: selectors.State, url: string): boolean;
+        isRegistrySelector?: boolean;
+        registry?: any;
+    };
     getAuthors(state: selectors.State, query?: selectors.GetRecordsHttpQuery): import("./entity-types").User[];
-    getCurrentUser(state: selectors.State): import("./entity-types").User<"view">;
+    getCurrentUser(state: selectors.State): import("./entity-types").User<'view'>;
+    getUserQueryResults: ((state: selectors.State, queryID: string) => import("./entity-types").User<'edit'>[]) & import("rememo").EnhancedSelector;
     getEntitiesByKind(state: selectors.State, kind: string): Array<any>;
+    getEntitiesConfig: ((state: selectors.State, kind: string) => Array<any>) & import("rememo").EnhancedSelector;
     getEntity(state: selectors.State, kind: string, name: string): any;
     getEntityConfig(state: selectors.State, kind: string, name: string): any;
+    getEntityRecord: selectors.GetEntityRecord;
     hasEntityRecord(state: selectors.State, kind: string, name: string, key?: string | number, query?: selectors.GetRecordsHttpQuery): boolean;
     __experimentalGetEntityRecordNoResolver<EntityRecord extends import("./entity-types").EntityRecord<any>>(state: selectors.State, kind: string, name: string, key: string | number): EntityRecord | undefined;
+    getRawEntityRecord: (<EntityRecord extends import("./entity-types").EntityRecord<any>>(state: selectors.State, kind: string, name: string, key: string | number) => EntityRecord | undefined) & import("rememo").EnhancedSelector;
     hasEntityRecords(state: selectors.State, kind: string, name: string, query?: selectors.GetRecordsHttpQuery): boolean;
+    getEntityRecords: selectors.GetEntityRecords;
+    getEntityRecordsTotalItems: (state: selectors.State, kind: string, name: string, query: selectors.GetRecordsHttpQuery) => number | null;
+    getEntityRecordsTotalPages: (state: selectors.State, kind: string, name: string, query: selectors.GetRecordsHttpQuery) => number | null;
+    __experimentalGetDirtyEntityRecords: ((state: selectors.State) => Array<{
+        title: string;
+        key: string | number;
+        name: string;
+        kind: string;
+    }>) & import("rememo").EnhancedSelector;
+    __experimentalGetEntitiesBeingSaved: ((state: selectors.State) => Array<{
+        title: string;
+        key: string | number;
+        name: string;
+        kind: string;
+    }>) & import("rememo").EnhancedSelector;
     getEntityRecordEdits(state: selectors.State, kind: string, name: string, recordId: string | number): any;
+    getEntityRecordNonTransientEdits: ((state: selectors.State, kind: string, name: string, recordId: string | number) => any) & import("rememo").EnhancedSelector;
     hasEditsForEntityRecord(state: selectors.State, kind: string, name: string, recordId: string | number): boolean;
+    getEditedEntityRecord: (<EntityRecord extends import("./entity-types").EntityRecord<any>>(state: selectors.State, kind: string, name: string, recordId: string | number) => import("./entity-types").Updatable<EntityRecord> | false) & import("rememo").EnhancedSelector;
     isAutosavingEntityRecord(state: selectors.State, kind: string, name: string, recordId: string | number): boolean;
     isSavingEntityRecord(state: selectors.State, kind: string, name: string, recordId: string | number): boolean;
     isDeletingEntityRecord(state: selectors.State, kind: string, name: string, recordId: string | number): boolean;
@@ -257,6 +282,11 @@ export const store: import("@wordpress/data").StoreDescriptor<import("@wordpress
     canUserEditEntityRecord(state: selectors.State, kind: string, name: string, recordId: string | number): boolean | undefined;
     getAutosaves(state: selectors.State, postType: string, postId: string | number): Array<any> | undefined;
     getAutosave<EntityRecord extends import("./entity-types").EntityRecord<any>>(state: selectors.State, postType: string, postId: string | number, authorId: string | number): EntityRecord | undefined;
+    hasFetchedAutosaves: {
+        (state: selectors.State, postType: string, postId: string | number): boolean;
+        isRegistrySelector?: boolean;
+        registry?: any;
+    };
     getReferenceByDistinctEdits(state: any): any;
     __experimentalGetCurrentThemeBaseGlobalStyles(state: selectors.State): any;
     __experimentalGetCurrentThemeGlobalStylesVariations(state: selectors.State): string | null;
@@ -269,86 +299,58 @@ export const store: import("@wordpress/data").StoreDescriptor<import("@wordpress
         is_custom?: boolean;
         ignore_empty?: boolean;
     }): string;
+    getRevisions: (state: selectors.State, kind: string, name: string, recordKey: string | number, query?: selectors.GetRecordsHttpQuery) => (Record<import("./entity-types").Context, Record<number, import("./entity-types").GlobalStylesRevision>> | Record<import("./entity-types").Context, Record<number, import("./entity-types").PostRevision>>)[] | null;
     hasRevision(state: selectors.State, kind: string, name: string, recordKey: string | number, revisionKey: string | number, query?: selectors.GetRecordsHttpQuery): boolean;
+    getRevision: ((state: selectors.State, kind: string, name: string, recordKey: string | number, revisionKey: string | number, query?: selectors.GetRecordsHttpQuery) => (Record<import("./entity-types").Context, Record<number, import("./entity-types").GlobalStylesRevision>> | Record<import("./entity-types").Context, Record<number, import("./entity-types").PostRevision>>) | Record<PropertyKey, never> | undefined) & import("rememo").EnhancedSelector;
     getSyncConnectionStatus(state: selectors.State): import("@wordpress/sync").ConnectionStatus | undefined;
-    isRequestingEmbedPreview: {
-        (state: selectors.State, url: string): boolean;
-        isRegistrySelector?: boolean;
-        registry?: any;
-    };
-    getUserQueryResults: ((state: selectors.State, queryID: string) => import("./entity-types").User<"edit">[]) & import("rememo").EnhancedSelector;
-    getEntitiesConfig: ((state: selectors.State, kind: string) => Array<any>) & import("rememo").EnhancedSelector;
-    getEntityRecord: selectors.GetEntityRecord;
-    getRawEntityRecord: (<EntityRecord extends import("./entity-types").EntityRecord<any>>(state: selectors.State, kind: string, name: string, key: string | number) => EntityRecord | undefined) & import("rememo").EnhancedSelector;
-    getEntityRecords: selectors.GetEntityRecords;
-    getEntityRecordsTotalItems: (state: selectors.State, kind: string, name: string, query: selectors.GetRecordsHttpQuery) => number | null;
-    getEntityRecordsTotalPages: (state: selectors.State, kind: string, name: string, query: selectors.GetRecordsHttpQuery) => number | null;
-    __experimentalGetDirtyEntityRecords: ((state: selectors.State) => Array<{
-        title: string;
-        key: string | number;
-        name: string;
-        kind: string;
-    }>) & import("rememo").EnhancedSelector;
-    __experimentalGetEntitiesBeingSaved: ((state: selectors.State) => Array<{
-        title: string;
-        key: string | number;
-        name: string;
-        kind: string;
-    }>) & import("rememo").EnhancedSelector;
-    getEntityRecordNonTransientEdits: ((state: selectors.State, kind: string, name: string, recordId: string | number) => any) & import("rememo").EnhancedSelector;
-    getEditedEntityRecord: (<EntityRecord extends import("./entity-types").EntityRecord<any>>(state: selectors.State, kind: string, name: string, recordId: string | number) => import("./entity-types").Updatable<EntityRecord> | false) & import("rememo").EnhancedSelector;
-    hasFetchedAutosaves: {
-        (state: selectors.State, postType: string, postId: string | number): boolean;
-        isRegistrySelector?: boolean;
-        registry?: any;
-    };
-    getRevisions: (state: selectors.State, kind: string, name: string, recordKey: string | number, query?: selectors.GetRecordsHttpQuery) => (Record<import("./entity-types").Context, Record<number, import("./entity-types").PostRevision>> | Record<import("./entity-types").Context, Record<number, import("./entity-types").GlobalStylesRevision>>)[] | null;
-    getRevision: ((state: selectors.State, kind: string, name: string, recordKey: string | number, revisionKey: string | number, query?: selectors.GetRecordsHttpQuery) => (Record<import("./entity-types").Context, Record<number, import("./entity-types").PostRevision>> | Record<import("./entity-types").Context, Record<number, import("./entity-types").GlobalStylesRevision>>) | Record<PropertyKey, never> | undefined) & import("rememo").EnhancedSelector;
     getComment: (state: selectors.State, id: number | string, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Comment<"edit"> | undefined;
+    getComments: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Comment<"edit">[] | null;
     getGlobalStyles: (state: selectors.State, id: number | string, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").GlobalStylesRevision<"edit"> | undefined;
     getMedia: (state: selectors.State, id: number | string, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Attachment<"edit"> | undefined;
+    getMediaItems: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Attachment<"edit">[] | null;
     getMenu: (state: selectors.State, id: number | string, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").NavMenu<"edit"> | undefined;
     getMenuItem: (state: selectors.State, id: number | string, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").NavMenuItem<"edit"> | undefined;
+    getMenuItems: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").NavMenuItem<"edit">[] | null;
     getMenuLocation: (state: selectors.State, id: number | string, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").MenuLocation<"edit"> | undefined;
+    getMenuLocations: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").MenuLocation<"edit">[] | null;
+    getMenus: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").NavMenu<"edit">[] | null;
     getPlugin: (state: selectors.State, id: number | string, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Plugin<"edit"> | undefined;
+    getPlugins: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Plugin<"edit">[] | null;
     getPostType: (state: selectors.State, id: number | string, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Type<"edit"> | undefined;
+    getPostTypes: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Type<"edit">[] | null;
     getSidebar: (state: selectors.State, id: number | string, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Sidebar<"edit"> | undefined;
+    getSidebars: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Sidebar<"edit">[] | null;
     getSite: (state: selectors.State, id: number | string, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Settings<"edit"> | undefined;
+    getSites: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Settings<"edit">[] | null;
     getStatus: (state: selectors.State, id: number | string, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").PostStatusObject<"edit"> | undefined;
+    getStatuses: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").PostStatusObject<"edit">[] | null;
+    getTaxonomies: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Taxonomy<"edit">[] | null;
     getTaxonomy: (state: selectors.State, id: number | string, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Taxonomy<"edit"> | undefined;
     getTerm: (state: selectors.State, id: number | string, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Term<"edit"> | undefined;
+    getTerms: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Term<"edit">[] | null;
     getTheme: (state: selectors.State, id: number | string, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Theme<"edit"> | undefined;
+    getThemes: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Theme<"edit">[] | null;
     getUnstableBase: (state: selectors.State, id: number | string, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").UnstableBase<"edit"> | undefined;
+    getUnstableBases: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").UnstableBase<"edit">[] | null;
     getUser: (state: selectors.State, id: number | string, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").User<"edit"> | undefined;
+    getUsers: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").User<"edit">[] | null;
     getWidget: (state: selectors.State, id: number | string, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Widget<"edit"> | undefined;
     getWidgetType: (state: selectors.State, id: number | string, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").WidgetType<"edit"> | undefined;
-    getComments: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Comment<"edit">[] | null;
-    getMediaItems: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Attachment<"edit">[] | null;
-    getMenus: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").NavMenu<"edit">[] | null;
-    getMenuItems: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").NavMenuItem<"edit">[] | null;
-    getMenuLocations: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").MenuLocation<"edit">[] | null;
-    getPlugins: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Plugin<"edit">[] | null;
-    getPostTypes: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Type<"edit">[] | null;
-    getSidebars: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Sidebar<"edit">[] | null;
-    getSites: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Settings<"edit">[] | null;
-    getStatuses: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").PostStatusObject<"edit">[] | null;
-    getTaxonomies: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Taxonomy<"edit">[] | null;
-    getTerms: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Term<"edit">[] | null;
-    getThemes: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Theme<"edit">[] | null;
-    getUnstableBases: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").UnstableBase<"edit">[] | null;
-    getUsers: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").User<"edit">[] | null;
-    getWidgets: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Widget<"edit">[] | null;
     getWidgetTypes: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").WidgetType<"edit">[] | null;
+    getWidgets: (state: selectors.State, query?: selectors.GetRecordsHttpQuery) => import("./entity-types").Widget<"edit">[] | null;
 }>>;
-export { SelectionType } from "./utils/crdt-user-selections";
-export { SelectionDirection } from "./types";
-export { default as EntityProvider } from "./entity-provider";
-export * from "./entity-provider";
-export * from "./entity-types";
-export * from "./awareness/types";
-export * from "./fetch";
-export * from "./hooks";
-export * from "./private-apis";
-export * from "./types";
-import * as selectors from './selectors';
+/**
+ * Enums cannot be exported private without losing the ability to narrow types
+ * based on their values (they blur to string type).
+ */
+export { SelectionType } from './utils/crdt-user-selections';
+export { SelectionDirection } from './types';
+export { default as EntityProvider } from './entity-provider';
+export * from './entity-provider';
+export * from './entity-types';
+export * from './awareness/types';
+export * from './fetch';
+export * from './hooks';
+export * from './private-apis';
+export * from './types';
 //# sourceMappingURL=index.d.ts.map

package/build-types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AA6HA;;;;GAIG;AACH;;;;;;;;;;;;;;;;;;;;;;4CAoBg9uB,OAAO;;;yBAAr/pB,YAAO,EAAC,YAAO,EAAC,yBAAW,EAAC,iBAAQ,EAAC;;;KAA4D,MAAe;;;KAA4B;uBAAi0E,YAAK,EAAC,YAAK,EAAC,yBAAS,EAAC,UAAM,EAAC;;KAAa;6BAA8qG,YAAK,EAAC,YAAK,EAAC,yBAAS;iBAAs4B;;;KAAqB;iBAA4R;;;KAAqB;;uBAAutC,YAAO,EAAC,YAAO,EAAC,WAAS,EAAC;;;;KAA4F,MAAe;;;;KAAoC;0BAAmrN,eAAS;6BAAgtC,YAAK,EAAC,YAAK,EAAC,aAAS,EAAC,yBAAQ,MAAc;;;;KAAoC;6CAAslC,YAAK,EAAC,YAAK,EAAC,yBAAS,EAAC,kBAAY,EAAC,YAAQ,MAAc;;;;KAAoC;uBAAgzJ,YAAK,EAAC,YAAK,EAAC,0BAAU,EAAC,oBAAQ,EAAC,iBAAM,EAAC,6CAAwB,EAAC,gBAAK,MAAc;;;KAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAtlU,sBAAc,EAAC,YAAc,EAAC,YAAc,EAAC,oCAA4B;iCAAu9B,sBAAc,EAAC,YAAc,EAAC,YAAc,EAAC,oCAA4B;;;;;;;;;;;;;;;;;;;;mBAA4oqB,sBAAc,EAAC,YAAc,EAAC,YAAc,EAAC,0BAA4B,EAAC,qCAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IApBz9pC;;;;;;;;;;;2BAzHxC,aAAa"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":"AASA,OAAO,KAAK,SAAS,MAAM,aAAa,CAAC;AAoHzC;;;;GAIG;AACH,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAgD,CAAC;AAKnE;;;GAGG;AACH,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAE7C,OAAO,EAAE,OAAO,IAAI,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAC9D,cAAc,mBAAmB,CAAC;AAClC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,SAAS,CAAC"}

package/build-types/locks/actions.d.ts

@@ -1,7 +1,7 @@
 export default function createLocksActions(): {
     __unstableAcquireStoreLock: (store: any, path: any, { exclusive }: {
         exclusive: any;
-    }) => () => Promise<any>;
+    }) => () => Promise<unknown>;
     __unstableReleaseStoreLock: (lock: any) => () => void;
 };
 //# sourceMappingURL=actions.d.ts.map

package/build-types/locks/actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../src/locks/actions.js"],"names":[],"mappings":"AAKA;;;;;EAYC"}
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../src/locks/actions.js"],"names":[],"mappings":"AAKA,MAAM,CAAC,OAAO,UAAU,kBAAkB;;;;;EAYzC"}

package/build-types/locks/engine.d.ts

@@ -1,5 +1,5 @@
 export default function createLocks(): {
-    acquire: (store: any, path: any, exclusive: any) => Promise<any>;
+    acquire: (store: any, path: any, exclusive: any) => Promise<unknown>;
     release: (lock: any) => void;
 };
 //# sourceMappingURL=engine.d.ts.map

package/build-types/locks/engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/locks/engine.js"],"names":[],"mappings":"AAMA;;;EAoCC"}
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../../src/locks/engine.js"],"names":[],"mappings":"AAMA,MAAM,CAAC,OAAO,UAAU,WAAW;;;EAoClC"}

package/build-types/locks/reducer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reducer.d.ts","sourceRoot":"","sources":["../../src/locks/reducer.js"],"names":[],"mappings":"AAaA;;;;;;;GAOG;AACH,4DAwCC"}
+{"version":3,"file":"reducer.d.ts","sourceRoot":"","sources":["../../src/locks/reducer.js"],"names":[],"mappings":"AAaA;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,UAAU,KAAK,CAAE,KAAK,KAAgB,EAAE,MAAM,KAAA,OAwC3D"}

package/build-types/locks/selectors.d.ts

@@ -1,5 +1,5 @@
-export function getPendingLockRequests(state: any): any;
-export function isLockAvailable(state: any, store: any, path: any, { exclusive }: {
+export declare function getPendingLockRequests(state: any): any;
+export declare function isLockAvailable(state: any, store: any, path: any, { exclusive }: {
     exclusive: any;
 }): boolean;
 //# sourceMappingURL=selectors.d.ts.map

package/build-types/locks/selectors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"selectors.d.ts","sourceRoot":"","sources":["../../src/locks/selectors.js"],"names":[],"mappings":"AAUA,wDAEC;AAED;;YA0BC"}
+{"version":3,"file":"selectors.d.ts","sourceRoot":"","sources":["../../src/locks/selectors.js"],"names":[],"mappings":"AAUA,wBAAgB,sBAAsB,CAAE,KAAK,KAAA,OAE5C;AAED,wBAAgB,eAAe,CAAE,KAAK,KAAA,EAAE,KAAK,KAAA,EAAE,IAAI,KAAA,EAAE,EAAE,SAAS,EAAE;;CAAA,WA0BjE"}

package/build-types/locks/utils.d.ts

@@ -1,8 +1,8 @@
-export function deepCopyLocksTreePath(tree: any, path: any): any;
-export function getNode(tree: any, path: any): any;
-export function iteratePath(tree: any, path: any): Generator<any, void, unknown>;
-export function iterateDescendants(node: any): Generator<any, void, unknown>;
-export function hasConflictingLock({ exclusive }: {
+export declare function deepCopyLocksTreePath(tree: any, path: any): any;
+export declare function getNode(tree: any, path: any): any;
+export declare function iteratePath(tree: any, path: any): Generator<any, void, unknown>;
+export declare function iterateDescendants(node: any): Generator<unknown, void, unknown>;
+export declare function hasConflictingLock({ exclusive }: {
     exclusive: any;
 }, locks: any): boolean;
 //# sourceMappingURL=utils.d.ts.map

package/build-types/locks/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/locks/utils.js"],"names":[],"mappings":"AAAA,iEAeC;AAED,mDAUC;AAED,iFAWC;AAED,6EAOC;AAED;;wBAUC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/locks/utils.js"],"names":[],"mappings":"AAAA,wBAAgB,qBAAqB,CAAE,IAAI,KAAA,EAAE,IAAI,KAAA,OAehD;AAED,wBAAgB,OAAO,CAAE,IAAI,KAAA,EAAE,IAAI,KAAA,OAUlC;AAED,wBAAiB,WAAW,CAAE,IAAI,KAAA,EAAE,IAAI,KAAA,iCAWvC;AAED,wBAAiB,kBAAkB,CAAE,IAAI,KAAA,qCAOxC;AAED,wBAAgB,kBAAkB,CAAE,EAAE,SAAS,EAAE;;CAAA,EAAE,KAAK,KAAA,WAUvD"}

package/build-types/name.d.ts

@@ -4,5 +4,5 @@
  *
  * @type {string}
  */
-export const STORE_NAME: string;
+export declare const STORE_NAME: string;
 //# sourceMappingURL=name.d.ts.map

package/build-types/name.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"name.d.ts","sourceRoot":"","sources":["../src/name.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,yBAFU,MAAM,CAEiB"}
+{"version":3,"file":"name.d.ts","sourceRoot":"","sources":["../src/name.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,UAAU,EAFb,MAEsB,CAAC"}

package/build-types/private-actions.d.ts

@@ -7,7 +7,40 @@
  *
  * @return {Object} Action object.
  */
-export function receiveRegisteredPostMeta(postType: string, registeredPostMeta: any): any;
+export declare function receiveRegisteredPostMeta(postType: string, registeredPostMeta: any): any;
+export type Modifier = {
+    type?: string;
+    args?: any;
+};
+export type Edits = {
+    src?: string;
+    modifiers?: Modifier[];
+};
+/**
+ * @typedef {Object} Modifier
+ * @property {string} [type] - The type of modifier.
+ * @property {Object} [args] - The arguments of the modifier.
+ */
+/**
+ * @typedef {Object} Edits
+ * @property {string}     [src]       - The URL of the media item.
+ * @property {Modifier[]} [modifiers] - The modifiers to apply to the media item.
+ */
+/**
+ * Duplicates a media (attachment) entity record and, optionally, modifies it.
+ *
+ * @param {string}   recordId                Entity record ID.
+ * @param {Edits}    edits                   Edits to apply to the record.
+ * @param {Object}   options                 Options object.
+ * @param {Function} options.__unstableFetch Custom fetch function.
+ * @param {boolean}  options.throwOnError    Whether to throw an error if the request fails.
+ *
+ * @return {Promise} Promise resolving to the updated record.
+ */
+export declare const editMediaEntity: (recordId: string, edits?: Edits, { __unstableFetch, throwOnError }?: {
+    __unstableFetch: Function;
+    throwOnError: boolean;
+}) => Promise;
 /**
  * Returns an action object used to receive editor settings.
  *
@@ -15,7 +48,7 @@ export function receiveRegisteredPostMeta(postType: string, registeredPostMeta:
  *
  * @return {Object} Action object.
  */
-export function receiveEditorSettings(settings: any): any;
+export declare function receiveEditorSettings(settings: any): any;
 /**
  * Returns an action object used to receive editor assets.
  *
@@ -23,7 +56,15 @@ export function receiveEditorSettings(settings: any): any;
  *
  * @return {Object} Action object.
  */
-export function receiveEditorAssets(assets: any): any;
+export declare function receiveEditorAssets(assets: any): any;
+/**
+ * Returns an action object used to set whether collaboration is supported.
+ *
+ * @param {boolean} supported Whether collaboration is supported.
+ *
+ * @return {Object} Action object.
+ */
+export declare const setCollaborationSupported: (supported: boolean) => any;
 /**
  * Returns an action object used to receive view config.
  *
@@ -33,30 +74,5 @@ export function receiveEditorAssets(assets: any): any;
  *
  * @return {Object} Action object.
  */
-export function receiveViewConfig(kind: string, name: string, config: any): any;
-export function editMediaEntity(recordId: string, edits?: Edits, { __unstableFetch, throwOnError }?: {
-    __unstableFetch: Function;
-    throwOnError: boolean;
-}): Promise<any>;
-export function setCollaborationSupported(supported: boolean): any;
-export type Modifier = {
-    /**
-     * - The type of modifier.
-     */
-    type?: string | undefined;
-    /**
-     * - The arguments of the modifier.
-     */
-    args?: any;
-};
-export type Edits = {
-    /**
-     * - The URL of the media item.
-     */
-    src?: string | undefined;
-    /**
-     * - The modifiers to apply to the media item.
-     */
-    modifiers?: Modifier[] | undefined;
-};
+export declare function receiveViewConfig(kind: string, name: string, config: any): any;
 //# sourceMappingURL=private-actions.d.ts.map

package/build-types/private-actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"private-actions.d.ts","sourceRoot":"","sources":["../src/private-actions.js"],"names":[],"mappings":"AAUA;;;;;;;;GAQG;AACH,oDALW,MAAM,gCAWhB;AA8GD;;;;;;GAMG;AACH,0DAKC;AAED;;;;;;GAMG;AACH,sDAKC;AAeD;;;;;;;;GAQG;AACH,wCANW,MAAM,QACN,MAAM,oBAYhB;AA9IM,0CARI,MAAM,UACN,KAAK,sCAEb;IAA0B,eAAe;IACf,YAAY,EAA9B,OAAO;CAEf,gBAqFD;AAqCK,qDAJI,OAAO,OAQhB"}
+{"version":3,"file":"private-actions.d.ts","sourceRoot":"","sources":["../src/private-actions.js"],"names":[],"mappings":"AAUA;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CAAE,QAAQ,EALxC,MAKwC,EAAE,kBAAkB,KAAA,OAMtE;AAGE,YAAkB,QAAQ,GAC1B;IAAoB,IAAI,AAAxB,CACA,EADW,MAAM,CACjB;IAAoB,IAAI,AAAxB,CACF,MAAA;CAAA,CAAA;AAGE,YAAkB,KAAK,GACvB;IAAwB,GAAG,AAA3B,CACA,EADW,MAAM,CACjB;IAAwB,SAAS,AAAjC,CACF,EADa,UAAU,CACvB;CAAA,CAAA;AAVD;;;;GAIG;AAEH;;;;GAIG;AAEH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,aARjB,MAAM,UACN,KAAK,sCAEb;IAA0B,eAAe,WACzC;IAA0B,YAAY,EAA9B,OAAO,CAEf;CAAA,KAAS,OAqFV,CAAC;AAEH;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAE,QAAQ,KAAA,OAK9C;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAE,MAAM,KAAA,OAK1C;AAED;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,cAJ3B,OAAO,QAQhB,CAAC;AAEH;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAE,IAAI,EAN5B,MAM4B,EAAE,IAAI,EALlC,MAKkC,EAAE,MAAM,KAAA,OAOpD"}

package/build-types/private-apis.d.ts

@@ -1,2 +1,2 @@
-export const privateApis: {};
+export declare const privateApis: {};
 //# sourceMappingURL=private-apis.d.ts.map

package/build-types/private-apis.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"private-apis.d.ts","sourceRoot":"","sources":["../src/private-apis.js"],"names":[],"mappings":"AAeA,6BAA8B"}
+{"version":3,"file":"private-apis.d.ts","sourceRoot":"","sources":["../src/private-apis.js"],"names":[],"mappings":"AAeA,eAAO,MAAM,WAAW,IAAK,CAAC"}