@warp-drive/core 5.7.0-alpha.14 → 5.7.0-alpha.16

package/declarations/reactive.d.ts

@@ -1,5 +1,281 @@
+/**
+* # About
+*
+* This module provides an implementation of reactive objects that a Store may use for creating
+* reactive representations of the raw data for requests, resources and their relationships
+* stored in the cache.
+*
+* - For configuring the store to use these reactive objects, see [The Setup Guide](/guides/1-configuration/2-setup/1-universal.md)
+* - For defining resource schemas, see [The Schema Guide](/guides)
+*
+* Any method that returns a record instance will use the `instantiateRecord`
+* hook configured above to instantiate a ReactiveResource once this is in place.
+* After that, its up to you what ReactiveResource can do.
+*
+* ## Modes
+*
+* ReactiveResource has two modes: `legacy` and `polaris`.
+*
+* **LegacyMode** can be used to emulate the behaviors and capabilities of WarpDrive's `Model` class,
+* and because there is little distinction between Model and a ReactiveResource in LegacyMode we refer
+* to both of these approaches as LegacyMode. This mode is the default experience in V5.
+*
+* In LegacyMode:
+*
+* - records are mutable
+* - local changes immediately reflect app wide
+* - records have all the APIs of Model (references, state props, currentState, methods etc)
+* - the continued use of `@warp-drive/legacy` is required (though most imports from it can be removed)
+* - `async: true` relationships are supported (but not recommended outside of [LinksMode](https://github.com/emberjs/data/blob/main/guides/relationships/features/links-mode.md))
+*
+* ---
+*
+* **PolarisMode** is an upcoming suite of features that will become the default experience in V6.
+*
+* In PolarisMode:
+*
+* - records are immutable, unless creating a new resource or explicitly checking out a record for editing
+* - local changes are isolated until committed, displaying only via the editable version of the record
+* - records have a more limited API, focused on only what is in their schema.
+* - some common operations may have more friction to perform because intended utilities are not yet available
+* - `async: true` relationships are not supported (see [LinksMode](https://github.com/emberjs/data/blob/main/guides/relationships/features/links-mode.md))
+* - The `@warp-drive/legacy` package is not required
+*
+* These modes are interopable. The reactive object (record) for a resource in PolarisMode can relate to
+* a record in LegacyMode and vice-versa. This interopability is true whether the record in LegacyMode is
+* a ReactiveResource or a Model.
+*
+* ---
+*
+* ## Basic Usage
+*
+* ReactiveResource is a reactive object that transforms raw data from an associated
+* cache into reactive data backed by Signals.
+*
+* The shape of the object and the transformation of raw cache data into its
+* reactive form is controlled by a resource schema.
+*
+* For instance, lets say your API is a [{JSON:API}](https://jsonapi.org) and your store is using
+* the Cache provided by [@warp-drive/json-api](/api/@warp-drive/json-api), and a request
+* returns the following raw data:
+*
+* ```ts
+* {
+*   data: {
+*     type: 'user',
+*     id: '1',
+*     attributes: { firstName: 'Chris', lastName: 'Thoburn' },
+*     relationships: { pets: { data: [{ type: 'dog', id: '1' }] }}
+*   },
+*   included: [
+*     {
+*       type: 'dog',
+*       id: '1',
+*       attributes: { name: 'Rey' },
+*       relationships: { owner: { data: { type: 'user', id: '1' }}}
+*     }
+*   ]
+* }
+* ```
+*
+* We could describe the `'user'` and `'dog'` resources in the above payload
+* with the following schemas:
+*
+* ```ts
+* store.schema.registerResources([
+*   {
+*     type: 'user',
+*     identity: { type: '@id', name: 'id' },
+*     fields: [
+*       {
+*         type: '@identity',
+*         name: '$type',
+*         kind: 'derived',
+*         options: { key: 'type' },
+*       },
+*       { kind: 'field', name: 'firstName' },
+*       { kind: 'field', name: 'lastName' },
+*       {
+*         kind: 'derived',
+*         name: 'name',
+*         type: 'concat',
+*         options: { fields: ['firstName', 'lastName'], separator: ' ' }
+*       },
+*       {
+*         kind: 'hasMany',
+*         name: 'pets',
+*         type: 'pet',
+*         options: {
+*           async: false,
+*           inverse: 'owner',
+*           polymorphic: true,
+*           linksMode: true,
+*         }
+*       }
+*     ]
+*   },
+*   {
+*     type: 'dog',
+*     identity: { type: '@id', name: 'id' },
+*     fields: [
+*       {
+*         type: '@identity',
+*         name: '$type',
+*         kind: 'derived',
+*         options: { key: 'type' },
+*       },
+*       { kind: 'field', name: 'name' },
+*       {
+*         kind: 'belongsTo',
+*         name: 'owner',
+*         type: 'user',
+*         options: {
+*           async: false,
+*           inverse: 'pets',
+*           as: 'pet',
+*           linksMode: true,
+*         }
+*       }
+*     ]
+*   }
+* ]);
+* ```
+*
+* With these schemas in place, the reactive objects that the store would
+* provide us whenever we encountered a `'user'` or a `'dog'` would be:
+*
+* ```ts
+* interface Pet {
+*   readonly id: string;
+*   readonly owner: User;
+* }
+*
+* interface Dog extends Pet {
+*   readonly $type: 'dog';
+*   readonly name: string;
+* }
+*
+* interface EditableUser {
+*   readonly $type: 'user';
+*   readonly id: string;
+*   firstName: string;
+*   lastName: string;
+*   readonly name: string;
+*   pets: Array<Dog | Pet>;
+* }
+*
+* interface User {
+*   readonly $type: 'user';
+*   readonly id: string;
+*   readonly firstName: string;
+*   readonly lastName: string;
+*   readonly name: string;
+*   readonly pets: Readonly<Array<Dog | Pet>>;
+*   [Checkout]: Promise<EditableUser>
+* }>
+* ```
+*
+* Note how based on the schema the reactive object we receive is able to produce
+* `name` on user (despite no name field being in the cache), provide `$type`
+* pulled from the identity of the resource, and flatten the individual attributes
+* and relationships onto the record for easier use.
+*
+* Notice also how we typed this object with `readonly`. This is because while
+* ReactiveResource instances are ***deeply reactive***, they are also ***immutable***.
+*
+* We can mutate a ReactiveResource only be explicitly asking permission to do so, and
+* in the process gaining access to an editable copy. The immutable version will
+* not show any in-process edits made to this editable copy.
+*
+* ```ts
+* import { Checkout } from '@warp-drive/schema-record';
+*
+* const editable = await user[Checkout]();
+* ```
+*
+* ## Utilities
+*
+* ReactiveResource provides a schema builder that simplifies setting up a couple of
+* conventional fields like identity and `$type`. We can rewrite the schema
+* definition above using this utility like so:
+*
+* ```ts
+* import { withDefaults } from '@warp-drive/core/reactive';
+*
+* store.schema.registerResources([
+*   withDefaults({
+*     type: 'user',
+*     fields: [
+*       { kind: 'field', name: 'firstName' },
+*       { kind: 'field', name: 'lastName' },
+*       {
+*         kind: 'derived',
+*         name: 'name',
+*         type: 'concat',
+*         options: { fields: ['firstName', 'lastName'], separator: ' ' }
+*       },
+*       {
+*         kind: 'hasMany',
+*         name: 'pets',
+*         type: 'pet',
+*         options: {
+*           async: false,
+*           inverse: 'owner',
+*           polymorphic: true,
+*           linksMode: true,
+*           resetOnRemoteUpdate: false,
+*         }
+*       }
+*     ]
+*   }),
+*   withDefaults({
+*     type: 'dog',
+*     fields: [
+*       { kind: 'field', name: 'name' },
+*       {
+*         kind: 'belongsTo',
+*         name: 'owner',
+*         type: 'user',
+*         options: {
+*           async: false,
+*           inverse: 'pets',
+*           as: 'pet',
+*           linksMode: true,
+*           resetOnRemoteUpdate: false,
+*         }
+*       }
+*     ]
+*   })
+* ]);
+* ```
+*
+* ## Type Support
+*
+* ### Resource Schemas
+*
+* - {@link PolarisResourceSchema}
+* - {@link LegacyResourceSchema}
+* - {@link ObjectSchema}
+*
+* ### Resource Schema Type Utils
+*
+* - {@link resourceSchema}
+* - {@link objectSchema}
+* - {@link isResourceSchema}
+* - {@link isLegacyResourceSchema}
+*
+* ### Field Schemas
+*
+* - {@link LegacyModeFieldSchema}
+* - {@link PolarisModeFieldSchema}
+*
+* @module
+*/
+import { checkout } from "./reactive/-private/record.js";
 export { instantiateRecord, teardownRecord } from "./reactive/-private/hooks.js";
 export { type CAUTION_MEGA_DANGER_ZONE_Extension, type ProcessedExtension, type ExtensionDef, type Transformation, SchemaService, withDefaults, fromIdentity, registerDerivations } from "./reactive/-private/schema.js";
-export { type ReactiveResource } from "./reactive/-private/record.js";
+export { commit, type ReactiveResource } from "./reactive/-private/record.js";
+export { checkout };
 export { Checkout } from "./reactive/-private/symbols.js";
 export { type ReactiveDocument } from "./reactive/-private/document.js";
+export { getExpensiveRequestSubscription } from "./store/-private/new-core-tmp/expensive-subscription.js";

package/declarations/request/-private/context.d.ts

@@ -1,4 +1,4 @@
-import type { StableDocumentIdentifier } from "../../types/identifier.js";
+import type { RequestKey } from "../../types/identifier.js";
 import type { ImmutableHeaders, ImmutableRequestInfo, RequestInfo, ResponseInfo } from "../../types/request.js";
 import type { DeferredStream, GodContext } from "./types.js";
 export declare function upgradeHeaders(headers: Headers | ImmutableHeaders): ImmutableHeaders;
@@ -34,7 +34,7 @@ export declare class Context {
 	constructor(owner: ContextOwner, isCacheHandler: boolean);
 	setStream(stream: ReadableStream | Promise<ReadableStream | null>): void;
 	setResponse(response: ResponseInfo | Response | null): void;
-	setIdentifier(identifier: StableDocumentIdentifier): void;
+	setIdentifier(identifier: RequestKey): void;
 	get hasRequestedStream(): boolean;
 	_finalize(): void;
 }

package/declarations/request/-private/manager.d.ts

@@ -1,4 +1,4 @@
-import type { StableDocumentIdentifier } from "../../types/identifier.js";
+import type { RequestKey } from "../../types/identifier.js";
 import type { RequestInfo } from "../../types/request.js";
 import type { CacheHandler, Future, GenericCreateArgs, Handler, ManagedRequestPriority } from "./types.js";
 import { IS_CACHE_HANDLER } from "./utils.js";
@@ -107,7 +107,7 @@ export declare class RequestManager {
 	*/
 	_pending: Map<number, Promise<unknown>>;
 	/** @internal */
-	_deduped: Map<StableDocumentIdentifier, {
+	_deduped: Map<RequestKey, {
 		priority: ManagedRequestPriority;
 		promise: Promise<unknown>;
 	}>;

package/declarations/request/-private/types.d.ts

@@ -1,5 +1,5 @@
 /* eslint-disable no-irregular-whitespace */
-import type { StableDocumentIdentifier } from "../../types/identifier.js";
+import type { RequestKey } from "../../types/identifier.js";
 import type { IS_FUTURE, RequestContext, RequestInfo, ResponseInfo, StructuredDataDocument } from "../../types/request.js";
 export interface GodContext {
 	controller: AbortController;
@@ -7,7 +7,7 @@ export interface GodContext {
 	stream: ReadableStream | Promise<ReadableStream | null> | null;
 	hasRequestedStream: boolean;
 	id: number;
-	identifier: StableDocumentIdentifier | null;
+	identifier: RequestKey | null;
 }
 export type Deferred<T> = {
 	resolve(v: T): void;
@@ -64,10 +64,10 @@ export interface Future<T> extends Promise<StructuredDataDocument<T>> {
 	* assigned by the CacheHandler.
 	*
 	* @property lid
-	* @type {StableDocumentIdentifier | null}
+	* @type {RequestKey | null}
 	* @public
 	*/
-	lid: StableDocumentIdentifier | null;
+	lid: RequestKey | null;
 	/**
 	* The id of the associated request, if any, as assigned
 	* by the RequestManager

package/declarations/store/-private/cache-handler/types.d.ts

@@ -1,4 +1,4 @@
-import type { StableDocumentIdentifier } from "../../../types/identifier.js";
+import type { RequestKey } from "../../../types/identifier.js";
 import type { ImmutableRequestInfo, ResponseInfo } from "../../../types/request.js";
 import type { Store } from "../store-service.js";
 /**
@@ -27,11 +27,11 @@ export interface CachePolicy {
 	* and the cache will be updated before returning the response.
 	*
 	* @public
-	* @param {StableDocumentIdentifier} identifier
+	* @param {RequestKey} identifier
 	* @param {Store} store
 	* @return {Boolean} true if the request is considered hard expired
 	*/
-	isHardExpired(identifier: StableDocumentIdentifier, store: Store): boolean;
+	isHardExpired(identifier: RequestKey, store: Store): boolean;
 	/**
 	* Invoked if `isHardExpired` is false to determine if the request
 	* should be update behind the scenes if cache data is already available.
@@ -42,11 +42,11 @@ export interface CachePolicy {
 	* request is made to update the cache via the configured request handlers.
 	*
 	* @public
-	* @param {StableDocumentIdentifier} identifier
+	* @param {RequestKey} identifier
 	* @param {Store} store
 	* @return {Boolean} true if the request is considered soft expired
 	*/
-	isSoftExpired(identifier: StableDocumentIdentifier, store: Store): boolean;
+	isSoftExpired(identifier: RequestKey, store: Store): boolean;
 	/**
 	* Invoked when a request will be sent to the configured request handlers.
 	* This is invoked for both foreground and background requests.
@@ -55,11 +55,11 @@ export interface CachePolicy {
 	*
 	* @public
 	* @param {ImmutableRequestInfo} request
-	* @param {StableDocumentIdentifier | null} identifier
+	* @param {RequestKey | null} identifier
 	* @param {Store} store
 	* @return {void}
 	*/
-	willRequest?(request: ImmutableRequestInfo, identifier: StableDocumentIdentifier | null, store: Store): void;
+	willRequest?(request: ImmutableRequestInfo, identifier: RequestKey | null, store: Store): void;
 	/**
 	* Invoked when a request has been fulfilled from the configured request handlers.
 	* This is invoked for both foreground and background requests once the cache has
@@ -90,9 +90,9 @@ export interface CachePolicy {
 	* @public
 	* @param {ImmutableRequestInfo} request
 	* @param {ImmutableResponse} response
-	* @param {StableDocumentIdentifier | null} identifier
+	* @param {RequestKey | null} identifier
 	* @param {Store} store
 	* @return {void}
 	*/
-	didRequest?(request: ImmutableRequestInfo, response: Response | ResponseInfo | null, identifier: StableDocumentIdentifier | null, store: Store): void;
+	didRequest?(request: ImmutableRequestInfo, response: Response | ResponseInfo | null, identifier: RequestKey | null, store: Store): void;
 }

package/declarations/store/-private/cache-handler/utils.d.ts

@@ -1,11 +1,11 @@
-import type { StableDocumentIdentifier } from "../../../types/identifier.js";
+import type { RequestKey } from "../../../types/identifier.js";
 import type { ImmutableCreateRequestOptions, ImmutableDeleteRequestOptions, ImmutableRequestInfo, ImmutableUpdateRequestOptions, StructuredDataDocument } from "../../../types/request.js";
 import type { ResourceDataDocument, ResourceErrorDocument } from "../../../types/spec/document.js";
 import type { ApiError } from "../../../types/spec/error.js";
 import type { Store } from "../store-service.js";
 export declare const MUTATION_OPS: Set<string>;
-export declare function calcShouldFetch(store: Store, request: ImmutableRequestInfo, hasCachedValue: boolean, identifier: StableDocumentIdentifier | null): boolean;
-export declare function calcShouldBackgroundFetch(store: Store, request: ImmutableRequestInfo, willFetch: boolean, identifier: StableDocumentIdentifier | null): boolean;
+export declare function calcShouldFetch(store: Store, request: ImmutableRequestInfo, hasCachedValue: boolean, identifier: RequestKey | null): boolean;
+export declare function calcShouldBackgroundFetch(store: Store, request: ImmutableRequestInfo, willFetch: boolean, identifier: RequestKey | null): boolean;
 export declare function isMutation(request: Partial<ImmutableRequestInfo>): request is ImmutableUpdateRequestOptions | ImmutableCreateRequestOptions | ImmutableDeleteRequestOptions;
 export declare function isCacheAffecting<T>(document: StructuredDataDocument<T>): boolean;
 export declare function isAggregateError(error: Error & {
@@ -21,7 +21,7 @@ export type RobustError = Error & {
 // TODO @runspired, consider if we should deep freeze errors (potentially only in debug) vs cloning them
 export declare function cloneError(error: RobustError): RobustError;
 export declare function isErrorDocument(document: ResourceDataDocument | ResourceErrorDocument): document is ResourceErrorDocument;
-export declare function getPriority(identifier: StableDocumentIdentifier | null, deduped: Map<StableDocumentIdentifier, {
+export declare function getPriority(identifier: RequestKey | null, deduped: Map<RequestKey, {
 	priority: {
 		blocking: boolean;
 	};

package/declarations/store/-private/caches/instance-cache.d.ts

@@ -1,21 +1,21 @@
 import { ReactiveDocument } from "../../../reactive/-private/document.js";
 import type { Cache } from "../../../types/cache.js";
-import type { StableDocumentIdentifier, StableRecordIdentifier } from "../../../types/identifier.js";
+import type { RequestKey, ResourceKey } from "../../../types/identifier.js";
 import type { TypedRecordInstance, TypeFromInstance } from "../../../types/record.js";
 import type { OpaqueRecordInstance } from "../../-types/q/record-instance.js";
 import { CacheCapabilitiesManager } from "../managers/cache-capabilities-manager.js";
 import type { CacheManager } from "../managers/cache-manager.js";
 import type { CreateRecordProperties, Store } from "../store-service.js";
-export declare function peekRecordIdentifier(record: OpaqueRecordInstance): StableRecordIdentifier | undefined;
+export declare function peekRecordIdentifier(record: OpaqueRecordInstance): ResourceKey | undefined;
 /**
-Retrieves the unique referentially-stable [RecordIdentifier](/ember-data/release/classes/StableRecordIdentifier)
+Retrieves the unique referentially-stable [RecordIdentifier](/ember-data/release/classes/ResourceKey)
 assigned to the given record instance.
 
 ```js
 import { recordIdentifierFor } from "@ember-data/store";
 // ... gain access to a record, for instance with peekRecord or findRecord
 const record = store.peekRecord("user", "1");
-// get the identifier for the record (see docs for StableRecordIdentifier)
+// get the identifier for the record (see docs for ResourceKey)
 const identifier = recordIdentifierFor(record);
 // access the identifier's properties.
 const { id, type, lid } = identifier;
@@ -23,11 +23,11 @@ const { id, type, lid } = identifier;
 
 @public
 @param {Object} record a record instance previously obstained from the store.
-@return {StableRecordIdentifier}
+@return {ResourceKey}
 */
-export declare function recordIdentifierFor<T extends TypedRecordInstance>(record: T): StableRecordIdentifier<TypeFromInstance<T>>;
-export declare function recordIdentifierFor(record: OpaqueRecordInstance): StableRecordIdentifier;
-export declare function setRecordIdentifier(record: OpaqueRecordInstance, identifier: StableRecordIdentifier): void;
+export declare function recordIdentifierFor<T extends TypedRecordInstance>(record: T): ResourceKey<TypeFromInstance<T>>;
+export declare function recordIdentifierFor(record: OpaqueRecordInstance): ResourceKey;
+export declare function setRecordIdentifier(record: OpaqueRecordInstance, identifier: ResourceKey): void;
 export declare function removeRecordIdentifier(record: OpaqueRecordInstance): void;
 export declare const StoreMap: Map<unknown, Store>;
 /**
@@ -36,8 +36,8 @@ export declare const StoreMap: Map<unknown, Store>;
 */
 export declare function storeFor(record: OpaqueRecordInstance, ignoreMissing: boolean): Store | null;
 export type Caches = {
-	record: Map<StableRecordIdentifier, OpaqueRecordInstance>;
-	document: Map<StableDocumentIdentifier, ReactiveDocument<OpaqueRecordInstance | OpaqueRecordInstance[] | null | undefined>>;
+	record: Map<ResourceKey, OpaqueRecordInstance>;
+	document: Map<RequestKey, ReactiveDocument<OpaqueRecordInstance | OpaqueRecordInstance[] | null | undefined>>;
 };
 export declare class InstanceCache {
 	store: Store;
@@ -46,15 +46,15 @@ export declare class InstanceCache {
 	__cacheManager: CacheManager;
 	__instances: Caches;
 	constructor(store: Store);
-	peek(identifier: StableRecordIdentifier): Cache | OpaqueRecordInstance | undefined;
-	getDocument<T>(identifier: StableDocumentIdentifier): ReactiveDocument<T>;
-	getRecord(identifier: StableRecordIdentifier): OpaqueRecordInstance;
-	recordIsLoaded(identifier: StableRecordIdentifier, filterDeleted?: boolean): boolean;
-	disconnect(identifier: StableRecordIdentifier): void;
-	unloadRecord(identifier: StableRecordIdentifier): void;
+	peek(identifier: ResourceKey): Cache | OpaqueRecordInstance | undefined;
+	getDocument<T>(identifier: RequestKey): ReactiveDocument<T>;
+	getRecord(identifier: ResourceKey): OpaqueRecordInstance;
+	recordIsLoaded(identifier: ResourceKey, filterDeleted?: boolean): boolean;
+	disconnect(identifier: ResourceKey): void;
+	unloadRecord(identifier: ResourceKey): void;
 	clear(type?: string): void;
 	// TODO this should move into something coordinating operations
-	setRecordId(identifier: StableRecordIdentifier, id: string): void;
+	setRecordId(identifier: ResourceKey, id: string): void;
 }
-export declare function getNewRecord(instances: InstanceCache, identifier: StableRecordIdentifier, properties: CreateRecordProperties): OpaqueRecordInstance;
+export declare function getNewRecord(instances: InstanceCache, identifier: ResourceKey, properties: CreateRecordProperties): OpaqueRecordInstance;
 export declare function _clearCaches(): void;

package/declarations/store/-private/default-cache-policy.d.ts

@@ -1,30 +1,30 @@
 import type { Cache } from "@warp-drive/core/types/cache";
-import type { StableDocumentIdentifier, StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { RequestKey, ResourceKey } from "@warp-drive/core/types/identifier";
 import type { ImmutableRequestInfo, ResponseInfo, StructuredDocument } from "@warp-drive/core/types/request";
 import type { ResourceDocument } from "@warp-drive/core/types/spec/document";
 type UnsubscribeToken = object;
 type CacheOperation = "added" | "removed" | "updated" | "state";
 type DocumentCacheOperation = "invalidated" | "added" | "removed" | "updated" | "state";
 export interface NotificationCallback {
-	(identifier: StableRecordIdentifier, notificationType: "attributes" | "relationships", key?: string): void;
-	(identifier: StableRecordIdentifier, notificationType: "errors" | "meta" | "identity" | "state"): void;
+	(resourceKey: ResourceKey, notificationType: "attributes" | "relationships", key?: string): void;
+	(resourceKey: ResourceKey, notificationType: "errors" | "meta" | "identity" | "state"): void;
 }
 interface ResourceOperationCallback {
 	// resource updates
-	(identifier: StableRecordIdentifier, notificationType: CacheOperation): void;
+	(resourceKey: ResourceKey, notificationType: CacheOperation): void;
 }
 interface DocumentOperationCallback {
 	// document updates
-	(identifier: StableDocumentIdentifier, notificationType: DocumentCacheOperation): void;
+	(cacheKey: RequestKey, notificationType: DocumentCacheOperation): void;
 }
 type NotificationManager = {
-	subscribe(identifier: StableRecordIdentifier, callback: NotificationCallback): UnsubscribeToken;
-	subscribe(identifier: "resource", callback: ResourceOperationCallback): UnsubscribeToken;
-	subscribe(identifier: "document" | StableDocumentIdentifier, callback: DocumentOperationCallback): UnsubscribeToken;
-	notify(identifier: StableRecordIdentifier, value: "attributes" | "relationships", key?: string): boolean;
-	notify(identifier: StableRecordIdentifier, value: "errors" | "meta" | "identity" | "state"): boolean;
-	notify(identifier: StableRecordIdentifier, value: CacheOperation): boolean;
-	notify(identifier: StableDocumentIdentifier, value: DocumentCacheOperation): boolean;
+	subscribe(resourceKey: ResourceKey, callback: NotificationCallback): UnsubscribeToken;
+	subscribe(cacheKey: "resource", callback: ResourceOperationCallback): UnsubscribeToken;
+	subscribe(cacheKey: "document" | RequestKey, callback: DocumentOperationCallback): UnsubscribeToken;
+	notify(cacheKey: ResourceKey, value: "attributes" | "relationships", key?: string): boolean;
+	notify(cacheKey: ResourceKey, value: "errors" | "meta" | "identity" | "state"): boolean;
+	notify(cacheKey: ResourceKey, value: CacheOperation): boolean;
+	notify(cacheKey: RequestKey, value: DocumentCacheOperation): boolean;
 };
 type Store = {
 	cache: Cache;
@@ -236,7 +236,7 @@ export type PolicyConfig = {
 * request for that type is successful.
 *
 * For this to work, the `createRecord` request must include the `cacheOptions.types` array
-* with the types that should be invalidated, or its request should specify the identifiers
+* with the types that should be invalidated, or its request should specify the ResourceKeys
 * of the records that are being created via `records`. Providing both is valid.
 *
 * > [!NOTE]
@@ -285,30 +285,28 @@ export type PolicyConfig = {
 export declare class DefaultCachePolicy {
 	config: PolicyConfig;
 	_stores: WeakMap<Store, {
-		invalidated: Set<StableDocumentIdentifier>;
-		types: Map<string, Set<StableDocumentIdentifier>>;
+		invalidated: Set<RequestKey>;
+		types: Map<string, Set<RequestKey>>;
 	}>;
 	_getStore(store: Store): {
-		invalidated: Set<StableDocumentIdentifier>;
-		types: Map<string, Set<StableDocumentIdentifier>>;
+		invalidated: Set<RequestKey>;
+		types: Map<string, Set<RequestKey>>;
 	};
 	constructor(config: PolicyConfig);
 	/**
-	* Invalidate a request by its identifier for a given store instance.
+	* Invalidate a request by its CacheKey for the given store instance.
 	*
 	* While the store argument may seem redundant, the CachePolicy
 	* is designed to be shared across multiple stores / forks
 	* of the store.
 	*
 	* ```ts
-	* store.lifetimes.invalidateRequest(store, identifier);
+	* store.lifetimes.invalidateRequest(store, cacheKey);
 	* ```
 	*
 	* @public
-	* @param {StableDocumentIdentifier} identifier
-	* @param {Store} store
 	*/
-	invalidateRequest(identifier: StableDocumentIdentifier, store: Store): void;
+	invalidateRequest(cacheKey: RequestKey, store: Store): void;
 	/**
 	* Invalidate all requests associated to a specific type
 	* for a given store instance.
@@ -325,8 +323,6 @@ export declare class DefaultCachePolicy {
 	* ```
 	*
 	* @public
-	* @param {String} type
-	* @param {Store} store
 	*/
 	invalidateRequestsForType(type: string, store: Store): void;
 	/**
@@ -340,13 +336,8 @@ export declare class DefaultCachePolicy {
 	* This method should not be invoked directly by consumers.
 	*
 	* @public
-	* @param {ImmutableRequestInfo} request
-	* @param {ImmutableResponse} response
-	* @param {Store} store
-	* @param {StableDocumentIdentifier | null} identifier
-	* @return {void}
 	*/
-	didRequest(request: ImmutableRequestInfo, response: Response | ResponseInfo | null, identifier: StableDocumentIdentifier | null, store: Store): void;
+	didRequest(request: ImmutableRequestInfo, response: Response | ResponseInfo | null, cacheKey: RequestKey | null, store: Store): void;
 	/**
 	* Invoked to determine if the request may be fulfilled from cache
 	* if possible.
@@ -359,11 +350,9 @@ export declare class DefaultCachePolicy {
 	* and the cache will be updated before returning the response.
 	*
 	* @public
-	* @param {StableDocumentIdentifier} identifier
-	* @param {Store} store
-	* @return {Boolean} true if the request is considered hard expired
+	* @return true if the request is considered hard expired
 	*/
-	isHardExpired(identifier: StableDocumentIdentifier, store: Store): boolean;
+	isHardExpired(cacheKey: RequestKey, store: Store): boolean;
 	/**
 	* Invoked if `isHardExpired` is false to determine if the request
 	* should be update behind the scenes if cache data is already available.
@@ -375,10 +364,8 @@ export declare class DefaultCachePolicy {
 	* request is made to update the cache via the configured request handlers.
 	*
 	* @public
-	* @param {StableDocumentIdentifier} identifier
-	* @param {Store} store
-	* @return {Boolean} true if the request is considered soft expired
+	* @return true if the request is considered soft expired
 	*/
-	isSoftExpired(identifier: StableDocumentIdentifier, store: Store): boolean;
+	isSoftExpired(cacheKey: RequestKey, store: Store): boolean;
 }
 export {};