@warp-drive/core 5.7.0-alpha.13 → 5.7.0-alpha.15

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 {};

package/declarations/store/-private/managers/cache-capabilities-manager.d.ts

@@ -1,25 +1,27 @@
-import type { StableDocumentIdentifier, StableRecordIdentifier } from "../../../types/identifier.js";
+import type { ResourceKey, RequestKey } from "../../../types/identifier.js";
 import type { CacheCapabilitiesManager as StoreWrapper } from "../../-types/q/cache-capabilities-manager.js";
 import type { SchemaService } from "../../-types/q/schema-service.js";
-import type { IdentifierCache } from "../caches/identifier-cache.js";
 import type { Store } from "../store-service.js";
+import type { CacheKeyManager } from "./cache-key-manager.js";
 import type { NotificationType } from "./notification-manager.js";
 export interface CacheCapabilitiesManager {
 	getSchemaDefinitionService(): SchemaService;
 }
 export declare class CacheCapabilitiesManager implements StoreWrapper {
 	_willNotify: boolean;
-	_pendingNotifies: Map<StableRecordIdentifier, Set<string>>;
+	_pendingNotifies: Map<ResourceKey, Set<string>>;
 	_store: Store;
 	constructor(_store: Store);
-	get identifierCache(): IdentifierCache;
-	_scheduleNotification(identifier: StableRecordIdentifier, key: string): void;
+	get cacheKeyManager(): CacheKeyManager;
+	/** @deprecated use {@link CacheCapabilitiesManager.cacheKeyManager} */
+	get identifierCache(): CacheKeyManager;
+	_scheduleNotification(identifier: ResourceKey, key: string): void;
 	_flushNotifications(): void;
-	notifyChange(identifier: StableRecordIdentifier, namespace: "added" | "removed", key: null): void;
-	notifyChange(identifier: StableDocumentIdentifier, namespace: "added" | "updated" | "removed", key: null): void;
-	notifyChange(identifier: StableRecordIdentifier, namespace: NotificationType, key: string | null): void;
+	notifyChange(identifier: ResourceKey, namespace: "added" | "removed", key: null): void;
+	notifyChange(identifier: RequestKey, namespace: "added" | "updated" | "removed", key: null): void;
+	notifyChange(identifier: ResourceKey, namespace: NotificationType, key: string | null): void;
 	get schema(): SchemaService;
-	setRecordId(identifier: StableRecordIdentifier, id: string): void;
-	hasRecord(identifier: StableRecordIdentifier): boolean;
-	disconnectRecord(identifier: StableRecordIdentifier): void;
+	setRecordId(identifier: ResourceKey, id: string): void;
+	hasRecord(identifier: ResourceKey): boolean;
+	disconnectRecord(identifier: ResourceKey): void;
 }

package/declarations/store/-private/{caches/identifier-cache.d.ts → managers/cache-key-manager.d.ts}

@@ -1,13 +1,13 @@
-import { type Identifier, type RecordIdentifier, type StableDocumentIdentifier, type StableExistingRecordIdentifier, type StableRecordIdentifier } from "../../../types/identifier.js";
+import { type PersistedResourceKey, type ResourceKey, type RequestKey } from "../../../types/identifier.js";
 import type { ImmutableRequestInfo } from "../../../types/request.js";
 import type { ExistingResourceIdentifierObject, ResourceIdentifierObject } from "../../../types/spec/json-api-raw.js";
 import type { ForgetMethod, GenerationMethod, KeyInfo, KeyInfoMethod, ResetMethod, UpdateMethod } from "../../-types/q/identifier.js";
 type TypeFromIdentifier<T> = T extends {
 	type: infer U;
 } ? U : string;
-type NarrowIdentifierIfPossible<T> = T extends ExistingResourceIdentifierObject ? StableExistingRecordIdentifier<TypeFromIdentifier<T>> : StableRecordIdentifier;
-export declare function isStableIdentifier(identifier: unknown): identifier is StableRecordIdentifier;
-export declare function isDocumentIdentifier(identifier: unknown): identifier is StableDocumentIdentifier;
+type NarrowIdentifierIfPossible<T> = T extends ExistingResourceIdentifierObject ? PersistedResourceKey<TypeFromIdentifier<T>> : ResourceKey;
+export declare function isResourceKey(identifier: unknown): identifier is ResourceKey;
+export declare function isRequestKey(identifier: unknown): identifier is RequestKey;
 interface KeyOptions {
 	lid: IdentifierMap;
 	id: IdentifierMap;
@@ -15,16 +15,16 @@ interface KeyOptions {
 type TypeMap = {
 	[key: string]: KeyOptions;
 };
-// type IdentifierTypeLookup = { all: Set<StableRecordIdentifier>; id: Map<string, StableRecordIdentifier> };
+// type IdentifierTypeLookup = { all: Set<ResourceKey>; id: Map<string, ResourceKey> };
 // type IdentifiersByType = Map<string, IdentifierTypeLookup>;
-type IdentifierMap = Map<string, StableRecordIdentifier>;
+type IdentifierMap = Map<string, ResourceKey>;
 type StableCache = {
 	resources: IdentifierMap;
-	documents: Map<string, StableDocumentIdentifier>;
+	documents: Map<string, RequestKey>;
 	resourcesByType: TypeMap;
 	polymorphicLidBackMap: Map<string, string[]>;
 };
-export type MergeMethod = (targetIdentifier: StableRecordIdentifier, matchedIdentifier: StableRecordIdentifier, resourceData: unknown) => StableRecordIdentifier;
+export type MergeMethod = (targetIdentifier: ResourceKey, matchedIdentifier: ResourceKey, resourceData: unknown) => ResourceKey;
 /**
 Configures how unique identifier lid strings are generated by @ember-data/store.
 
@@ -163,10 +163,10 @@ to the application instance, you may not need to implement the `resetMethod`.
 export declare function setIdentifierResetMethod(method: ResetMethod | null): void;
 /**
 Configure a callback for when the identifier cache is generating a new
-StableRecordIdentifier for a resource.
+ResourceKey for a resource.
 
 This method controls the `type` and `id` that will be assigned to the
-`StableRecordIdentifier` that is created.
+`ResourceKey` that is created.
 
 This configuration MUST occur prior to the store instance being created.
 
@@ -178,7 +178,7 @@ import { setKeyInfoForResource } from '@warp-drive/core';
 */
 export declare function setKeyInfoForResource(method: KeyInfoMethod | null): void;
 /**
-* Each instance of {@link Store} receives a unique instance of a IdentifierCache.
+* Each instance of {@link Store} receives a unique instance of a CacheKeyManager.
 *
 * This cache is responsible for assigning or retrieving the unique identify
 * for arbitrary resource data encountered by the store. Data representing
@@ -190,7 +190,7 @@ export declare function setKeyInfoForResource(method: KeyInfoMethod | null): voi
 * @hideconstructor
 * @public
 */
-export declare class IdentifierCache {
+export declare class CacheKeyManager {
 	/** @internal */
 	_cache: StableCache;
 	private _generate;
@@ -215,7 +215,7 @@ export declare class IdentifierCache {
 		type: string;
 		id: string | null;
 		lid?: string;
-	}): StableRecordIdentifier;
+	}): ResourceKey;
 	/**
 	* @private
 	*/
@@ -229,14 +229,14 @@ export declare class IdentifierCache {
 	*
 	* @private
 	*/
-	peekRecordIdentifier(resource: ResourceIdentifierObject | Identifier): StableRecordIdentifier | undefined;
+	peekRecordIdentifier(resource: ResourceIdentifierObject): ResourceKey | undefined;
 	/**
 	Returns the DocumentIdentifier for the given Request, creates one if it does not yet exist.
 	Returns `null` if the request does not have a `cacheKey` or `url`.
 	
 	@public
 	*/
-	getOrCreateDocumentIdentifier(request: ImmutableRequestInfo): StableDocumentIdentifier | null;
+	getOrCreateDocumentIdentifier(request: ImmutableRequestInfo): RequestKey | null;
 	/**
 	Returns the Identifier for the given Resource, creates one if it does not yet exist.
 	
@@ -264,7 +264,7 @@ export declare class IdentifierCache {
 		type: string;
 		id?: string | null;
 		lid?: string;
-	}): StableRecordIdentifier;
+	}): ResourceKey;
 	/**
 	Provides the opportunity to update secondary lookup tables for existing identifiers
 	Called after an identifier created with `createIdentifierForNewRecord` has been
@@ -283,11 +283,12 @@ export declare class IdentifierCache {
 	
 	@public
 	*/
-	updateRecordIdentifier(identifierObject: RecordIdentifier, data: unknown): StableRecordIdentifier;
+	// FIXME audit usage
+	updateRecordIdentifier(identifierObject: ResourceKey, data: unknown): ResourceKey;
 	/**
 	* @private
 	*/
-	_mergeRecordIdentifiers(keyInfo: KeyInfo, identifier: StableRecordIdentifier, existingIdentifier: StableRecordIdentifier, data: unknown): StableRecordIdentifier;
+	_mergeRecordIdentifiers(keyInfo: KeyInfo, identifier: ResourceKey, existingIdentifier: ResourceKey, data: unknown): ResourceKey;
 	/**
 	Provides the opportunity to eliminate an identifier from secondary lookup tables
 	as well as eliminates it from ember-data's own lookup tables and book keeping.
@@ -298,7 +299,8 @@ export declare class IdentifierCache {
 	
 	@public
 	*/
-	forgetRecordIdentifier(identifierObject: RecordIdentifier): void;
+	// FIXME audit usage
+	forgetRecordIdentifier(identifierObject: ResourceKey): void;
 	/** @internal */
 	destroy(): void;
 }

package/declarations/store/-private/managers/cache-manager.d.ts

@@ -1,9 +1,9 @@
 import type { Cache, ChangedAttributesHash, RelationshipDiff } from "../../../types/cache.js";
 import type { Change } from "../../../types/cache/change.js";
-import type { MergeOperation } from "../../../types/cache/operations.js";
+import type { Operation } from "../../../types/cache/operations.js";
 import type { CollectionRelationship, ResourceRelationship } from "../../../types/cache/relationship.js";
 import type { LocalRelationshipOperation } from "../../../types/graph.js";
-import type { StableDocumentIdentifier, StableRecordIdentifier } from "../../../types/identifier.js";
+import type { RequestKey, ResourceKey } from "../../../types/identifier.js";
 import type { Value } from "../../../types/json/raw.js";
 import type { StructuredDataDocument, StructuredDocument } from "../../../types/request.js";
 import type { ResourceDocument, SingleResourceDataDocument } from "../../../types/spec/document.js";
@@ -61,14 +61,11 @@ export declare class CacheManager implements Cache {
 	/**
 	* Perform an operation on the cache to update the remote state.
 	*
-	* Note: currently the only valid operation is a MergeOperation
-	* which occurs when a collision of identifiers is detected.
-	*
 	* @public
 	* @param op the operation to perform
 	* @return {void}
 	*/
-	patch(op: MergeOperation): void;
+	patch(op: Operation | Operation[]): void;
 	/**
 	* Update resource data with a local mutation. Currently supports operations
 	* on relationships only.
@@ -105,32 +102,29 @@ export declare class CacheManager implements Cache {
 	* notifications for relational data.
 	*
 	* @public
-	* @param {StableRecordIdentifier | StableDocumentIdentifier} identifier
+	* @param {ResourceKey | RequestKey} cacheKey
 	* @return {ResourceDocument | ResourceBlob | null} the known resource data
 	*/
-	peek(identifier: StableRecordIdentifier): unknown;
-	peek(identifier: StableDocumentIdentifier): ResourceDocument | null;
-	peekRemoteState(identifier: StableRecordIdentifier): unknown;
-	peekRemoteState(identifier: StableDocumentIdentifier): ResourceDocument | null;
+	peek(cacheKey: ResourceKey): unknown;
+	peek(cacheKey: RequestKey): ResourceDocument | null;
+	peekRemoteState(cacheKey: ResourceKey): unknown;
+	peekRemoteState(cacheKey: RequestKey): ResourceDocument | null;
 	/**
 	* Peek the Cache for the existing request data associated with
 	* a cacheable request
 	*
-	* @param {StableDocumentIdentifier}
-	* @return {StableDocumentIdentifier | null}
+	* @param {RequestKey}
+	* @return {RequestKey | null}
 	* @public
 	*/
-	peekRequest(identifier: StableDocumentIdentifier): StructuredDocument<ResourceDocument> | null;
+	peekRequest(key: RequestKey): StructuredDocument<ResourceDocument> | null;
 	/**
-	* Push resource data from a remote source into the cache for this identifier
+	* Push resource data from a remote source into the cache for this ResourceKey
 	*
 	* @public
-	* @param identifier
-	* @param data
-	* @param hasRecord
-	* @return {void | string[]} if `hasRecord` is true then calculated key changes should be returned
+	* @return if `hasRecord` is true then calculated key changes should be returned
 	*/
-	upsert(identifier: StableRecordIdentifier, data: unknown, hasRecord: boolean): void | string[];
+	upsert(key: ResourceKey, data: unknown, hasRecord: boolean): void | string[];
 	// Cache Forking Support
 	// =====================
 	/**
@@ -165,7 +159,7 @@ export declare class CacheManager implements Cache {
 	* `Change` entry in the returned array.
 	*
 	* A `Change` is described by an object containing up to
-	* three properties: (1) the `identifier` of the entity that
+	* three properties: (1) the `ResourceKey` of the entity that
 	* changed; (2) the `op` code of that change being one of
 	* `upsert` or `remove`, and if the op is `upsert` a `patch`
 	* containing the data to merge into the cache for the given
@@ -180,7 +174,7 @@ export declare class CacheManager implements Cache {
 	*
 	* ```ts
 	* interface Change {
-	*  identifier: StableRecordIdentifier | StableDocumentIdentifier;
+	*  key: ResourceKey | RequestKey;
 	*  op: 'upsert' | 'remove';
 	*  patch?: unknown;
 	* }
@@ -228,97 +222,76 @@ export declare class CacheManager implements Cache {
 	* process. This return value behavior is deprecated.
 	*
 	* @public
-	* @param identifier
-	* @param options
 	*/
-	clientDidCreate(identifier: StableRecordIdentifier, options?: Record<string, unknown>): Record<string, unknown>;
+	clientDidCreate(key: ResourceKey, options?: Record<string, unknown>): Record<string, unknown>;
 	/**
 	* [LIFECYCLE] Signals to the cache that a resource
 	* will be part of a save transaction.
 	*
 	* @public
-	* @param identifier
+	* @param key
 	*/
-	willCommit(identifier: StableRecordIdentifier, context: StoreRequestContext): void;
+	willCommit(key: ResourceKey, context: StoreRequestContext): void;
 	/**
 	* [LIFECYCLE] Signals to the cache that a resource
 	* was successfully updated as part of a save transaction.
 	*
 	* @public
-	* @param identifier
-	* @param data
 	*/
-	didCommit(identifier: StableRecordIdentifier, result: StructuredDataDocument<unknown>): SingleResourceDataDocument;
+	didCommit(key: ResourceKey, result: StructuredDataDocument<unknown>): SingleResourceDataDocument;
 	/**
 	* [LIFECYCLE] Signals to the cache that a resource
 	* was update via a save transaction failed.
 	*
 	* @public
-	* @param identifier
-	* @param errors
 	*/
-	commitWasRejected(identifier: StableRecordIdentifier, errors?: ApiError[]): void;
+	commitWasRejected(key: ResourceKey, errors?: ApiError[]): void;
 	/**
 	* [LIFECYCLE] Signals to the cache that all data for a resource
 	* should be cleared.
 	*
 	* @public
-	* @param identifier
 	*/
-	unloadRecord(identifier: StableRecordIdentifier): void;
+	unloadRecord(key: ResourceKey): void;
 	// Granular Resource Data APIs
 	// ===========================
 	/**
 	* Retrieve the data for an attribute from the cache
 	*
 	* @public
-	* @param identifier
-	* @param propertyName
-	* @return {unknown}
 	*/
-	getAttr(identifier: StableRecordIdentifier, propertyName: string): Value | undefined;
+	getAttr(key: ResourceKey, propertyName: string): Value | undefined;
 	/**
 	* Retrieve the remote state for an attribute from the cache
 	*
 	* @public
-	* @param identifier
-	* @param propertyName
-	* @return {unknown}
 	*/
-	getRemoteAttr(identifier: StableRecordIdentifier, propertyName: string): Value | undefined;
+	getRemoteAttr(key: ResourceKey, propertyName: string): Value | undefined;
 	/**
 	* Mutate the data for an attribute in the cache
 	*
 	* @public
-	* @param identifier
-	* @param propertyName
-	* @param value
 	*/
-	setAttr(identifier: StableRecordIdentifier, propertyName: string, value: Value): void;
+	setAttr(key: ResourceKey, propertyName: string, value: Value): void;
 	/**
 	* Query the cache for the changed attributes of a resource.
 	*
 	* @public
-	* @param identifier
-	* @return
 	*/
-	changedAttrs(identifier: StableRecordIdentifier): ChangedAttributesHash;
+	changedAttrs(key: ResourceKey): ChangedAttributesHash;
 	/**
 	* Query the cache for whether any mutated attributes exist
 	*
 	* @public
-	* @param identifier
-	* @return {Boolean}
 	*/
-	hasChangedAttrs(identifier: StableRecordIdentifier): boolean;
+	hasChangedAttrs(key: ResourceKey): boolean;
 	/**
 	* Tell the cache to discard any uncommitted mutations to attributes
 	*
 	* @public
-	* @param identifier
 	* @return the names of attributes that were restored
 	*/
-	rollbackAttrs(identifier: StableRecordIdentifier): string[];
+	rollbackAttrs(key: ResourceKey): string[];
 	// Relationships
 	// =============
 	/**
@@ -330,32 +303,28 @@ export declare class CacheManager implements Cache {
 	* type RelationshipDiff =
 	| {
 	kind: 'collection';
-	remoteState: StableRecordIdentifier[];
-	additions: Set<StableRecordIdentifier>;
-	removals: Set<StableRecordIdentifier>;
-	localState: StableRecordIdentifier[];
+	remoteState: ResourceKey[];
+	additions: Set<ResourceKey>;
+	removals: Set<ResourceKey>;
+	localState: ResourceKey[];
 	reordered: boolean;
 	}
 	| {
 	kind: 'resource';
-	remoteState: StableRecordIdentifier | null;
-	localState: StableRecordIdentifier | null;
+	remoteState: ResourceKey | null;
+	localState: ResourceKey | null;
 	};
 	```
 	*
 	* @public
-	* @param {StableRecordIdentifier} identifier
-	* @return {Map<string, RelationshipDiff>}
 	*/
-	changedRelationships(identifier: StableRecordIdentifier): Map<string, RelationshipDiff>;
+	changedRelationships(key: ResourceKey): Map<string, RelationshipDiff>;
 	/**
 	* Query the cache for whether any mutated attributes exist
 	*
 	* @public
-	* @param {StableRecordIdentifier} identifier
-	* @return {Boolean}
 	*/
-	hasChangedRelationships(identifier: StableRecordIdentifier): boolean;
+	hasChangedRelationships(key: ResourceKey): boolean;
 	/**
 	* Tell the cache to discard any uncommitted mutations to relationships.
 	*
@@ -364,28 +333,23 @@ export declare class CacheManager implements Cache {
 	* This method is a candidate to become a mutation
 	*
 	* @public
-	* @param {StableRecordIdentifier} identifier
-	* @return {String[]} the names of relationships that were restored
+	* @return the names of relationships that were restored
 	*/
-	rollbackRelationships(identifier: StableRecordIdentifier): string[];
+	rollbackRelationships(key: ResourceKey): string[];
 	/**
 	* Query the cache for the current state of a relationship property
 	*
 	* @public
-	* @param identifier
-	* @param propertyName
 	* @return resource relationship object
 	*/
-	getRelationship(identifier: StableRecordIdentifier, propertyName: string): ResourceRelationship | CollectionRelationship;
+	getRelationship(key: ResourceKey, propertyName: string): ResourceRelationship | CollectionRelationship;
 	/**
 	* Query the cache for the remote state of a relationship property
 	*
 	* @public
-	* @param identifier
-	* @param propertyName
 	* @return resource relationship object
 	*/
-	getRemoteRelationship(identifier: StableRecordIdentifier, propertyName: string): ResourceRelationship | CollectionRelationship;
+	getRemoteRelationship(key: ResourceKey, propertyName: string): ResourceRelationship | CollectionRelationship;
 	// Resource State
 	// ===============
 	/**
@@ -393,51 +357,39 @@ export declare class CacheManager implements Cache {
 	* or remove such a mark.
 	*
 	* @public
-	* @param identifier
-	* @param isDeleted
 	*/
-	setIsDeleted(identifier: StableRecordIdentifier, isDeleted: boolean): void;
+	setIsDeleted(key: ResourceKey, isDeleted: boolean): void;
 	/**
 	* Query the cache for any validation errors applicable to the given resource.
 	*
 	* @public
-	* @param identifier
-	* @return
 	*/
-	getErrors(identifier: StableRecordIdentifier): ApiError[];
+	getErrors(key: ResourceKey): ApiError[];
 	/**
 	* Query the cache for whether a given resource has any available data
 	*
 	* @public
-	* @param identifier
-	* @return {Boolean}
 	*/
-	isEmpty(identifier: StableRecordIdentifier): boolean;
+	isEmpty(key: ResourceKey): boolean;
 	/**
 	* Query the cache for whether a given resource was created locally and not
 	* yet persisted.
 	*
 	* @public
-	* @param identifier
-	* @return {Boolean}
 	*/
-	isNew(identifier: StableRecordIdentifier): boolean;
+	isNew(key: ResourceKey): boolean;
 	/**
 	* Query the cache for whether a given resource is marked as deleted (but not
 	* necessarily persisted yet).
 	*
 	* @public
-	* @param identifier
-	* @return {Boolean}
 	*/
-	isDeleted(identifier: StableRecordIdentifier): boolean;
+	isDeleted(key: ResourceKey): boolean;
 	/**
 	* Query the cache for whether a given resource has been deleted and that deletion
 	* has also been persisted.
 	*
 	* @public
-	* @param identifier
-	* @return {Boolean}
 	*/
-	isDeletionCommitted(identifier: StableRecordIdentifier): boolean;
+	isDeletionCommitted(key: ResourceKey): boolean;
 }