@warp-drive/core 5.8.0-alpha.3 → 5.8.0-alpha.32

package/dist/unpkg/prod-deprecated/declarations/store.d.ts

@@ -0,0 +1,2 @@
+export { DefaultCachePolicy, type PolicyConfig, type CacheControlValue, parseCacheControl } from "./store/-private/default-cache-policy.js";
+export type { NotificationManager } from "./store/-private/managers/notification-manager.js";

package/dist/unpkg/prod-deprecated/declarations/types/-private.d.ts

@@ -0,0 +1,22 @@
+type UniversalTransientKey = "REQ_ID";
+type UniversalKey = `(transient) ${UniversalTransientKey}` | "RequestMap" | "PromiseCache" | "RequestCache" | "SkipCache" | "EnableHydration" | "WarpDriveRuntimeConfig";
+type TransientKey = "transactionRef" | "configuredGenerationMethod" | "configuredUpdateMethod" | "configuredForgetMethod" | "configuredResetMethod" | "configuredKeyInfoMethod" | "signalHooks";
+type GlobalKey = `(transient) ${TransientKey}` | "AdapterError" | "InvalidError" | "TimeoutError" | "AbortError" | "UnauthorizedError" | "ForbiddenError" | "NotFoundError" | "ConflictError" | "ServerError" | "#{}" | "#[]" | "Signals" | "AvailableShims" | "FAKE_ARR" | "#source" | "#update" | "#notify" | "IS_COLLECTION" | "Touching" | "RequestPromise" | "SaveOp" | "LEGACY_SUPPORT" | "LegacySupport" | "Graphs" | "IS_FROZEN" | "IS_CACHE_HANDLER" | "CONFIG" | "DEBUG_MAP" | "IDENTIFIERS" | "DOCUMENTS" | "RecordCache" | "StoreMap" | "Store" | "$type" | "TransformName" | "RequestSignature" | "IS_FUTURE" | "DOC" | "ManagedArrayMap" | "ManagedObjectMap" | "Support" | "SOURCE" | "Destroy" | "Checkout" | "Commit" | "Context";
+type UniqueSymbol<T extends string> = `___(unique) Symbol(${T})`;
+type UniqueSymbolOr<
+	T,
+	K extends string
+> = T extends symbol ? UniqueSymbol<K> : T;
+export declare function getOrSetGlobal<
+	T,
+	K extends GlobalKey
+>(key: K, value: T): UniqueSymbolOr<T, K>;
+export declare function peekTransient<T>(key: TransientKey): T | null;
+export declare function setTransient<T>(key: TransientKey, value: T): T;
+export declare function getOrSetUniversal<
+	T,
+	K extends UniversalKey
+>(key: K, value: T): UniqueSymbolOr<T, K>;
+export declare function peekUniversalTransient<T>(key: UniversalTransientKey): T | null;
+export declare function setUniversalTransient<T>(key: UniversalTransientKey, value: T): T;
+export {};

package/dist/unpkg/prod-deprecated/declarations/types/cache/aliases.d.ts

@@ -0,0 +1 @@
+export type ResourceBlob = unknown;

package/dist/unpkg/prod-deprecated/declarations/types/cache/change.d.ts

@@ -0,0 +1,6 @@
+import type { RequestKey, ResourceKey } from "../identifier.js";
+export interface Change {
+	identifier: ResourceKey | RequestKey;
+	op: "upsert" | "remove";
+	patch?: unknown;
+}

package/dist/unpkg/prod-deprecated/declarations/types/cache/mutations.d.ts

@@ -0,0 +1,38 @@
+import type { ResourceKey } from "../identifier.js";
+export interface AddToResourceRelationshipMutation {
+	op: "add";
+	record: ResourceKey;
+	field: string;
+	value: ResourceKey | ResourceKey[];
+	index?: number;
+}
+export interface RemoveFromResourceRelationshipMutation {
+	op: "remove";
+	record: ResourceKey;
+	field: string;
+	value: ResourceKey | ResourceKey[];
+	index?: number;
+}
+export interface ReplaceRelatedRecordMutation {
+	op: "replaceRelatedRecord";
+	record: ResourceKey;
+	field: string;
+	value: ResourceKey | null;
+	prior?: ResourceKey;
+	index?: number;
+}
+export interface ReplaceRelatedRecordsMutation {
+	op: "replaceRelatedRecords";
+	record: ResourceKey;
+	field: string;
+	value: ResourceKey[];
+	prior?: ResourceKey[];
+	index?: number;
+}
+export interface SortRelatedRecordsMutation {
+	op: "sortRelatedRecords";
+	record: ResourceKey;
+	field: string;
+	value: ResourceKey[];
+}
+export type Mutation = ReplaceRelatedRecordsMutation | ReplaceRelatedRecordMutation | RemoveFromResourceRelationshipMutation | AddToResourceRelationshipMutation | SortRelatedRecordsMutation;

package/dist/unpkg/prod-deprecated/declarations/types/cache/operations.d.ts

@@ -0,0 +1,168 @@
+import type { PersistedResourceKey, RequestKey, ResourceKey } from "../identifier.js";
+import type { Value } from "../json/raw.js";
+import type { ExistingResourceObject } from "../spec/json-api-raw.js";
+import type { Relationship } from "./relationship.js";
+/**
+* All operations are objects with at least one property,
+* `op` which contains a string with the name of the operation
+* to perform.
+*/
+export interface Op {
+	/**
+	* The name of the {@link Op | operation}
+	*/
+	op: string;
+}
+/**
+* Occasionally the Store discovers that two previously
+* thought to be distinct resources refer to the same resource.
+*
+* This operation will be performed, giving the Cache the chance
+* to cleanup and merge internal state as desired when this discovery
+* is made.
+*/
+export interface MergeOperation extends Op {
+	op: "mergeIdentifiers";
+	/**
+	* The stale {@link ResourceKey | ResourceKey} that
+	* the cache should eliminate in favor of {@link MergeOperation.value | value}
+	*/
+	record: ResourceKey;
+	/**
+	* The kept {@link ResourceKey | ResourceKey} that
+	* the cache should also keep and merge {@link MergeOperation.record | record} into.
+	*/
+	value: ResourceKey;
+}
+/**
+* Removes a document and its associated request from
+* the cache.
+*/
+export interface RemoveDocumentOperation extends Op {
+	op: "remove";
+	/**
+	* The cache key for the request
+	*/
+	record: RequestKey;
+}
+/**
+* Removes a resource from the cache. This is treated
+* as if a remote deletion has occurred, and all references
+* to the resource should be eliminated.
+*/
+export interface RemoveResourceOperation extends Op {
+	op: "remove";
+	/**
+	* The cache key for the resource
+	*/
+	record: PersistedResourceKey;
+}
+/**
+* Adds a resource to the cache.
+*/
+export interface AddResourceOperation extends Op {
+	op: "add";
+	/**
+	* The cache key for the resource
+	*/
+	record: PersistedResourceKey;
+	/**
+	* The data for the resource
+	*/
+	value: ExistingResourceObject;
+}
+/**
+* Upserts (merges) new state for a resource
+*/
+export interface UpdateResourceOperation extends Op {
+	op: "update";
+	record: PersistedResourceKey;
+	value: ExistingResourceObject;
+}
+/**
+* Replaces the state of a field with a new state
+*/
+export interface UpdateResourceFieldOperation extends Op {
+	op: "update";
+	record: PersistedResourceKey;
+	field: string;
+	value: Value;
+}
+/**
+* Replaces the state of a relationship with a new state
+*/
+export interface UpdateResourceRelationshipOperation extends Op {
+	op: "update";
+	record: PersistedResourceKey;
+	field: string;
+	value: Relationship<PersistedResourceKey>;
+}
+/**
+* Adds a resource to a request document, optionally
+* at a specific index. This can be used to update the
+* result of a request.
+*/
+export interface AddToDocumentOperation extends Op {
+	op: "add";
+	record: RequestKey;
+	field: "data" | "included";
+	value: PersistedResourceKey | PersistedResourceKey[];
+	index?: number;
+}
+/**
+* Adds the specified ResourceKeys to a relationship
+*/
+export interface AddToResourceRelationshipOperation extends Op {
+	op: "add";
+	record: PersistedResourceKey;
+	field: string;
+	value: PersistedResourceKey | PersistedResourceKey[];
+	index?: number;
+}
+/**
+* Removes the specified ResourceKeys from a relationship
+*/
+export interface RemoveFromResourceRelationshipOperation extends Op {
+	op: "remove";
+	record: PersistedResourceKey;
+	field: string;
+	value: PersistedResourceKey | PersistedResourceKey[];
+	index?: number;
+}
+/**
+* Removes a resource from a request document, optionally
+* at a specific index. This can be used to update the
+* result of a request.
+*/
+export interface RemoveFromDocumentOperation extends Op {
+	op: "remove";
+	record: RequestKey;
+	field: "data" | "included";
+	value: PersistedResourceKey | PersistedResourceKey[];
+	index?: number;
+}
+/**
+* {@link Cache} Operations perform updates to the
+* Cache's "remote" (or clean) state to reflect external
+* changes.
+*
+* Usually operations represent the result of a {@link WebSocket} or
+* {@link EventSource | ServerEvent} message, though they can also be used to carefully
+* patch the state of the cache with information known by the
+* application or developer.
+*
+* Operations are applied via {@link Cache.patch}.
+*
+* See also:
+* - {@link MergeOperation}
+* - {@link RemoveResourceOperation}
+* - {@link RemoveDocumentOperation}
+* - {@link AddResourceOperation}
+* - {@link UpdateResourceOperation}
+* - {@link UpdateResourceFieldOperation}
+* - {@link AddToResourceRelationshipOperation}
+* - {@link RemoveFromResourceRelationshipOperation}
+* - {@link AddToDocumentOperation}
+* - {@link RemoveFromDocumentOperation}
+*/
+export type Operation = MergeOperation | RemoveResourceOperation | RemoveDocumentOperation | AddResourceOperation | UpdateResourceOperation | UpdateResourceFieldOperation | AddToResourceRelationshipOperation | RemoveFromResourceRelationshipOperation | AddToDocumentOperation | RemoveFromDocumentOperation;

package/dist/unpkg/prod-deprecated/declarations/types/cache/relationship.d.ts

@@ -0,0 +1,13 @@
+import type { ResourceKey } from "../identifier.js";
+import type { Links, Meta, PaginationLinks } from "../spec/json-api-raw.js";
+export interface ResourceRelationship<T = ResourceKey> {
+	data?: T | null;
+	meta?: Meta;
+	links?: Links;
+}
+export interface CollectionRelationship<T = ResourceKey> {
+	data?: T[];
+	meta?: Meta;
+	links?: PaginationLinks;
+}
+export type Relationship<T = ResourceKey> = ResourceRelationship<T> | CollectionRelationship<T>;

package/dist/unpkg/prod-deprecated/declarations/types/cache.d.ts

@@ -0,0 +1,429 @@
+import type { ResourceBlob } from "./cache/aliases.js";
+import type { Change } from "./cache/change.js";
+import type { Mutation } from "./cache/mutations.js";
+import type { Operation } from "./cache/operations.js";
+import type { CollectionRelationship, ResourceRelationship } from "./cache/relationship.js";
+import type { RequestKey, ResourceKey } from "./identifier.js";
+import type { Value } from "./json/raw.js";
+import type { TypeFromInstanceOrString } from "./record.js";
+import type { RequestContext, StructuredDataDocument, StructuredDocument } from "./request.js";
+import type { CollectionResourceDataDocument, ResourceDocument, SingleResourceDataDocument } from "./spec/document.js";
+import type { ApiError } from "./spec/error.js";
+/**
+* A hash of changed attributes with the key being the attribute name and the value being an
+* array of `[oldValue, newValue]`.
+*
+*/
+export type ChangedAttributesHash = Record<string, [Value | undefined, Value]>;
+export type RelationshipDiff = {
+	kind: "collection";
+	remoteState: ResourceKey[];
+	additions: Set<ResourceKey>;
+	removals: Set<ResourceKey>;
+	localState: ResourceKey[];
+	reordered: boolean;
+} | {
+	kind: "resource";
+	remoteState: ResourceKey | null;
+	localState: ResourceKey | null;
+};
+/**
+* The interface for WarpDrive Caches.
+*
+* A Cache handles in-memory storage of Document and Resource
+* data.
+*
+* @public
+*/
+export interface Cache {
+	/**
+	* The Cache Version that this implementation implements.
+	*
+	* @public
+	*/
+	version: "2";
+	/**
+	* Cache the response to a request
+	*
+	* Unlike `store.push` which has UPSERT
+	* semantics, `put` has `replace` semantics similar to
+	* the `http` method `PUT`
+	*
+	* the individually cacheable resource data it may contain
+	* should upsert, but the document data surrounding it should
+	* fully replace any existing information
+	*
+	* Note that in order to support inserting arbitrary data
+	* to the cache that did not originate from a request `put`
+	* should expect to sometimes encounter a document with only
+	* a `content` member and therefor must not assume the existence
+	* of `request` and `response` on the document.
+	*
+	* @public
+	*/
+	put<T>(doc: StructuredDocument<T> | {
+		content: T;
+	}): ResourceDocument;
+	/**
+	* Update the "remote" or "canonical" (persisted) state of the Cache
+	* by merging new information into the existing state.
+	*
+	* @public
+	* @param op the operation(s) to perform
+	*/
+	patch(op: Operation | Operation[]): void;
+	/**
+	* Update the "local" or "current" (unpersisted) state of the Cache
+	*
+	* @public
+	*/
+	mutate(mutation: Mutation): void;
+	/**
+	* Peek resource data from the Cache.
+	*
+	* In development, if the return value
+	* is JSON the return value
+	* will be deep-cloned and deep-frozen
+	* to prevent mutation thereby enforcing cache
+	* Immutability.
+	*
+	* This form of peek is useful for implementations
+	* that want to feed raw-data from cache to the UI
+	* or which want to interact with a blob of data
+	* directly from the presentation cache.
+	*
+	* An implementation might want to do this because
+	* de-referencing records which read from their own
+	* blob is generally safer because the record does
+	* not require retainining connections to the Store
+	* and Cache to present data on a per-field basis.
+	*
+	* This generally takes the place of `getAttr` as
+	* an API and may even take the place of `getRelationship`
+	* depending on implementation specifics, though this
+	* latter usage is less recommended due to the advantages
+	* of the Graph handling necessary entanglements and
+	* notifications for relational data.
+	*
+	* @public
+	* @return the known resource data, if any
+	*/
+	peek<T = unknown>(cacheKey: ResourceKey<TypeFromInstanceOrString<T>>): T | null;
+	peek(cacheKey: RequestKey): ResourceDocument | null;
+	/**
+	* Peek remote resource data from the Cache.
+	*
+	* This will give the data provided from the server without any local changes.
+	*
+	* In development, if the return value
+	* is JSON the return value
+	* will be deep-cloned and deep-frozen
+	* to prevent mutation thereby enforcing cache
+	* Immutability.
+	*
+	* This form of peek is useful for implementations
+	* that want to feed raw-data from cache to the UI
+	* or which want to interact with a blob of data
+	* directly from the presentation cache.
+	*
+	* An implementation might want to do this because
+	* de-referencing records which read from their own
+	* blob is generally safer because the record does
+	* not require retainining connections to the Store
+	* and Cache to present data on a per-field basis.
+	*
+	* This generally takes the place of `getAttr` as
+	* an API and may even take the place of `getRelationship`
+	* depending on implementation specifics, though this
+	* latter usage is less recommended due to the advantages
+	* of the Graph handling necessary entanglements and
+	* notifications for relational data.
+	*
+	* @public
+	* @return the known data, if any
+	*/
+	peekRemoteState<T = unknown>(cacheKey: ResourceKey<TypeFromInstanceOrString<T>>): T | null;
+	peekRemoteState(cacheKey: RequestKey): ResourceDocument | null;
+	/**
+	* Peek the Cache for the existing request data associated with
+	* a cacheable request
+	*
+	* This is effectively the reverse of `put` for a request in
+	* that it will return the the request, response, and content
+	* whereas `peek` will return just the `content`.
+	*
+	* @public
+	*/
+	peekRequest(cacheKey: RequestKey): StructuredDocument<ResourceDocument> | null;
+	/**
+	* Push resource data from a remote source into the cache for this ResourceKey
+	*
+	* @public
+	* @return if `hasRecord` is true then calculated key changes should be returned
+	*/
+	upsert(cacheKey: ResourceKey, data: ResourceBlob, hasRecord: boolean): void | string[];
+	/**
+	* Create a fork of the cache from the current state.
+	*
+	* Applications should typically not call this method themselves,
+	* preferring instead to fork at the Store level, which will
+	* utilize this method to fork the cache.
+	*
+	* @public
+	*/
+	fork(): Promise<Cache>;
+	/**
+	* Merge a fork back into a parent Cache.
+	*
+	* Applications should typically not call this method themselves,
+	* preferring instead to merge at the Store level, which will
+	* utilize this method to merge the caches.
+	*
+	*/
+	merge(cache: Cache): Promise<void>;
+	/**
+	* Generate the list of changes applied to all
+	* record in the store.
+	*
+	* Each individual resource or document that has
+	* been mutated should be described as an individual
+	* `Change` entry in the returned array.
+	*
+	* A `Change` is described by an object containing up to
+	* three properties: (1) the `CacheKey` 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
+	* entity.
+	*
+	* This `patch` is opaque to the Store but should be understood
+	* by the Cache and may expect to be utilized by an Adapter
+	* when generating data during a `save` operation.
+	*
+	* It is generally recommended that the `patch` contain only
+	* the updated state, ignoring fields that are unchanged
+	*
+	* ```ts
+	* interface Change {
+	*  key: ResourceKey | RequestKey;
+	*  op: 'upsert' | 'remove';
+	*  patch?: unknown;
+	* }
+	* ```
+	*
+	* @public
+	*/
+	diff(): Promise<Change[]>;
+	/**
+	* Serialize the entire contents of the Cache into a Stream
+	* which may be fed back into a new instance of the same Cache
+	* via `cache.hydrate`.
+	*
+	* @return {Promise<ReadableStream>}
+	* @public
+	*/
+	dump(): Promise<ReadableStream<unknown>>;
+	/**
+	* hydrate a Cache from a Stream with content previously serialized
+	* from another instance of the same Cache, resolving when hydration
+	* is complete.
+	*
+	* This method should expect to be called both in the context of restoring
+	* the Cache during application rehydration after SSR **AND** at unknown
+	* times during the lifetime of an already booted application when it is
+	* desired to bulk-load additional information into the cache. This latter
+	* behavior supports optimizing pre/fetching of data for route transitions
+	* via data-only SSR modes.
+	*
+	* @public
+	*/
+	hydrate(stream: ReadableStream<unknown>): Promise<void>;
+	/**
+	* [LIFECYCLE] Signal to the cache that a new record has been instantiated on the client
+	*
+	* It returns properties from options that should be set on the record during the create
+	* process. This return value behavior is deprecated.
+	*
+	* @public
+	*/
+	clientDidCreate(cacheKey: ResourceKey, createArgs?: Record<string, unknown>): Record<string, unknown>;
+	/**
+	* [LIFECYCLE] Signals to the cache that a resource
+	* will be part of a save transaction.
+	*
+	* @public
+	*/
+	willCommit(cacheKey: ResourceKey | ResourceKey[], context: RequestContext | null): void;
+	/**
+	* [LIFECYCLE] Signals to the cache that a resource
+	* was successfully updated as part of a save transaction.
+	*
+	* @public
+	* @param cacheKey - the primary ResourceKey that was operated on
+	* @param result - a document in the cache format containing any updated data
+	*/
+	didCommit(cacheKey: ResourceKey, result: StructuredDataDocument<SingleResourceDataDocument> | null): SingleResourceDataDocument;
+	didCommit(cacheKey: ResourceKey[], result: StructuredDataDocument<SingleResourceDataDocument> | null): SingleResourceDataDocument;
+	didCommit(cacheKey: ResourceKey[], result: StructuredDataDocument<CollectionResourceDataDocument> | null): CollectionResourceDataDocument;
+	/**
+	* [LIFECYCLE] Signals to the cache that a resource
+	* was update via a save transaction failed.
+	*
+	* @public
+	*/
+	commitWasRejected(cacheKey: ResourceKey | ResourceKey[], errors?: ApiError[]): void;
+	/**
+	* [LIFECYCLE] Signals to the cache that all data for a resource
+	* should be cleared.
+	*
+	* This method is a candidate to become a mutation
+	*
+	* @public
+	*/
+	unloadRecord(cacheKey: ResourceKey): void;
+	/**
+	* Retrieve the data for an attribute from the cache
+	*
+	* @public
+	*/
+	getAttr(cacheKey: ResourceKey, field: string | string[]): Value | undefined;
+	/**
+	* Retrieve remote state without any local changes for a specific attribute
+	*
+	* @public
+	*/
+	getRemoteAttr(cacheKey: ResourceKey, field: string | string[]): Value | undefined;
+	/**
+	* Mutate the data for an attribute in the cache
+	*
+	* This method is a candidate to become a mutation
+	*
+	* @public
+	*/
+	setAttr(cacheKey: ResourceKey, field: string | string[], value: Value): void;
+	/**
+	* Query the cache for the changed attributes of a resource.
+	*
+	* Returns a map of field names to tuples of [old, new] values
+	*
+	* ```
+	* { <field>: [<old>, <new>] }
+	* ```
+	*
+	* @public
+	*/
+	changedAttrs(cacheKey: ResourceKey): ChangedAttributesHash;
+	/**
+	* Query the cache for whether any mutated attributes exist
+	*
+	* @public
+	*/
+	hasChangedAttrs(cacheKey: ResourceKey): boolean;
+	/**
+	* Tell the cache to discard any uncommitted mutations to attributes
+	*
+	* This method is a candidate to become a mutation
+	*
+	* @public
+	* @return the names of fields that were restored
+	*/
+	rollbackAttrs(cacheKey: ResourceKey): string[];
+	/**
+	* Query the cache for the changes to relationships of a resource.
+	*
+	* Returns a map of relationship names to RelationshipDiff objects.
+	*
+	* ```ts
+	* type RelationshipDiff =
+	| {
+	kind: 'collection';
+	remoteState: ResourceKey[];
+	additions: Set<ResourceKey>;
+	removals: Set<ResourceKey>;
+	localState: ResourceKey[];
+	reordered: boolean;
+	}
+	| {
+	kind: 'resource';
+	remoteState: ResourceKey | null;
+	localState: ResourceKey | null;
+	};
+	```
+	*
+	* @public
+	*/
+	changedRelationships(cacheKey: ResourceKey): Map<string, RelationshipDiff>;
+	/**
+	* Query the cache for whether any mutated attributes exist
+	*
+	* @public
+	*/
+	hasChangedRelationships(cacheKey: ResourceKey): boolean;
+	/**
+	* Tell the cache to discard any uncommitted mutations to relationships.
+	*
+	* This will also discard the change on any appropriate inverses.
+	*
+	* This method is a candidate to become a mutation
+	*
+	* @public
+	* @return the names of relationships that were restored
+	*/
+	rollbackRelationships(cacheKey: ResourceKey): string[];
+	/**
+	* Query the cache for the current state of a relationship property
+	*
+	* @public
+	* @return resource relationship object
+	*/
+	getRelationship(cacheKey: ResourceKey, field: string, isCollection?: boolean): ResourceRelationship | CollectionRelationship;
+	/**
+	* Query the cache for the server state of a relationship property without any local changes
+	*
+	* @public
+	* @return resource relationship object
+	*/
+	getRemoteRelationship(cacheKey: ResourceKey, field: string, isCollection?: boolean): ResourceRelationship | CollectionRelationship;
+	/**
+	* Update the cache state for the given resource to be marked
+	* as locally deleted, or remove such a mark.
+	*
+	* This method is a candidate to become a mutation
+	*
+	* @public
+	*/
+	setIsDeleted(cacheKey: ResourceKey, isDeleted: boolean): void;
+	/**
+	* Query the cache for any validation errors applicable to the given resource.
+	*
+	* @public
+	*/
+	getErrors(cacheKey: ResourceKey): ApiError[];
+	/**
+	* Query the cache for whether a given resource has any available data
+	*
+	* @public
+	*/
+	isEmpty(cacheKey: ResourceKey): boolean;
+	/**
+	* Query the cache for whether a given resource was created locally and not
+	* yet persisted.
+	*
+	* @public
+	*/
+	isNew(cacheKey: ResourceKey): boolean;
+	/**
+	* Query the cache for whether a given resource is marked as deleted (but not
+	* necessarily persisted yet).
+	*
+	* @public
+	*/
+	isDeleted(cacheKey: ResourceKey): boolean;
+	/**
+	* Query the cache for whether a given resource has been deleted and that deletion
+	* has also been persisted.
+	*
+	* @public
+	*/
+	isDeletionCommitted(cacheKey: ResourceKey): boolean;
+}