@warp-drive/core 5.7.0-alpha.2 → 5.7.0-alpha.21

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

@@ -3,12 +3,54 @@ import { ContextOwner } from "./context.js";
 import type { DeferredFuture, Future, GodContext, Handler } from "./types.js";
 export declare const IS_CACHE_HANDLER: "___(unique) Symbol(IS_CACHE_HANDLER)";
 export declare function curryFuture<T>(owner: ContextOwner, inbound: Future<T>, outbound: DeferredFuture<T>): Future<T>;
-export interface HttpErrorProps extends DOMException {
+/**
+* Additional properties exposed on errors thrown by the
+* {@link Fetch | Fetch Handler}.
+*
+* In the case of an Abort or system/browser level issue,
+* this extends {@link DOMException}.
+*
+* Else it extends from {@link AggregateError} if the
+* response includes an array of errors, falling back
+* to {@link Error} as its base.
+*/
+export interface FetchError extends DOMException {
+	/**
+	* Alias for {@link FetchError.status | status}.
+	*
+	* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/status)
+	*/
 	code: number;
+	/**
+	* The name associated to the {@link FetchError.status | status code}.
+	*
+	* Typically this will be of the formula `StatusTextError` for instance
+	* a 404 status with status text of `Not Found` would have the name
+	* `NotFoundError`.
+	*/
 	name: string;
+	/**
+	* The http status code associated to the returned error.
+	*
+	* Browser/System level network errors will often have an error code of `0` or `5`.
+	* Aborted requests will have an error code of `20`.
+	*
+	* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/status)
+	*/
 	status: number;
+	/**
+	* The Status Text associated to the {@link FetchError.status | status code}
+	* for the error.
+	*
+	* [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/statusText)
+	*
+	*/
 	statusText: string;
-	isRequestError: boolean;
+	/**
+	* A property signifying that an Error uses the {@link FetchError}
+	* interface.
+	*/
+	isRequestError: true;
 }
 export declare function enhanceReason(reason?: string): DOMException;
 export declare function handleOutcome<T>(owner: ContextOwner, inbound: Promise<T | StructuredDataDocument<T>>, outbound: DeferredFuture<T>): Future<T>;

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

@@ -3,17 +3,11 @@ import type { ImmutableRequestInfo, RequestContext } from "../../../types/reques
 import type { ResourceIdentifierObject } from "../../../types/spec/json-api-raw.js";
 import type { RequestSignature } from "../../../types/symbols.js";
 import type { Store } from "../store-service.js";
-export type LooseStoreRequestInfo<
-	RT = unknown,
-	T = unknown
-> = Omit<ImmutableRequestInfo<RT, T>, "records" | "headers" | typeof RequestSignature> & {
+export type LooseStoreRequestInfo<RT = unknown> = Omit<ImmutableRequestInfo<RT>, "records" | "headers" | typeof RequestSignature> & {
 	records?: ResourceIdentifierObject[];
 	headers?: Headers;
 };
-export type StoreRequestInput<
-	RT = unknown,
-	T = unknown
-> = ImmutableRequestInfo<RT, T> | LooseStoreRequestInfo<RT, T>;
+export type StoreRequestInput<RT = unknown> = ImmutableRequestInfo<RT> | LooseStoreRequestInfo<RT>;
 export interface StoreRequestContext extends RequestContext {
 	request: ImmutableRequestInfo & {
 		store: Store;

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
@@ -71,7 +71,7 @@ export interface CachePolicy {
 	* so that request subscriptions can reload when needed.
 	*
 	* ```ts
-	* store.notifications.notify(identifier, 'invalidated');
+	* store.notifications.notify(identifier, 'invalidated', null);
 	* ```
 	*
 	* This allows anything subscribed to the request to be notified of the change
@@ -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,20 +23,21 @@ 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>;
 /**
 * We may eventually make this public, but its likely better for this to be killed off
 * @internal
 */
-export declare function storeFor(record: OpaqueRecordInstance): Store | undefined;
+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;
@@ -45,14 +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, properties?: CreateRecordProperties): 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: 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 {};

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

@@ -1,25 +1,27 @@
-import type { StableDocumentIdentifier, StableRecordIdentifier } from "../../../types/identifier.js";
+import type { RequestKey, ResourceKey } 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 RequestKey, type ResourceKey } 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.
 	
@@ -263,7 +263,8 @@ export declare class IdentifierCache {
 	createIdentifierForNewRecord(data: {
 		type: string;
 		id?: string | null;
-	}): StableRecordIdentifier;
+		lid?: string;
+	}): ResourceKey;
 	/**
 	Provides the opportunity to update secondary lookup tables for existing identifiers
 	Called after an identifier created with `createIdentifierForNewRecord` has been
@@ -282,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.
@@ -297,7 +299,8 @@ export declare class IdentifierCache {
 	
 	@public
 	*/
-	forgetRecordIdentifier(identifierObject: RecordIdentifier): void;
+	// FIXME audit usage
+	forgetRecordIdentifier(identifierObject: ResourceKey): void;
 	/** @internal */
 	destroy(): void;
 }