@ember-data/store 5.4.0-alpha.32 → 5.4.0-alpha.33

package/unstable-preview-types/-private/managers/notification-manager.d.ts

@@ -1,96 +1,98 @@
-import type { StableDocumentIdentifier, StableRecordIdentifier } from '@warp-drive/core-types/identifier';
-import type Store from '../store-service';
-export type UnsubscribeToken = object;
-export type CacheOperation = 'added' | 'removed' | 'updated' | 'state';
-export type NotificationType = 'attributes' | 'relationships' | 'identity' | 'errors' | 'meta' | '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 {
-    (identifier: StableRecordIdentifier, notificationType: CacheOperation): void;
-}
-export interface DocumentOperationCallback {
-    (identifier: StableDocumentIdentifier, notificationType: CacheOperation): void;
-}
-/**
- * The NotificationManager provides the ability to subscribe to
- * changes to Cache state.
- *
- * This Feature is what allows EmberData to create subscriptions that
- * work with any framework or change-notification system.
- *
- * @class NotificationManager
- * @public
- */
-export default class NotificationManager {
-    store: Store;
-    isDestroyed: boolean;
-    _buffered: Map<StableDocumentIdentifier | StableRecordIdentifier, [string, string | undefined][]>;
-    _cache: Map<StableDocumentIdentifier | StableRecordIdentifier | 'resource' | 'document', Map<UnsubscribeToken, NotificationCallback | ResourceOperationCallback | DocumentOperationCallback>>;
-    _tokens: Map<UnsubscribeToken, StableDocumentIdentifier | StableRecordIdentifier | 'resource' | 'document'>;
-    _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;
-     * }
-     * ```
-     *
-     * @method subscribe
-     * @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: StableDocumentIdentifier, callback: DocumentOperationCallback): UnsubscribeToken;
-    subscribe(identifier: 'document', callback: DocumentOperationCallback): UnsubscribeToken;
-    /**
-     * remove a previous subscription
-     *
-     * @method unsubscribe
-     * @public
-     * @param {UnsubscribeToken} token
-     */
-    unsubscribe(token: UnsubscribeToken): void;
-    /**
-     * Custom Caches and Application Code should not call this method directly.
-     *
-     * @method notify
-     * @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 | StableDocumentIdentifier, value: CacheOperation): boolean;
-    _onNextFlush(cb: () => void): void;
-    _scheduleNotify(): void;
-    _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;
-}
-//# sourceMappingURL=notification-manager.d.ts.map
+declare module '@ember-data/store/-private/managers/notification-manager' {
+  import type { StableDocumentIdentifier, StableRecordIdentifier } from '@warp-drive/core-types/identifier';
+  import type Store from '@ember-data/store/-private/store-service';
+  export type UnsubscribeToken = object;
+  export type CacheOperation = 'added' | 'removed' | 'updated' | 'state';
+  export type NotificationType = 'attributes' | 'relationships' | 'identity' | 'errors' | 'meta' | '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 {
+      (identifier: StableRecordIdentifier, notificationType: CacheOperation): void;
+  }
+  export interface DocumentOperationCallback {
+      (identifier: StableDocumentIdentifier, notificationType: CacheOperation): void;
+  }
+  /**
+   * The NotificationManager provides the ability to subscribe to
+   * changes to Cache state.
+   *
+   * This Feature is what allows EmberData to create subscriptions that
+   * work with any framework or change-notification system.
+   *
+   * @class NotificationManager
+   * @public
+   */
+  export default class NotificationManager {
+      store: Store;
+      isDestroyed: boolean;
+      _buffered: Map<StableDocumentIdentifier | StableRecordIdentifier, [string, string | undefined][]>;
+      _cache: Map<StableDocumentIdentifier | StableRecordIdentifier | 'resource' | 'document', Map<UnsubscribeToken, NotificationCallback | ResourceOperationCallback | DocumentOperationCallback>>;
+      _tokens: Map<UnsubscribeToken, StableDocumentIdentifier | StableRecordIdentifier | 'resource' | 'document'>;
+      _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;
+       * }
+       * ```
+       *
+       * @method subscribe
+       * @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: StableDocumentIdentifier, callback: DocumentOperationCallback): UnsubscribeToken;
+      subscribe(identifier: 'document', callback: DocumentOperationCallback): UnsubscribeToken;
+      /**
+       * remove a previous subscription
+       *
+       * @method unsubscribe
+       * @public
+       * @param {UnsubscribeToken} token
+       */
+      unsubscribe(token: UnsubscribeToken): void;
+      /**
+       * Custom Caches and Application Code should not call this method directly.
+       *
+       * @method notify
+       * @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 | StableDocumentIdentifier, value: CacheOperation): boolean;
+      _onNextFlush(cb: () => void): void;
+      _scheduleNotify(): void;
+      _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;
+  }
+  //# sourceMappingURL=notification-manager.d.ts.map
+}

package/unstable-preview-types/-private/managers/record-array-manager.d.ts

@@ -1,95 +1,97 @@
-import type { StableRecordIdentifier } from '@warp-drive/core-types/identifier';
-import type { ImmutableRequestInfo } from '@warp-drive/core-types/request';
-import type { CollectionResourceDocument } from '@warp-drive/core-types/spec/raw';
-import IdentifierArray, { Collection } from '../record-arrays/identifier-array';
-import type Store from '../store-service';
-import type { UnsubscribeToken } from './notification-manager';
-/**
- * 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 EmberData 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'>;
-/**
-  @class RecordArrayManager
-  @internal
-*/
-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;
-    _keyedArrays: Map<string, Collection>;
-    _visibilitySet: Map<StableRecordIdentifier, boolean>;
-    constructor(options: {
-        store: Store;
-    });
-    _syncArray(array: IdentifierArray): void;
-    /**
-      Get the `RecordArray` for a modelName, which contains all loaded records of
-      given modelName.
-  
-      @method liveArrayFor
-      @internal
-      @param {String} modelName
-      @return {RecordArray}
-    */
-    liveArrayFor(type: string): IdentifierArray;
-    createArray(config: {
-        type?: string;
-        query?: ImmutableRequestInfo | Record<string, unknown>;
-        identifiers?: StableRecordIdentifier[];
-        doc?: CollectionResourceDocument;
-    }): Collection;
-    dirtyArray(array: IdentifierArray, delta: number): void;
-    _getPendingFor(identifier: StableRecordIdentifier, includeManaged: boolean, isRemove?: boolean): Map<IdentifierArray, ChangeSet> | void;
-    populateManagedArray(array: Collection, identifiers: StableRecordIdentifier[], payload: CollectionResourceDocument): 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 default RecordArrayManager;
-//# sourceMappingURL=record-array-manager.d.ts.map
+declare module '@ember-data/store/-private/managers/record-array-manager' {
+  import type { StableRecordIdentifier } from '@warp-drive/core-types/identifier';
+  import type { ImmutableRequestInfo } from '@warp-drive/core-types/request';
+  import type { CollectionResourceDocument } from '@warp-drive/core-types/spec/raw';
+  import IdentifierArray, { Collection } from '@ember-data/store/-private/record-arrays/identifier-array';
+  import type Store from '@ember-data/store/-private/store-service';
+  import type { UnsubscribeToken } from '@ember-data/store/-private/managers/notification-manager';
+  /**
+   * 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 EmberData 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'>;
+  /**
+    @class RecordArrayManager
+    @internal
+  */
+  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;
+      _keyedArrays: Map<string, Collection>;
+      _visibilitySet: Map<StableRecordIdentifier, boolean>;
+      constructor(options: {
+          store: Store;
+      });
+      _syncArray(array: IdentifierArray): void;
+      /**
+        Get the `RecordArray` for a modelName, which contains all loaded records of
+        given modelName.
+    
+        @method liveArrayFor
+        @internal
+        @param {String} modelName
+        @return {RecordArray}
+      */
+      liveArrayFor(type: string): IdentifierArray;
+      createArray(config: {
+          type?: string;
+          query?: ImmutableRequestInfo | Record<string, unknown>;
+          identifiers?: StableRecordIdentifier[];
+          doc?: CollectionResourceDocument;
+      }): Collection;
+      dirtyArray(array: IdentifierArray, delta: number): void;
+      _getPendingFor(identifier: StableRecordIdentifier, includeManaged: boolean, isRemove?: boolean): Map<IdentifierArray, ChangeSet> | void;
+      populateManagedArray(array: Collection, identifiers: StableRecordIdentifier[], payload: CollectionResourceDocument): 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 default RecordArrayManager;
+  //# sourceMappingURL=record-array-manager.d.ts.map
+}

package/unstable-preview-types/-private/network/request-cache.d.ts

@@ -1,107 +1,109 @@
-import type { StableRecordIdentifier } from '@warp-drive/core-types/identifier';
-import type { FindRecordOptions } from '../../-types/q/store';
-import type Store from '../store-service';
-declare const Touching: unique symbol;
-export declare const RequestPromise: unique symbol;
-export interface Operation {
-    op: string;
-    options: FindRecordOptions | undefined;
-    recordIdentifier: StableRecordIdentifier;
-}
-export interface FindRecordQuery extends Operation {
-    op: 'findRecord';
-}
-export interface SaveRecordMutation extends Operation {
-    op: 'saveRecord';
-}
-export interface Request {
-    data: Operation[];
-    options?: Record<string, unknown>;
-}
-export type RequestStates = 'pending' | 'fulfilled' | 'rejected';
-export interface RequestState {
-    state: RequestStates;
-    type: 'query' | 'mutation';
-    request: Request;
-    response?: Response;
-}
-export interface Response {
-    data: unknown;
-}
-interface InternalRequest extends RequestState {
-    [Touching]: StableRecordIdentifier[];
-    [RequestPromise]?: Promise<unknown>;
-}
-export type RequestSubscription = (requestState: RequestState) => void;
-/**
- * The RequestStateService is used to track the state of requests
- * for fetching or updating known resource identifies that are inflight.
- *
- * @class RequestStateService
- * @public
- */
-export default 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.
-     *
-     * @method subscribeForRecord
-     * @public
-     * @param {StableRecordIdentifier} identifier
-     * @param {(state: RequestState) => void} callback
-     */
-    subscribeForRecord(identifier: StableRecordIdentifier, callback: RequestSubscription): void;
-    /**
-     * Retrieve all active requests for a given resource identity.
-     *
-     * @method getPendingRequestsForRecord
-     * @public
-     * @param {StableRecordIdentifier} identifier
-     * @return {RequestState[]} an array of request states for any pending requests for the given identifier
-     */
-    getPendingRequestsForRecord(identifier: StableRecordIdentifier): RequestState[];
-    /**
-     * Retrieve the last completed request for a given resource identity.
-     *
-     * @method getLastRequestForRecord
-     * @public
-     * @param {StableRecordIdentifier} identifier
-     * @return {RequestState | null} the state of the most recent request for the given identifier
-     */
-    getLastRequestForRecord(identifier: StableRecordIdentifier): RequestState | null;
-}
-export {};
-//# sourceMappingURL=request-cache.d.ts.map
+declare module '@ember-data/store/-private/network/request-cache' {
+  import type { StableRecordIdentifier } from '@warp-drive/core-types/identifier';
+  import type { FindRecordOptions } from '@ember-data/store/-types/q/store';
+  import type Store from '@ember-data/store/-private/store-service';
+  declare const Touching: unique symbol;
+  export declare const RequestPromise: unique symbol;
+  export interface Operation {
+      op: string;
+      options: FindRecordOptions | undefined;
+      recordIdentifier: StableRecordIdentifier;
+  }
+  export interface FindRecordQuery extends Operation {
+      op: 'findRecord';
+  }
+  export interface SaveRecordMutation extends Operation {
+      op: 'saveRecord';
+  }
+  export interface Request {
+      data: Operation[];
+      options?: Record<string, unknown>;
+  }
+  export type RequestStates = 'pending' | 'fulfilled' | 'rejected';
+  export interface RequestState {
+      state: RequestStates;
+      type: 'query' | 'mutation';
+      request: Request;
+      response?: Response;
+  }
+  export interface Response {
+      data: unknown;
+  }
+  interface InternalRequest extends RequestState {
+      [Touching]: StableRecordIdentifier[];
+      [RequestPromise]?: Promise<unknown>;
+  }
+  export type RequestSubscription = (requestState: RequestState) => void;
+  /**
+   * The RequestStateService is used to track the state of requests
+   * for fetching or updating known resource identifies that are inflight.
+   *
+   * @class RequestStateService
+   * @public
+   */
+  export default 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.
+       *
+       * @method subscribeForRecord
+       * @public
+       * @param {StableRecordIdentifier} identifier
+       * @param {(state: RequestState) => void} callback
+       */
+      subscribeForRecord(identifier: StableRecordIdentifier, callback: RequestSubscription): void;
+      /**
+       * Retrieve all active requests for a given resource identity.
+       *
+       * @method getPendingRequestsForRecord
+       * @public
+       * @param {StableRecordIdentifier} identifier
+       * @return {RequestState[]} an array of request states for any pending requests for the given identifier
+       */
+      getPendingRequestsForRecord(identifier: StableRecordIdentifier): RequestState[];
+      /**
+       * Retrieve the last completed request for a given resource identity.
+       *
+       * @method getLastRequestForRecord
+       * @public
+       * @param {StableRecordIdentifier} identifier
+       * @return {RequestState | null} the state of the most recent request for the given identifier
+       */
+      getLastRequestForRecord(identifier: StableRecordIdentifier): RequestState | null;
+  }
+  export {};
+  //# sourceMappingURL=request-cache.d.ts.map
+}