@warp-drive/core 5.6.0-alpha.15 → 5.6.0-alpha.17

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

@@ -1,93 +1,98 @@
-import type { StableDocumentIdentifier, StableRecordIdentifier } from '../../../types/identifier.ts';
-import type { Store } from '../store-service.ts';
+import type { StableDocumentIdentifier, StableRecordIdentifier } from "../../../types/identifier.js";
+import type { Store } from "../store-service.js";
 export type UnsubscribeToken = object;
-export type CacheOperation = 'added' | 'removed' | 'updated' | 'state';
-export type DocumentCacheOperation = 'invalidated' | 'added' | 'removed' | 'updated' | 'state';
-export type NotificationType = 'attributes' | 'relationships' | 'identity' | 'errors' | 'meta' | CacheOperation;
+export type CacheOperation = "added" | "removed" | "updated" | "state";
+export type DocumentCacheOperation = "invalidated" | "added" | "removed" | "updated" | "state";
+export type NotificationType = "attributes" | "relationships" | "identity" | "errors" | "meta" | CacheOperation;
 export interface NotificationCallback {
-    (identifier: StableRecordIdentifier, notificationType: 'attributes' | 'relationships', key?: string): void;
-    (identifier: StableRecordIdentifier, notificationType: 'errors' | 'meta' | 'identity' | 'state'): void;
-    (identifier: StableRecordIdentifier, notificationType: CacheOperation): void;
+	(identifier: StableRecordIdentifier, notificationType: "attributes" | "relationships", key?: string): void;
+	(identifier: StableRecordIdentifier, notificationType: "errors" | "meta" | "identity" | "state"): void;
+	(identifier: StableRecordIdentifier, notificationType: CacheOperation): void;
 }
 export interface ResourceOperationCallback {
-    (identifier: StableRecordIdentifier, notificationType: CacheOperation): void;
+	// resource updates
+	(identifier: StableRecordIdentifier, notificationType: CacheOperation): void;
 }
 export interface DocumentOperationCallback {
-    (identifier: StableDocumentIdentifier, notificationType: DocumentCacheOperation): void;
+	// document updates
+	(identifier: StableDocumentIdentifier, notificationType: DocumentCacheOperation): void;
 }
 /**
- * The NotificationManager provides the ability to subscribe to
- * changes to Cache state.
- *
- * This Feature is what allows WarpDrive to create subscriptions that
- * work with any framework or change-notification system.
- *
- * @class NotificationManager
- * @public
- */
+* The NotificationManager provides the ability to subscribe to
+* changes to Cache state.
+*
+* This Feature is what allows WarpDrive to create subscriptions that
+* work with any framework or change-notification system.
+*
+* @hideconstructor
+* @public
+*/
 export default class NotificationManager {
-    store: Store;
-    isDestroyed: boolean;
-    _buffered: Map<StableDocumentIdentifier | StableRecordIdentifier, [string, string | undefined][]>;
-    _cache: Map<StableDocumentIdentifier | StableRecordIdentifier | 'resource' | 'document', Array<NotificationCallback | ResourceOperationCallback | DocumentOperationCallback>>;
-    _hasFlush: boolean;
-    _onFlushCB?: () => void;
-    constructor(store: Store);
-    /**
-     * Subscribe to changes for a given resource identifier, resource addition/removal, or document addition/removal.
-     *
-     * ```ts
-     * export type CacheOperation = 'added' | 'removed' | 'updated' | 'state';
-     *
-     * export interface NotificationCallback {
-     *   (identifier: StableRecordIdentifier, notificationType: 'attributes' | 'relationships', key?: string): void;
-     *   (identifier: StableRecordIdentifier, notificationType: 'errors' | 'meta' | 'identity' | 'state'): void;
-     *   (identifier: StableRecordIdentifier, notificationType: NotificationType, key?: string): void;
-     * }
-     * export interface ResourceOperationCallback {
-     *   // resource updates
-     *   (identifier: StableRecordIdentifier, notificationType: CacheOperation): void;
-     * }
-     * export interface DocumentOperationCallback {
-     *   // document updates
-     *   (identifier: StableDocumentIdentifier, notificationType: CacheOperation): void;
-     * }
-     * ```
-     *
-     * @public
-     * @param {StableDocumentIdentifier | StableRecordIdentifier | 'resource' | 'document'} identifier
-     * @param {NotificationCallback | ResourceOperationCallback | DocumentOperationCallback} callback
-     * @return {UnsubscribeToken} an opaque token to be used with unsubscribe
-     */
-    subscribe(identifier: StableRecordIdentifier, callback: NotificationCallback): UnsubscribeToken;
-    subscribe(identifier: 'resource', callback: ResourceOperationCallback): UnsubscribeToken;
-    subscribe(identifier: 'document' | StableDocumentIdentifier, callback: DocumentOperationCallback): UnsubscribeToken;
-    /**
-     * remove a previous subscription
-     *
-     * @public
-     * @param {UnsubscribeToken} token
-     */
-    unsubscribe(token: UnsubscribeToken): void;
-    /**
-     * Custom Caches and Application Code should not call this method directly.
-     *
-     * @param identifier
-     * @param value
-     * @param key
-     * @return {Boolean} whether a notification was delivered to any subscribers
-     * @private
-     */
-    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;
-    _onNextFlush(cb: () => void): void;
-    _scheduleNotify(): boolean;
-    _flush(): void;
-    _flushNotification(identifier: StableRecordIdentifier, value: 'attributes' | 'relationships', key?: string): boolean;
-    _flushNotification(identifier: StableRecordIdentifier, value: 'errors' | 'meta' | 'identity' | 'state'): boolean;
-    _flushNotification(identifier: StableRecordIdentifier | StableDocumentIdentifier, value: CacheOperation): boolean;
-    destroy(): void;
+	/** @internal */
+	private store;
+	/** @internal */
+	private isDestroyed;
+	/** @internal */
+	private _buffered;
+	/** @internal */
+	private _cache;
+	/** @internal */
+	private _hasFlush;
+	/** @internal */
+	private _onFlushCB?;
+	constructor(store: Store);
+	/**
+	* Subscribe to changes for a given resource identifier, resource addition/removal, or document addition/removal.
+	*
+	* ```ts
+	* export type CacheOperation = 'added' | 'removed' | 'updated' | 'state';
+	*
+	* export interface NotificationCallback {
+	*   (identifier: StableRecordIdentifier, notificationType: 'attributes' | 'relationships', key?: string): void;
+	*   (identifier: StableRecordIdentifier, notificationType: 'errors' | 'meta' | 'identity' | 'state'): void;
+	*   (identifier: StableRecordIdentifier, notificationType: NotificationType, key?: string): void;
+	* }
+	* export interface ResourceOperationCallback {
+	*   // resource updates
+	*   (identifier: StableRecordIdentifier, notificationType: CacheOperation): void;
+	* }
+	* export interface DocumentOperationCallback {
+	*   // document updates
+	*   (identifier: StableDocumentIdentifier, notificationType: CacheOperation): void;
+	* }
+	* ```
+	*
+	* @public
+	* @param {StableDocumentIdentifier | StableRecordIdentifier | 'resource' | 'document'} identifier
+	* @param {NotificationCallback | ResourceOperationCallback | DocumentOperationCallback} callback
+	* @return {UnsubscribeToken} an opaque token to be used with unsubscribe
+	*/
+	subscribe(identifier: StableRecordIdentifier, callback: NotificationCallback): UnsubscribeToken;
+	subscribe(identifier: "resource", callback: ResourceOperationCallback): UnsubscribeToken;
+	subscribe(identifier: "document" | StableDocumentIdentifier, callback: DocumentOperationCallback): UnsubscribeToken;
+	/**
+	* remove a previous subscription
+	*
+	* @public
+	*/
+	unsubscribe(token: UnsubscribeToken): void;
+	/**
+	* Custom Caches and Application Code should not call this method directly.
+	*
+	* @private
+	*/
+	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;
+	/** @internal */
+	_onNextFlush(cb: () => void): void;
+	private _scheduleNotify;
+	/** @internal */
+	_flush(): void;
+	private _flushNotification;
+	private _flushNotification;
+	private _flushNotification;
+	/** @internal */
+	destroy(): void;
 }
-//# sourceMappingURL=notification-manager.d.ts.map

package/declarations/store/-private/managers/record-array-manager.d.ts

@@ -1,98 +1,97 @@
-import type { LocalRelationshipOperation } from '../../../types/graph.ts';
-import type { StableDocumentIdentifier, StableRecordIdentifier } from '../../../types/identifier.ts';
-import type { ImmutableRequestInfo } from '../../../types/request.ts';
-import type { CollectionResourceDocument } from '../../../types/spec/json-api-raw.ts';
-import { Collection, IdentifierArray } from '../record-arrays/identifier-array.ts';
-import type { Store } from '../store-service.ts';
-import type { UnsubscribeToken } from './notification-manager.ts';
+import type { LocalRelationshipOperation } from "../../../types/graph.js";
+import type { StableDocumentIdentifier, StableRecordIdentifier } from "../../../types/identifier.js";
+import type { ImmutableRequestInfo } from "../../../types/request.js";
+import type { CollectionResourceDocument } from "../../../types/spec/json-api-raw.js";
+import { Collection, IdentifierArray } from "../record-arrays/identifier-array.js";
+import type { Store } from "../store-service.js";
+import type { UnsubscribeToken } from "./notification-manager.js";
 /**
- * This is a clever optimization.
- *
- * clever optimizations rarely stand the test of time, so if you're
- * ever curious or think something better is possible please benchmark
- * and discuss. The benchmark for this at the time of writing is in
- * `scripts/benchmark-push.js`
- *
- * This approach turns out to be 150x faster in Chrome and node than
- * simply using push or concat. It's highly susceptible to the specifics
- * of the batch size, and may require tuning.
- *
- * Clever optimizations should always come with a `why`. This optimization
- * exists for two reasons.
- *
- * 1) array.push(...objects) and Array.prototype.push.apply(arr, objects)
- *   are susceptible to stack overflows. The size of objects at which this
- *   occurs varies by environment, browser, and current stack depth and memory
- *   pressure; however, it occurs in all browsers in fairly pristine conditions
- *   somewhere around 125k to 200k elements. Since WarpDrive regularly encounters
- *   arrays larger than this in size, we cannot use push.
- *
- * 2) `array.concat` or simply setting the array to a new reference is often an
- *   easier approach; however, native Proxy to an array cannot swap it's target array
- *   and attempts at juggling multiple array sources have proven to be victim to a number
- *   of browser implementation bugs. Should these bugs be addressed then we could
- *   simplify to using `concat`, however, do note this is currently 150x faster
- *   than concat, and due to the overloaded signature of concat will likely always
- *   be faster.
- *
- * Sincerely,
- *   - runspired (Chris Thoburn) 08/21/2022
- *
- * @function fastPush
- * @internal
- * @param target the array to push into
- * @param source the items to push into target
- */
+* This is a clever optimization.
+*
+* clever optimizations rarely stand the test of time, so if you're
+* ever curious or think something better is possible please benchmark
+* and discuss. The benchmark for this at the time of writing is in
+* `scripts/benchmark-push.js`
+*
+* This approach turns out to be 150x faster in Chrome and node than
+* simply using push or concat. It's highly susceptible to the specifics
+* of the batch size, and may require tuning.
+*
+* Clever optimizations should always come with a `why`. This optimization
+* exists for two reasons.
+*
+* 1) array.push(...objects) and Array.prototype.push.apply(arr, objects)
+*   are susceptible to stack overflows. The size of objects at which this
+*   occurs varies by environment, browser, and current stack depth and memory
+*   pressure; however, it occurs in all browsers in fairly pristine conditions
+*   somewhere around 125k to 200k elements. Since WarpDrive regularly encounters
+*   arrays larger than this in size, we cannot use push.
+*
+* 2) `array.concat` or simply setting the array to a new reference is often an
+*   easier approach; however, native Proxy to an array cannot swap it's target array
+*   and attempts at juggling multiple array sources have proven to be victim to a number
+*   of browser implementation bugs. Should these bugs be addressed then we could
+*   simplify to using `concat`, however, do note this is currently 150x faster
+*   than concat, and due to the overloaded signature of concat will likely always
+*   be faster.
+*
+* Sincerely,
+*   - runspired (Chris Thoburn) 08/21/2022
+*
+* @function fastPush
+* @internal
+* @param target the array to push into
+* @param source the items to push into target
+*/
 export declare function fastPush<T>(target: T[], source: T[]): void;
-type ChangeSet = Map<StableRecordIdentifier, 'add' | 'del'>;
+type ChangeSet = Map<StableRecordIdentifier, "add" | "del">;
 /**
-  @class RecordArrayManager
-  @internal
+@class RecordArrayManager
+@internal
 */
 export declare class RecordArrayManager {
-    store: Store;
-    isDestroying: boolean;
-    isDestroyed: boolean;
-    _set: Map<IdentifierArray, Set<StableRecordIdentifier>>;
-    _live: Map<string, IdentifierArray>;
-    _managed: Set<IdentifierArray>;
-    _pending: Map<IdentifierArray, ChangeSet>;
-    _identifiers: Map<StableRecordIdentifier, Set<Collection>>;
-    _staged: Map<string, ChangeSet>;
-    _subscription: UnsubscribeToken;
-    _documentSubscription: UnsubscribeToken;
-    _keyedArrays: Map<string, Collection>;
-    _visibilitySet: Map<StableRecordIdentifier, boolean>;
-    constructor(options: {
-        store: Store;
-    });
-    _syncArray(array: IdentifierArray | Collection): void;
-    mutate(mutation: LocalRelationshipOperation): void;
-    /**
-      Get the `RecordArray` for a modelName, which contains all loaded records of
-      given modelName.
-  
-      @internal
-      @param {String} modelName
-      @return {RecordArray}
-    */
-    liveArrayFor(type: string): IdentifierArray;
-    getCollection(config: {
-        type?: string;
-        query?: ImmutableRequestInfo | Record<string, unknown>;
-        identifiers?: StableRecordIdentifier[];
-        doc?: CollectionResourceDocument;
-        identifier?: StableDocumentIdentifier | null;
-    }): Collection;
-    dirtyArray(array: IdentifierArray, delta: number, shouldSyncFromCache: boolean): void;
-    _getPendingFor(identifier: StableRecordIdentifier, includeManaged: boolean, isRemove?: boolean): Map<IdentifierArray, ChangeSet> | void;
-    populateManagedArray(array: Collection, identifiers: StableRecordIdentifier[], payload: CollectionResourceDocument | null): void;
-    identifierAdded(identifier: StableRecordIdentifier): void;
-    identifierRemoved(identifier: StableRecordIdentifier): void;
-    identifierChanged(identifier: StableRecordIdentifier): void;
-    clear(isClear?: boolean): void;
-    destroy(): void;
+	store: Store;
+	isDestroying: boolean;
+	isDestroyed: boolean;
+	_set: Map<IdentifierArray, Set<StableRecordIdentifier>>;
+	_live: Map<string, IdentifierArray>;
+	_managed: Set<IdentifierArray>;
+	_pending: Map<IdentifierArray, ChangeSet>;
+	_identifiers: Map<StableRecordIdentifier, Set<Collection>>;
+	_staged: Map<string, ChangeSet>;
+	_subscription: UnsubscribeToken;
+	_documentSubscription: UnsubscribeToken;
+	_keyedArrays: Map<string, Collection>;
+	_visibilitySet: Map<StableRecordIdentifier, boolean>;
+	constructor(options: {
+		store: Store;
+	});
+	_syncArray(array: IdentifierArray | Collection): void;
+	mutate(mutation: LocalRelationshipOperation): void;
+	/**
+	Get the `RecordArray` for a modelName, which contains all loaded records of
+	given modelName.
+	
+	@internal
+	@param {String} modelName
+	@return {RecordArray}
+	*/
+	liveArrayFor(type: string): IdentifierArray;
+	getCollection(config: {
+		type?: string;
+		query?: ImmutableRequestInfo | Record<string, unknown>;
+		identifiers?: StableRecordIdentifier[];
+		doc?: CollectionResourceDocument;
+		identifier?: StableDocumentIdentifier | null;
+	}): Collection;
+	dirtyArray(array: IdentifierArray, delta: number, shouldSyncFromCache: boolean): void;
+	_getPendingFor(identifier: StableRecordIdentifier, includeManaged: boolean, isRemove?: boolean): Map<IdentifierArray, ChangeSet> | void;
+	populateManagedArray(array: Collection, identifiers: StableRecordIdentifier[], payload: CollectionResourceDocument | null): void;
+	identifierAdded(identifier: StableRecordIdentifier): void;
+	identifierRemoved(identifier: StableRecordIdentifier): void;
+	identifierChanged(identifier: StableRecordIdentifier): void;
+	clear(isClear?: boolean): void;
+	destroy(): void;
 }
 export declare function disassociateIdentifier(ArraysCache: Map<StableRecordIdentifier, Set<Collection>>, array: Collection, identifier: StableRecordIdentifier): void;
 export {};
-//# sourceMappingURL=record-array-manager.d.ts.map

package/declarations/store/-private/network/request-cache.d.ts

@@ -1,104 +1,107 @@
-import type { StableRecordIdentifier } from '../../../types/identifier.ts';
-import type { FindRecordOptions } from '../../-types/q/store.ts';
-import type { Store } from '../store-service.ts';
+import type { StableRecordIdentifier } from "../../../types/identifier.js";
+import type { FindRecordOptions } from "../../-types/q/store.js";
+import type { Store } from "../store-service.js";
 declare const Touching: "___(unique) Symbol(Touching)";
 export declare const RequestPromise: "___(unique) Symbol(RequestPromise)";
 export interface Operation {
-    op: string;
-    options: FindRecordOptions | undefined;
-    recordIdentifier: StableRecordIdentifier;
+	op: string;
+	options: FindRecordOptions | undefined;
+	recordIdentifier: StableRecordIdentifier;
 }
 export interface FindRecordQuery extends Operation {
-    op: 'findRecord';
+	op: "findRecord";
 }
 export interface SaveRecordMutation extends Operation {
-    op: 'saveRecord';
+	op: "saveRecord";
 }
 export interface Request {
-    data: Operation[];
-    options?: Record<string, unknown>;
+	data: Operation[];
+	options?: Record<string, unknown>;
 }
-export type RequestStates = 'pending' | 'fulfilled' | 'rejected';
+export type RequestStates = "pending" | "fulfilled" | "rejected";
 export interface RequestCacheRequestState {
-    state: RequestStates;
-    type: 'query' | 'mutation';
-    request: Request;
-    response?: Response;
+	state: RequestStates;
+	type: "query" | "mutation";
+	request: Request;
+	response?: Response;
 }
 export interface Response {
-    data: unknown;
+	// rawData: unknown;
+	data: unknown;
 }
 interface InternalRequest extends RequestCacheRequestState {
-    [Touching]: StableRecordIdentifier[];
-    [RequestPromise]?: Promise<unknown>;
+	[Touching]: StableRecordIdentifier[];
+	[RequestPromise]?: Promise<unknown>;
 }
 export type RequestSubscription = (requestState: RequestCacheRequestState) => void;
 /**
- * The RequestStateService is used to track the state of requests
- * for fetching or updating known resource identifies that are inflight.
- *
- * @class RequestStateService
- * @public
- */
+* The RequestStateService is used to track the state of requests
+* for fetching or updating known resource identifies that are inflight.
+*
+* @hideconstructor
+* @public
+*/
 export declare class RequestStateService {
-    _pending: Map<StableRecordIdentifier, InternalRequest[]>;
-    _done: Map<StableRecordIdentifier, InternalRequest[]>;
-    _subscriptions: Map<StableRecordIdentifier, RequestSubscription[]>;
-    _toFlush: InternalRequest[];
-    _store: Store;
-    constructor(store: Store);
-    _clearEntries(identifier: StableRecordIdentifier): void;
-    _enqueue<T>(promise: Promise<T>, queryRequest: Request): Promise<T>;
-    _triggerSubscriptions(req: InternalRequest): void;
-    _flush(): void;
-    _flushRequest(req: InternalRequest): void;
-    _dequeue(identifier: StableRecordIdentifier, request: InternalRequest): void;
-    _addDone(request: InternalRequest): void;
-    /**
-     * Subscribe to requests for a given resource identity.
-     *
-     * The callback will receive the current state of the request.
-     *
-     * ```ts
-     * interface RequestState {
-     *   state: 'pending' | 'fulfilled' | 'rejected';
-     *   type: 'query' | 'mutation';
-     *   request: Request;
-     *   response?: { data: unknown };
-     * }
-     * ```
-     *
-     * Note: It should be considered dangerous to use this API for more than simple
-     * state derivation or debugging. The `request` and `response` properties are poorly
-     * spec'd and may change unexpectedly when shifting what Handlers are in use or how
-     * requests are issued from the Store.
-     *
-     * We expect to revisit this API in the near future as we continue to refine the
-     * RequestManager ergonomics, as a simpler but more powerful direct integration
-     * with the RequestManager for these purposes is likely to be a better long-term
-     * design.
-     *
-     * @public
-     * @param {StableRecordIdentifier} identifier
-     * @param {(state: RequestCacheRequestState) => void} callback
-     */
-    subscribeForRecord(identifier: StableRecordIdentifier, callback: RequestSubscription): void;
-    /**
-     * Retrieve all active requests for a given resource identity.
-     *
-     * @public
-     * @param {StableRecordIdentifier} identifier
-     * @return {RequestCacheRequestState[]} an array of request states for any pending requests for the given identifier
-     */
-    getPendingRequestsForRecord(identifier: StableRecordIdentifier): RequestCacheRequestState[];
-    /**
-     * Retrieve the last completed request for a given resource identity.
-     *
-     * @public
-     * @param {StableRecordIdentifier} identifier
-     * @return {RequestCacheRequestState | null} the state of the most recent request for the given identifier
-     */
-    getLastRequestForRecord(identifier: StableRecordIdentifier): RequestCacheRequestState | null;
+	/** @internal */
+	_pending: Map<StableRecordIdentifier, InternalRequest[]>;
+	private _done;
+	private _subscriptions;
+	private _toFlush;
+	private _store;
+	constructor(store: Store);
+	/** @internal */
+	_clearEntries(identifier: StableRecordIdentifier): void;
+	/** @internal */
+	_enqueue<T>(promise: Promise<T>, queryRequest: Request): Promise<T>;
+	private _triggerSubscriptions;
+	private _flush;
+	private _flushRequest;
+	private _dequeue;
+	private _addDone;
+	/**
+	* Subscribe to requests for a given resource identity.
+	*
+	* The callback will receive the current state of the request.
+	*
+	* ```ts
+	* interface RequestState {
+	*   state: 'pending' | 'fulfilled' | 'rejected';
+	*   type: 'query' | 'mutation';
+	*   request: Request;
+	*   response?: { data: unknown };
+	* }
+	* ```
+	*
+	* Note: It should be considered dangerous to use this API for more than simple
+	* state derivation or debugging. The `request` and `response` properties are poorly
+	* spec'd and may change unexpectedly when shifting what Handlers are in use or how
+	* requests are issued from the Store.
+	*
+	* We expect to revisit this API in the near future as we continue to refine the
+	* RequestManager ergonomics, as a simpler but more powerful direct integration
+	* with the RequestManager for these purposes is likely to be a better long-term
+	* design.
+	*
+	* @public
+	* @param {StableRecordIdentifier} identifier
+	* @param {(state: RequestCacheRequestState) => void} callback
+	*/
+	subscribeForRecord(identifier: StableRecordIdentifier, callback: RequestSubscription): void;
+	/**
+	* Retrieve all active requests for a given resource identity.
+	*
+	* @public
+	* @param {StableRecordIdentifier} identifier
+	* @return {RequestCacheRequestState[]} an array of request states for any pending requests for the given identifier
+	*/
+	getPendingRequestsForRecord(identifier: StableRecordIdentifier): RequestCacheRequestState[];
+	/**
+	* Retrieve the last completed request for a given resource identity.
+	*
+	* @public
+	* @param {StableRecordIdentifier} identifier
+	* @return {RequestCacheRequestState | null} the state of the most recent request for the given identifier
+	*/
+	getLastRequestForRecord(identifier: StableRecordIdentifier): RequestCacheRequestState | null;
 }
 export {};
-//# sourceMappingURL=request-cache.d.ts.map