@wordpress/core-data 4.14.1-next.d6164808d3.0 → 5.0.0

package/build-types/hooks/use-entity-record.d.ts

@@ -0,0 +1,124 @@
+import type { Status } from './constants';
+export interface EntityRecordResolution<RecordType> {
+    /** The requested entity record */
+    record: RecordType | null;
+    /** The edited entity record */
+    editedRecord: Partial<RecordType>;
+    /** Apply local (in-browser) edits to the edited entity record */
+    edit: (diff: Partial<RecordType>) => void;
+    /** Persist the edits to the server */
+    save: () => Promise<void>;
+    /**
+     * Is the record still being resolved?
+     */
+    isResolving: boolean;
+    /**
+     * Does the record have any local edits?
+     */
+    hasEdits: boolean;
+    /**
+     * Is the record resolved by now?
+     */
+    hasResolved: boolean;
+    /** Resolution status */
+    status: Status;
+}
+export interface Options {
+    /**
+     * Whether to run the query or short-circuit and return null.
+     *
+     * @default true
+     */
+    enabled: boolean;
+}
+/**
+ * Resolves the specified entity record.
+ *
+ * @since 6.1.0 Introduced in WordPress core.
+ *
+ * @param  kind     Kind of the entity, e.g. `root` or a `postType`. See rootEntitiesConfig in ../entities.ts for a list of available kinds.
+ * @param  name     Name of the entity, e.g. `plugin` or a `post`. See rootEntitiesConfig in ../entities.ts for a list of available names.
+ * @param  recordId ID of the requested entity record.
+ * @param  options  Optional hook options.
+ * @example
+ * ```js
+ * import { useEntityRecord } from '@wordpress/core-data';
+ *
+ * function PageTitleDisplay( { id } ) {
+ *   const { record, isResolving } = useEntityRecord( 'postType', 'page', id );
+ *
+ *   if ( isResolving ) {
+ *     return 'Loading...';
+ *   }
+ *
+ *   return record.title;
+ * }
+ *
+ * // Rendered in the application:
+ * // <PageTitleDisplay id={ 1 } />
+ * ```
+ *
+ * In the above example, when `PageTitleDisplay` is rendered into an
+ * application, the page and the resolution details will be retrieved from
+ * the store state using `getEntityRecord()`, or resolved if missing.
+ *
+ * @example
+ * ```js
+ * import { useDispatch } from '@wordpress/data';
+ * import { useCallback } from '@wordpress/element';
+ * import { __ } from '@wordpress/i18n';
+ * import { TextControl } from '@wordpress/components';
+ * import { store as noticeStore } from '@wordpress/notices';
+ * import { useEntityRecord } from '@wordpress/core-data';
+ *
+ * function PageRenameForm( { id } ) {
+ * 	const page = useEntityRecord( 'postType', 'page', id );
+ * 	const { createSuccessNotice, createErrorNotice } =
+ * 		useDispatch( noticeStore );
+ *
+ * 	const setTitle = useCallback( ( title ) => {
+ * 		page.edit( { title } );
+ * 	}, [ page.edit ] );
+ *
+ * 	if ( page.isResolving ) {
+ * 		return 'Loading...';
+ * 	}
+ *
+ * 	async function onRename( event ) {
+ * 		event.preventDefault();
+ * 		try {
+ * 			await page.save();
+ * 			createSuccessNotice( __( 'Page renamed.' ), {
+ * 				type: 'snackbar',
+ * 			} );
+ * 		} catch ( error ) {
+ * 			createErrorNotice( error.message, { type: 'snackbar' } );
+ * 		}
+ * 	}
+ *
+ * 	return (
+ * 		<form onSubmit={ onRename }>
+ * 			<TextControl
+ * 				label={ __( 'Name' ) }
+ * 				value={ page.editedRecord.title }
+ * 				onChange={ setTitle }
+ * 			/>
+ * 			<button type="submit">{ __( 'Save' ) }</button>
+ * 		</form>
+ * 	);
+ * }
+ *
+ * // Rendered in the application:
+ * // <PageRenameForm id={ 1 } />
+ * ```
+ *
+ * In the above example, updating and saving the page title is handled
+ * via the `edit()` and `save()` mutation helpers provided by
+ * `useEntityRecord()`;
+ *
+ * @return Entity record data.
+ * @template RecordType
+ */
+export default function useEntityRecord<RecordType>(kind: string, name: string, recordId: string | number, options?: Options): EntityRecordResolution<RecordType>;
+export declare function __experimentalUseEntityRecord(kind: string, name: string, recordId: any, options: any): EntityRecordResolution<unknown>;
+//# sourceMappingURL=use-entity-record.d.ts.map

package/build-types/hooks/use-entity-record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-entity-record.d.ts","sourceRoot":"","sources":["../../src/hooks/use-entity-record.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAE1C,MAAM,WAAW,sBAAsB,CAAE,UAAU;IAClD,kCAAkC;IAClC,MAAM,EAAE,UAAU,GAAG,IAAI,CAAC;IAE1B,+BAA+B;IAC/B,YAAY,EAAE,OAAO,CAAE,UAAU,CAAE,CAAC;IAEpC,iEAAiE;IACjE,IAAI,EAAE,CAAE,IAAI,EAAE,OAAO,CAAE,UAAU,CAAE,KAAM,IAAI,CAAC;IAE9C,sCAAsC;IACtC,IAAI,EAAE,MAAM,OAAO,CAAE,IAAI,CAAE,CAAC;IAE5B;;OAEG;IACH,WAAW,EAAE,OAAO,CAAC;IAErB;;OAEG;IACH,QAAQ,EAAE,OAAO,CAAC;IAElB;;OAEG;IACH,WAAW,EAAE,OAAO,CAAC;IAErB,wBAAwB;IACxB,MAAM,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,OAAO;IACvB;;;;OAIG;IACH,OAAO,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuFG;AACH,MAAM,CAAC,OAAO,UAAU,eAAe,CAAE,UAAU,EAClD,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,GAAG,MAAM,EACzB,OAAO,GAAE,OAA2B,GAClC,sBAAsB,CAAE,UAAU,CAAE,CAkDtC;AAED,wBAAgB,6BAA6B,CAC5C,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,GAAG,EACb,OAAO,EAAE,GAAG,mCAOZ"}

package/build-types/hooks/use-entity-records.d.ts

@@ -0,0 +1,49 @@
+import type { Options, EntityRecordResolution } from './use-entity-record';
+declare type EntityRecordsResolution<RecordType> = Omit<EntityRecordResolution<RecordType>, 'record'> & {
+    /** The requested entity record */
+    records: RecordType[] | null;
+};
+/**
+ * Resolves the specified entity records.
+ *
+ * @since 6.1.0 Introduced in WordPress core.
+ *
+ * @param  kind      Kind of the entity, e.g. `root` or a `postType`. See rootEntitiesConfig in ../entities.ts for a list of available kinds.
+ * @param  name      Name of the entity, e.g. `plugin` or a `post`. See rootEntitiesConfig in ../entities.ts for a list of available names.
+ * @param  queryArgs Optional HTTP query description for how to fetch the data, passed to the requested API endpoint.
+ * @param  options   Optional hook options.
+ * @example
+ * ```js
+ * import { useEntityRecord } from '@wordpress/core-data';
+ *
+ * function PageTitlesList() {
+ *   const { records, isResolving } = useEntityRecords( 'postType', 'page' );
+ *
+ *   if ( isResolving ) {
+ *     return 'Loading...';
+ *   }
+ *
+ *   return (
+ *     <ul>
+ *       {records.map(( page ) => (
+ *         <li>{ page.title }</li>
+ *       ))}
+ *     </ul>
+ *   );
+ * }
+ *
+ * // Rendered in the application:
+ * // <PageTitlesList />
+ * ```
+ *
+ * In the above example, when `PageTitlesList` is rendered into an
+ * application, the list of records and the resolution details will be retrieved from
+ * the store state using `getEntityRecords()`, or resolved if missing.
+ *
+ * @return Entity records data.
+ * @template RecordType
+ */
+export default function useEntityRecords<RecordType>(kind: string, name: string, queryArgs?: Record<string, unknown>, options?: Options): EntityRecordsResolution<RecordType>;
+export declare function __experimentalUseEntityRecords(kind: string, name: string, queryArgs: any, options: any): EntityRecordsResolution<unknown>;
+export {};
+//# sourceMappingURL=use-entity-records.d.ts.map

package/build-types/hooks/use-entity-records.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-entity-records.d.ts","sourceRoot":"","sources":["../../src/hooks/use-entity-records.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAC;AAE3E,aAAK,uBAAuB,CAAE,UAAU,IAAK,IAAI,CAChD,sBAAsB,CAAE,UAAU,CAAE,EACpC,QAAQ,CACR,GAAG;IACH,kCAAkC;IAClC,OAAO,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC;CAC7B,CAAC;AAIF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAM,CAAC,OAAO,UAAU,gBAAgB,CAAE,UAAU,EACnD,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,SAAS,GAAE,MAAM,CAAE,MAAM,EAAE,OAAO,CAAO,EACzC,OAAO,GAAE,OAA2B,GAClC,uBAAuB,CAAE,UAAU,CAAE,CAwBvC;AAED,wBAAgB,8BAA8B,CAC7C,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,GAAG,EACd,OAAO,EAAE,GAAG,oCAOZ"}

package/build-types/hooks/use-query-select.d.ts

@@ -0,0 +1,46 @@
+export declare const META_SELECTORS: string[];
+/**
+ * Like useSelect, but the selectors return objects containing
+ * both the original data AND the resolution info.
+ *
+ * @since 6.1.0 Introduced in WordPress core.
+ * @private
+ *
+ * @param {Function} mapQuerySelect see useSelect
+ * @param {Array}    deps           see useSelect
+ *
+ * @example
+ * ```js
+ * import { useQuerySelect } from '@wordpress/data';
+ * import { store as coreDataStore } from '@wordpress/core-data';
+ *
+ * function PageTitleDisplay( { id } ) {
+ *   const { data: page, isResolving } = useQuerySelect( ( query ) => {
+ *     return query( coreDataStore ).getEntityRecord( 'postType', 'page', id )
+ *   }, [ id ] );
+ *
+ *   if ( isResolving ) {
+ *     return 'Loading...';
+ *   }
+ *
+ *   return page.title;
+ * }
+ *
+ * // Rendered in the application:
+ * // <PageTitleDisplay id={ 10 } />
+ * ```
+ *
+ * In the above example, when `PageTitleDisplay` is rendered into an
+ * application, the page and the resolution details will be retrieved from
+ * the store state using the `mapSelect` callback on `useQuerySelect`.
+ *
+ * If the id prop changes then any page in the state for that id is
+ * retrieved. If the id prop doesn't change and other props are passed in
+ * that do change, the title will not change because the dependency is just
+ * the id.
+ * @see useSelect
+ *
+ * @return {QuerySelectResponse} Queried data.
+ */
+export default function useQuerySelect(mapQuerySelect: any, deps: any): any;
+//# sourceMappingURL=use-query-select.d.ts.map

package/build-types/hooks/use-query-select.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-query-select.d.ts","sourceRoot":"","sources":["../../src/hooks/use-query-select.ts"],"names":[],"mappings":"AAWA,eAAO,MAAM,cAAc,UAM1B,CAAC;AAgBF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAM,CAAC,OAAO,UAAU,cAAc,CAAE,cAAc,KAAA,EAAE,IAAI,KAAA,OAK3D"}

package/build-types/hooks/use-resource-permissions.d.ts

@@ -0,0 +1,99 @@
+import { Status } from './constants';
+interface GlobalResourcePermissionsResolution {
+    /** Can the current user create new resources of this type? */
+    canCreate: boolean;
+}
+interface SpecificResourcePermissionsResolution {
+    /** Can the current user update resources of this type? */
+    canUpdate: boolean;
+    /** Can the current user delete resources of this type? */
+    canDelete: boolean;
+}
+interface ResolutionDetails {
+    /** Resolution status */
+    status: Status;
+    /**
+     * Is the data still being resolved?
+     */
+    isResolving: boolean;
+}
+/**
+ * Is the data resolved by now?
+ */
+declare type HasResolved = boolean;
+declare type ResourcePermissionsResolution<IdType> = [
+    HasResolved,
+    ResolutionDetails & GlobalResourcePermissionsResolution & (IdType extends void ? SpecificResourcePermissionsResolution : {})
+];
+/**
+ * Resolves resource permissions.
+ *
+ * @since 6.1.0 Introduced in WordPress core.
+ *
+ * @param  resource The resource in question, e.g. media.
+ * @param  id       ID of a specific resource entry, if needed, e.g. 10.
+ *
+ * @example
+ * ```js
+ * import { useResourcePermissions } from '@wordpress/core-data';
+ *
+ * function PagesList() {
+ *   const { canCreate, isResolving } = useResourcePermissions( 'pages' );
+ *
+ *   if ( isResolving ) {
+ *     return 'Loading ...';
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       {canCreate ? (<button>+ Create a new page</button>) : false}
+ *       // ...
+ *     </div>
+ *   );
+ * }
+ *
+ * // Rendered in the application:
+ * // <PagesList />
+ * ```
+ *
+ * @example
+ * ```js
+ * import { useResourcePermissions } from '@wordpress/core-data';
+ *
+ * function Page({ pageId }) {
+ *   const {
+ *     canCreate,
+ *     canUpdate,
+ *     canDelete,
+ *     isResolving
+ *   } = useResourcePermissions( 'pages', pageId );
+ *
+ *   if ( isResolving ) {
+ *     return 'Loading ...';
+ *   }
+ *
+ *   return (
+ *     <div>
+ *       {canCreate ? (<button>+ Create a new page</button>) : false}
+ *       {canUpdate ? (<button>Edit page</button>) : false}
+ *       {canDelete ? (<button>Delete page</button>) : false}
+ *       // ...
+ *     </div>
+ *   );
+ * }
+ *
+ * // Rendered in the application:
+ * // <Page pageId={ 15 } />
+ * ```
+ *
+ * In the above example, when `PagesList` is rendered into an
+ * application, the appropriate permissions and the resolution details will be retrieved from
+ * the store state using `canUser()`, or resolved if missing.
+ *
+ * @return Entity records data.
+ * @template IdType
+ */
+export default function useResourcePermissions<IdType = void>(resource: string, id?: IdType): ResourcePermissionsResolution<IdType>;
+export declare function __experimentalUseResourcePermissions(resource: string, id?: unknown): ResourcePermissionsResolution<unknown>;
+export {};
+//# sourceMappingURL=use-resource-permissions.d.ts.map

package/build-types/hooks/use-resource-permissions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-resource-permissions.d.ts","sourceRoot":"","sources":["../../src/hooks/use-resource-permissions.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAGrC,UAAU,mCAAmC;IAC5C,8DAA8D;IAC9D,SAAS,EAAE,OAAO,CAAC;CACnB;AACD,UAAU,qCAAqC;IAC9C,0DAA0D;IAC1D,SAAS,EAAE,OAAO,CAAC;IACnB,0DAA0D;IAC1D,SAAS,EAAE,OAAO,CAAC;CACnB;AACD,UAAU,iBAAiB;IAC1B,wBAAwB;IACxB,MAAM,EAAE,MAAM,CAAC;IACf;;OAEG;IACH,WAAW,EAAE,OAAO,CAAC;CACrB;AAED;;GAEG;AACH,aAAK,WAAW,GAAG,OAAO,CAAC;AAE3B,aAAK,6BAA6B,CAAE,MAAM,IAAK;IAC9C,WAAW;IACX,iBAAiB,GAChB,mCAAmC,GACnC,CAAE,MAAM,SAAS,IAAI,GAAG,qCAAqC,GAAG,EAAE,CAAE;CACrE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmEG;AACH,MAAM,CAAC,OAAO,UAAU,sBAAsB,CAAE,MAAM,GAAG,IAAI,EAC5D,QAAQ,EAAE,MAAM,EAChB,EAAE,CAAC,EAAE,MAAM,GACT,6BAA6B,CAAE,MAAM,CAAE,CA0DzC;AAED,wBAAgB,oCAAoC,CACnD,QAAQ,EAAE,MAAM,EAChB,EAAE,CAAC,EAAE,OAAO,0CAOZ"}

package/build-types/index.d.ts

@@ -0,0 +1,131 @@
+/// <reference types="rememo" />
+/**
+ * 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/build-types/types").StoreDescriptor<import("@wordpress/data/build-types/types").ReduxStoreConfig<any, {
+    __unstableAcquireStoreLock: (store: any, path: any, { exclusive }: {
+        exclusive: any;
+    }) => () => Promise<any>;
+    __unstableReleaseStoreLock: (lock: any) => () => void;
+    receiveUserQuery(queryID: string, users: any): any;
+    receiveCurrentUser(currentUser: any): any;
+    addEntities(entities: any[]): any;
+    receiveEntityRecords(kind: string, name: string, records: any, query: any, invalidateCache: boolean | null | undefined, edits: any): any;
+    receiveCurrentTheme(currentTheme: any): any;
+    __experimentalReceiveCurrentGlobalStylesId(currentGlobalStylesId: string): any;
+    __experimentalReceiveThemeBaseGlobalStyles(stylesheet: string, globalStyles: any): any;
+    __experimentalReceiveThemeGlobalStyleVariations(stylesheet: string, variations: any[]): any;
+    receiveThemeSupports(): any;
+    receiveEmbedPreview(url: string, preview: any): any;
+    __unstableCreateUndoLevel(): any;
+    receiveUploadPermissions(hasUploadPermissions: boolean): any;
+    receiveUserPermission(key: string, isAllowed: boolean): any;
+    receiveAutosaves(postId: number, autosaves: any): any;
+    deleteEntityRecord: (kind: string, name: string, recordId: string, query: any, { __unstableFetch, throwOnError }?: {
+        __unstableFetch?: Function | undefined;
+        throwOnError?: boolean | undefined;
+    } | undefined) => ({ dispatch }: {
+        dispatch: any;
+    }) => Promise<boolean | undefined>;
+    editEntityRecord: (kind: string, name: string, recordId: number, edits: any, options?: {
+        undoIgnore?: boolean | undefined;
+    }) => any;
+    undo: () => ({ select, dispatch }: {
+        select: any;
+        dispatch: any;
+    }) => void;
+    redo: () => ({ select, dispatch }: {
+        select: any;
+        dispatch: any;
+    }) => void;
+    saveEntityRecord: (kind: string, name: string, record: any, { isAutosave, __unstableFetch, throwOnError, }?: {
+        isAutosave?: boolean | undefined;
+        __unstableFetch?: Function | undefined;
+        throwOnError?: boolean | undefined;
+    }) => ({ select, resolveSelect, dispatch }: {
+        select: any;
+        resolveSelect: any;
+        dispatch: any;
+    }) => Promise<any>;
+    __experimentalBatch: (requests: any[]) => (thunkArgs: any) => Promise<any>;
+    saveEditedEntityRecord: (kind: string, name: string, recordId: any, options: any) => ({ select, dispatch }: {
+        select: any;
+        dispatch: any;
+    }) => Promise<any>;
+    __experimentalSaveSpecifiedEntityEdits: (kind: string, name: string, recordId: any, itemsToSave: any[], options: any) => ({ select, dispatch }: {
+        select: any;
+        dispatch: any;
+    }) => Promise<any>;
+}, {
+    getAuthors(state: selectors.State, query?: {
+        [x: string]: any;
+    } | undefined): import("./entity-types").User<"edit">[];
+    getCurrentUser(state: selectors.State): import("./entity-types").User<"edit">;
+    getEntitiesByKind(state: selectors.State, kind: string): any[];
+    getEntitiesConfig(state: selectors.State, kind: string): any[];
+    getEntity(state: selectors.State, kind: string, name: string): any;
+    getEntityConfig(state: selectors.State, kind: string, name: string): any;
+    __experimentalGetEntityRecordNoResolver<EntityRecord extends import("./entity-types").Attachment<any> | import("./entity-types").Comment<any> | import("./entity-types").MenuLocation<any> | import("./entity-types").NavMenu<any> | import("./entity-types").NavMenuItem<any> | import("./entity-types").Page<any> | import("./entity-types").Plugin<any> | import("./entity-types").Post<any> | import("./entity-types").Settings<any> | import("./entity-types").Sidebar<any> | import("./entity-types").Taxonomy<any> | import("./entity-types").Theme<any> | import("./entity-types").User<any> | import("./entity-types").Type<any> | import("./entity-types").Widget<any> | import("./entity-types").WidgetType<any> | import("./entity-types").WpTemplate<any> | import("./entity-types").WpTemplatePart<any>>(state: selectors.State, kind: string, name: string, key: string | number): EntityRecord | undefined;
+    hasEntityRecords(state: selectors.State, kind: string, name: string, query?: {
+        [x: string]: any;
+    } | undefined): boolean;
+    getEntityRecordEdits(state: selectors.State, kind: string, name: string, recordId: string | number): any;
+    hasEditsForEntityRecord(state: selectors.State, kind: string, name: string, recordId: string | number): boolean;
+    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;
+    getLastEntitySaveError(state: selectors.State, kind: string, name: string, recordId: string | number): any;
+    getLastEntityDeleteError(state: selectors.State, kind: string, name: string, recordId: string | number): any;
+    getUndoEdit(state: selectors.State): any;
+    getRedoEdit(state: selectors.State): any;
+    hasUndo(state: selectors.State): boolean;
+    hasRedo(state: selectors.State): boolean;
+    getCurrentTheme(state: selectors.State): any;
+    __experimentalGetCurrentGlobalStylesId(state: selectors.State): string;
+    getThemeSupports(state: selectors.State): any;
+    getEmbedPreview(state: selectors.State, url: string): any;
+    isPreviewEmbedFallback(state: selectors.State, url: string): boolean;
+    canUser(state: selectors.State, action: string, resource: string, id?: (string | number) | undefined): boolean | undefined;
+    canUserEditEntityRecord(state: selectors.State, kind: string, name: string, recordId: string | number): boolean | undefined;
+    getAutosaves(state: selectors.State, postType: string, postId: string | number): any[] | undefined;
+    getAutosave<EntityRecord_1 extends import("./entity-types").Attachment<any> | import("./entity-types").Comment<any> | import("./entity-types").MenuLocation<any> | import("./entity-types").NavMenu<any> | import("./entity-types").NavMenuItem<any> | import("./entity-types").Page<any> | import("./entity-types").Plugin<any> | import("./entity-types").Post<any> | import("./entity-types").Settings<any> | import("./entity-types").Sidebar<any> | import("./entity-types").Taxonomy<any> | import("./entity-types").Theme<any> | import("./entity-types").User<any> | import("./entity-types").Type<any> | import("./entity-types").Widget<any> | import("./entity-types").WidgetType<any> | import("./entity-types").WpTemplate<any> | import("./entity-types").WpTemplatePart<any>>(state: selectors.State, postType: string, postId: string | number, authorId: string | number): EntityRecord_1 | undefined;
+    __experimentalGetTemplateForLink(state: selectors.State, link: string): (import("./entity-types").Updatable<import("./entity-types").WpTemplate<"edit">> | undefined) | null;
+    __experimentalGetCurrentThemeBaseGlobalStyles(state: selectors.State): any;
+    __experimentalGetCurrentThemeGlobalStylesVariations(state: selectors.State): string | null;
+    getBlockPatterns(state: selectors.State): any[];
+    getBlockPatternCategories(state: selectors.State): any[];
+    isRequestingEmbedPreview: Function;
+    getUserQueryResults: ((state: selectors.State, queryID: string) => import("./entity-types").User<"edit">[]) & import("rememo").EnhancedSelector;
+    getEntityRecord: (<EntityRecord_2 extends import("./entity-types").Attachment<any> | import("./entity-types").Comment<any> | import("./entity-types").MenuLocation<any> | import("./entity-types").NavMenu<any> | import("./entity-types").NavMenuItem<any> | import("./entity-types").Page<any> | import("./entity-types").Plugin<any> | import("./entity-types").Post<any> | import("./entity-types").Settings<any> | import("./entity-types").Sidebar<any> | import("./entity-types").Taxonomy<any> | import("./entity-types").Theme<any> | import("./entity-types").User<any> | import("./entity-types").Type<any> | import("./entity-types").Widget<any> | import("./entity-types").WidgetType<any> | import("./entity-types").WpTemplate<any> | import("./entity-types").WpTemplatePart<any> | Partial<import("./entity-types").Attachment<any> | import("./entity-types").Comment<any> | import("./entity-types").MenuLocation<any> | import("./entity-types").NavMenu<any> | import("./entity-types").NavMenuItem<any> | import("./entity-types").Page<any> | import("./entity-types").Plugin<any> | import("./entity-types").Post<any> | import("./entity-types").Settings<any> | import("./entity-types").Sidebar<any> | import("./entity-types").Taxonomy<any> | import("./entity-types").Theme<any> | import("./entity-types").User<any> | import("./entity-types").Type<any> | import("./entity-types").Widget<any> | import("./entity-types").WidgetType<any> | import("./entity-types").WpTemplate<any> | import("./entity-types").WpTemplatePart<any>>>(state: selectors.State, kind: string, name: string, key: string | number, query?: {
+        [x: string]: any;
+    } | undefined) => EntityRecord_2 | undefined) & import("rememo").EnhancedSelector;
+    getRawEntityRecord: (<EntityRecord_3 extends import("./entity-types").Attachment<any> | import("./entity-types").Comment<any> | import("./entity-types").MenuLocation<any> | import("./entity-types").NavMenu<any> | import("./entity-types").NavMenuItem<any> | import("./entity-types").Page<any> | import("./entity-types").Plugin<any> | import("./entity-types").Post<any> | import("./entity-types").Settings<any> | import("./entity-types").Sidebar<any> | import("./entity-types").Taxonomy<any> | import("./entity-types").Theme<any> | import("./entity-types").User<any> | import("./entity-types").Type<any> | import("./entity-types").Widget<any> | import("./entity-types").WidgetType<any> | import("./entity-types").WpTemplate<any> | import("./entity-types").WpTemplatePart<any>>(state: selectors.State, kind: string, name: string, key: string | number) => EntityRecord_3 | undefined) & import("rememo").EnhancedSelector;
+    getEntityRecords: <EntityRecord_4 extends import("./entity-types").Attachment<any> | import("./entity-types").Comment<any> | import("./entity-types").MenuLocation<any> | import("./entity-types").NavMenu<any> | import("./entity-types").NavMenuItem<any> | import("./entity-types").Page<any> | import("./entity-types").Plugin<any> | import("./entity-types").Post<any> | import("./entity-types").Settings<any> | import("./entity-types").Sidebar<any> | import("./entity-types").Taxonomy<any> | import("./entity-types").Theme<any> | import("./entity-types").User<any> | import("./entity-types").Type<any> | import("./entity-types").Widget<any> | import("./entity-types").WidgetType<any> | import("./entity-types").WpTemplate<any> | import("./entity-types").WpTemplatePart<any> | Partial<import("./entity-types").Attachment<any> | import("./entity-types").Comment<any> | import("./entity-types").MenuLocation<any> | import("./entity-types").NavMenu<any> | import("./entity-types").NavMenuItem<any> | import("./entity-types").Page<any> | import("./entity-types").Plugin<any> | import("./entity-types").Post<any> | import("./entity-types").Settings<any> | import("./entity-types").Sidebar<any> | import("./entity-types").Taxonomy<any> | import("./entity-types").Theme<any> | import("./entity-types").User<any> | import("./entity-types").Type<any> | import("./entity-types").Widget<any> | import("./entity-types").WidgetType<any> | import("./entity-types").WpTemplate<any> | import("./entity-types").WpTemplatePart<any>>>(state: selectors.State, kind: string, name: string, query?: {
+        [x: string]: any;
+    } | undefined) => EntityRecord_4[] | null;
+    __experimentalGetDirtyEntityRecords: ((state: selectors.State) => {
+        title: string;
+        key: string | number;
+        name: string;
+        kind: string;
+    }[]) & import("rememo").EnhancedSelector;
+    __experimentalGetEntitiesBeingSaved: ((state: selectors.State) => {
+        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_5 extends import("./entity-types").Attachment<any> | import("./entity-types").Comment<any> | import("./entity-types").MenuLocation<any> | import("./entity-types").NavMenu<any> | import("./entity-types").NavMenuItem<any> | import("./entity-types").Page<any> | import("./entity-types").Plugin<any> | import("./entity-types").Post<any> | import("./entity-types").Settings<any> | import("./entity-types").Sidebar<any> | import("./entity-types").Taxonomy<any> | import("./entity-types").Theme<any> | import("./entity-types").User<any> | import("./entity-types").Type<any> | import("./entity-types").Widget<any> | import("./entity-types").WidgetType<any> | import("./entity-types").WpTemplate<any> | import("./entity-types").WpTemplatePart<any>>(state: selectors.State, kind: string, name: string, recordId: string | number) => import("./entity-types").Updatable<EntityRecord_5> | undefined) & import("rememo").EnhancedSelector;
+    hasFetchedAutosaves: Function;
+    getReferenceByDistinctEdits: ((state: selectors.State) => never[]) & import("rememo").EnhancedSelector;
+}>>;
+export { default as EntityProvider } from "./entity-provider";
+export * from "./entity-provider";
+export * from "./entity-types";
+export * from "./fetch";
+export * from "./hooks";
+import * as selectors from "./selectors";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.js"],"names":[],"mappings":";AA0DA;;;;GAIG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAmE"}

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,10 @@
+/**
+ * Reducer returning locks.
+ *
+ * @param {Object} state  Current state.
+ * @param {Object} action Dispatched action.
+ *
+ * @return {Object} Updated state.
+ */
+export default function locks(state: any, action: any): any;
+//# sourceMappingURL=reducer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reducer.d.ts","sourceRoot":"","sources":["../../src/locks/reducer.js"],"names":[],"mappings":"AAaA;;;;;;;GAOG;AACH,4DAwCC"}

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

@@ -0,0 +1,5 @@
+export function getPendingLockRequests(state: any): any;
+export 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

@@ -0,0 +1 @@
+{"version":3,"file":"selectors.d.ts","sourceRoot":"","sources":["../../src/locks/selectors.js"],"names":[],"mappings":"AAUA,wDAEC;AAED;;YA0BC"}

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

@@ -0,0 +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 }: {
+    exclusive: any;
+}, locks: any): boolean;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +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"}

package/build-types/name.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The reducer key used by core data in store registration.
+ * This is defined in a separate file to avoid cycle-dependency
+ *
+ * @type {string}
+ */
+export const STORE_NAME: string;
+//# sourceMappingURL=name.d.ts.map

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

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

package/build-types/queried-data/actions.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Returns an action object used in signalling that items have been received.
+ *
+ * @param {Array}   items Items received.
+ * @param {?Object} edits Optional edits to reset.
+ *
+ * @return {Object} Action object.
+ */
+export function receiveItems(items: any[], edits: any | null): any;
+/**
+ * Returns an action object used in signalling that entity records have been
+ * deleted and they need to be removed from entities state.
+ *
+ * @param {string}              kind            Kind of the removed entities.
+ * @param {string}              name            Name of the removed entities.
+ * @param {Array|number|string} records         Record IDs of the removed entities.
+ * @param {boolean}             invalidateCache Controls whether we want to invalidate the cache.
+ * @return {Object} Action object.
+ */
+export function removeItems(kind: string, name: string, records: any[] | number | string, invalidateCache?: boolean): any;
+/**
+ * Returns an action object used in signalling that queried data has been
+ * received.
+ *
+ * @param {Array}   items Queried items received.
+ * @param {?Object} query Optional query object.
+ * @param {?Object} edits Optional edits to reset.
+ *
+ * @return {Object} Action object.
+ */
+export function receiveQueriedItems(items: any[], query: any | null, edits: any | null): any;
+//# sourceMappingURL=actions.d.ts.map

package/build-types/queried-data/actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../src/queried-data/actions.js"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AACH,mEAMC;AAED;;;;;;;;;GASG;AACH,kCANW,MAAM,QACN,MAAM,WACN,QAAM,MAAM,GAAC,MAAM,oBACnB,OAAO,OAWjB;AAED;;;;;;;;;GASG;AACH,6FAKC"}