@warp-drive/core 5.8.0-beta.0 → 5.8.0-beta.1

package/declarations/request.d.ts

@@ -1,5 +1,52 @@
+import type { ReactiveDataDocument } from "./reactive.js";
+import type { RequestInfo } from "./types/request.js";
+import type { RequestSignature } from "./types/symbols.js";
 export { createDeferred } from "./request/-private/future.js";
 export type { Future, Handler, CacheHandler, NextFn, Deferred, ManagedRequestPriority } from "./request/-private/types.js";
 export { setPromiseResult, getPromiseResult } from "./request/-private/promise-cache.js";
 export type { Awaitable } from "./request/-private/promise-cache.js";
 export type { Context } from "./request/-private/context.js";
+/**
+* Brands the supplied object with the supplied response type.
+*
+* ```ts
+* import type { ReactiveDataDocument } from '@warp-drive/core/reactive';
+* import { withResponseType } from '@warp-drive/core/request';
+* import type { User } from '#/data/user.ts'
+*
+* const result = await store.request(
+*  withResponseType<ReactiveDataDocument<User>>({ url: '/users/1' })
+* );
+*
+* result.content.data; // will have type User
+* ```
+*
+*/
+export declare function withResponseType<T>(obj: RequestInfo): RequestInfo<T> & {
+	[RequestSignature]: T;
+};
+/**
+* Brands the supplied object with the supplied response type
+* wrapped in {@link ReactiveDataDocument}. This is a convenience for
+* the common case of using {@link withResponseType} with `ReactiveDataDocument`.
+*
+* ```ts
+* import { withReactiveResponse } from '@warp-drive/core/request';
+* import type { User } from '#/data/user.ts'
+*
+* const result = await store.request(
+*   withReactiveResponse<User>({ url: '/users/1' })
+* );
+*
+* result.content.data; // will have type User
+* ```
+*
+* @public
+*/
+export declare function withReactiveResponse<T>(obj: RequestInfo): RequestInfo<ReactiveDataDocument<T>> & {
+	[RequestSignature]: ReactiveDataDocument<T>;
+};
+/**
+* @deprecated use {@link withResponseType} instead
+*/
+export declare const withBrand: typeof withResponseType;

package/declarations/signals/-leaked.d.ts

@@ -0,0 +1,2 @@
+export { defineNonEnumerableSignal, defineGate, defineSignal, entangleSignal, signal, waitFor, gate, DISPOSE, memoized, notifyInternalSignal, peekInternalSignal, withSignalStore } from "./-private.js";
+export type { AutorefreshBehaviorCombos, SubscriptionArgs, ContentFeatures, RecoveryFeatures, RequestArgs } from "./-private.js";

package/declarations/signals/-private.d.ts

@@ -0,0 +1,6 @@
+export { DISPOSE, createRequestSubscription, type RequestArgs, type SubscriptionArgs, type RequestComponentArgs, type RequestSubscription, type ContentFeatures, type RecoveryFeatures, type AutorefreshBehaviorCombos, type AutorefreshBehaviorType } from "./request-subscription.js";
+export { getRequestState, type RequestLoadingState, type RequestState } from "./request-state.js";
+export { getPromiseState, type PromiseState, type ResolvedPromise, type RejectedPromise, type PendingPromise } from "./promise-state.js";
+export { setupSignals, type HooksOptions, type SignalHooks, waitFor, willSyncFlushWatchers } from "./reactivity/configure.js";
+export { signal, memoized, gate, entangleSignal, entangleInitiallyStaleSignal, defineSignal, defineGate, defineNonEnumerableSignal, createSignalDescriptor } from "./reactivity/signal.js";
+export { type SignalStore, ARRAY_SIGNAL, OBJECT_SIGNAL, Signals, type WarpDriveSignal, peekInternalSignal, createInternalMemo, withSignalStore, notifyInternalSignal, consumeInternalSignal, getOrCreateInternalSignal, createInternalSignal } from "./reactivity/internal.js";

package/declarations/{store/-private/new-core-tmp → signals}/promise-state.d.ts

@@ -1,4 +1,4 @@
-import type { Awaitable } from "../../../request.js";
+import type { Awaitable } from "../request.js";
 /**
 * The state of a promise in the "pending"
 * state. This is the default initial state.
@@ -256,6 +256,7 @@ export declare function createPromiseState<
 *
 * If looking to use in a template, consider also the `<Await />` component.
 *
+* See also {@link PromiseState}
 */
 export declare function getPromiseState<
 	T = unknown,

package/declarations/{store/-private/new-core-tmp → signals}/request-state.d.ts

@@ -1,5 +1,5 @@
-import type { Future } from "../../../request.js";
-import type { ImmutableRequestInfo, ResponseInfo, StructuredErrorDocument } from "../../../types/request.js";
+import type { Future } from "../request.js";
+import type { ImmutableRequestInfo, ResponseInfo, StructuredErrorDocument } from "../types/request.js";
 import type { PendingPromise, RejectedPromise, ResolvedPromise } from "./promise-state.js";
 /**
 * Lazily consumes the stream of a request, providing a number of
@@ -308,14 +308,14 @@ export interface PrivateRequestState {
 * - {@link CancelledRequest}
 *
 */
-export type RequestCacheRequestState<
+export type RequestState<
 	RT = unknown,
 	E extends StructuredErrorDocument = StructuredErrorDocument
 > = PendingRequest | ResolvedRequest<RT> | RejectedRequest<RT, E> | CancelledRequest<RT, E>;
 export declare function createRequestState<
 	RT,
 	E
->(future: Future<RT>): Readonly<RequestCacheRequestState<RT, StructuredErrorDocument<E>>>;
+>(future: Future<RT>): Readonly<RequestState<RT, StructuredErrorDocument<E>>>;
 /**
 * `getRequestState` can be used in both JavaScript and Template contexts.
 *
@@ -362,11 +362,11 @@ export declare function createRequestState<
 * ```
 *
 * If looking to use in a template, consider also the `<Request />` component
-* which offers a numbe of additional capabilities for requests *beyond* what
+* which offers a number of additional capabilities for requests *beyond* what
 * `RequestState` provides.
 *
 */
 export declare function getRequestState<
 	RT,
 	E
->(future: Future<RT>): Readonly<RequestCacheRequestState<RT, StructuredErrorDocument<E>>>;
+>(future: Future<RT>): Readonly<RequestState<RT, StructuredErrorDocument<E>>>;

package/declarations/{store/-private/new-core-tmp → signals}/request-subscription.d.ts

@@ -1,7 +1,7 @@
-import type { RequestManager, Store, StoreRequestInput } from "../../../index.js";
-import type { Future } from "../../../request.js";
-import type { StructuredErrorDocument } from "../../../types/request.js";
-import type { RequestState } from "../../-private.js";
+import type { RequestManager, Store, StoreRequestInput } from "../index.js";
+import type { Future } from "../request.js";
+import type { StructuredErrorDocument } from "../types/request.js";
+import type { RequestState } from "./request-state.js";
 export declare const DISPOSE: "(symbol) dispose";
 export type AutorefreshBehaviorType = "online" | "interval" | "invalid";
 export type AutorefreshBehaviorCombos = boolean | AutorefreshBehaviorType | `${AutorefreshBehaviorType},${AutorefreshBehaviorType}` | `${AutorefreshBehaviorType},${AutorefreshBehaviorType},${AutorefreshBehaviorType}`;

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

@@ -12,7 +12,6 @@ import type { Store } from "../store-service.js";
 * Implementing this service allows you to programatically define
 * when a request should be considered expired.
 *
-* @class (Interface) CachePolicy
 * @public
 */
 export interface CachePolicy {
@@ -27,9 +26,7 @@ export interface CachePolicy {
 	* and the cache will be updated before returning the response.
 	*
 	* @public
-	* @param {RequestKey} 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: RequestKey, store: Store): boolean;
 	/**
@@ -42,9 +39,7 @@ export interface CachePolicy {
 	* request is made to update the cache via the configured request handlers.
 	*
 	* @public
-	* @param {RequestKey} 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: RequestKey, store: Store): boolean;
 	/**
@@ -54,10 +49,6 @@ export interface CachePolicy {
 	* Note, this is invoked regardless of whether the request has a cache-key.
 	*
 	* @public
-	* @param {ImmutableRequestInfo} request
-	* @param {RequestKey | null} identifier
-	* @param {Store} store
-	* @return {void}
 	*/
 	willRequest?(request: ImmutableRequestInfo, identifier: RequestKey | null, store: Store): void;
 	/**
@@ -88,11 +79,6 @@ export interface CachePolicy {
 	*
 	*
 	* @public
-	* @param {ImmutableRequestInfo} request
-	* @param {ImmutableResponse} response
-	* @param {RequestKey | null} identifier
-	* @param {Store} store
-	* @return {void}
 	*/
 	didRequest?(request: ImmutableRequestInfo, response: Response | ResponseInfo | null, identifier: RequestKey | null, store: Store): void;
 }

package/declarations/store/-private/caches/instance-cache.d.ts

@@ -1,4 +1,4 @@
-import { ReactiveDocument } from "../../../reactive/-private/document.js";
+import { type ReactiveDocument } from "../../../reactive/-private/document.js";
 import type { Cache } from "../../../types/cache.js";
 import type { RequestKey, ResourceKey } from "../../../types/identifier.js";
 import type { TypedRecordInstance, TypeFromInstance } from "../../../types/record.js";
@@ -6,13 +6,13 @@ 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): ResourceKey | undefined;
+export declare function peekResourceKey(record: OpaqueRecordInstance): ResourceKey | undefined;
 /**
-Retrieves the unique referentially-stable [RecordIdentifier](/ember-data/release/classes/ResourceKey)
+Retrieves the unique referentially-stable {@link ResourceKey}
 assigned to the given record instance.
 
 ```js
-import { recordIdentifierFor } from "@ember-data/store";
+import { recordIdentifierFor } from "@warp-drive/core";
 // ... 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 ResourceKey)
@@ -22,8 +22,7 @@ const { id, type, lid } = identifier;
 ```
 
 @public
-@param {Object} record a record instance previously obstained from the store.
-@return {ResourceKey}
+@param record a record instance previously obstained from the store.
 */
 export declare function recordIdentifierFor<T extends TypedRecordInstance>(record: T): ResourceKey<TypeFromInstance<T>>;
 export declare function recordIdentifierFor(record: OpaqueRecordInstance): ResourceKey;

package/declarations/store/-private/default-cache-policy.d.ts

@@ -2,6 +2,7 @@ import type { Cache } from "@warp-drive/core/types/cache";
 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";
+import type { CachePolicy } from "../-private.js";
 type UnsubscribeToken = object;
 type CacheOperation = "added" | "removed" | "updated" | "state";
 type DocumentCacheOperation = "invalidated" | "added" | "removed" | "updated" | "state";
@@ -28,6 +29,11 @@ type Store = {
 	cache: Cache;
 	notifications: NotificationManager;
 };
+/**
+* Interface of a parsed Cache-Control header value.
+*
+* - [MDN Cache-Control Reference](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Cache-Control)
+*/
 export interface CacheControlValue {
 	immutable?: boolean;
 	"max-age"?: number;
@@ -66,24 +72,83 @@ export interface CacheControlValue {
 * }
 * ```
 *
+* See also {@link CacheControlValue} and [Response Directives](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Cache-Control#response_directives)
+*
 * @public
-* @param {String} header
-* @return {CacheControlValue}
 */
 export declare function parseCacheControl(header: string): CacheControlValue;
 /**
+* The constraint options for {@link PolicyConfig.constraints}
+*/
+export interface PolicyConfigConstraints {
+	/**
+	* Headers that should be checked for expiration.
+	*
+	*/
+	headers?: {
+		/**
+		* Whether the `Cache-Control` header should be checked for expiration.
+		* If `true`, then the `max-age` and `s-maxage` directives are used alongside
+		* the `Age` and `Date` headers to determine if the expiration time has passed.
+		*
+		* Other directives are ignored.
+		*
+		* 'Cache-Control' will take precedence over 'Expires' if both are present
+		* and both configured to be checked.
+		*
+		*/
+		"Cache-Control"?: boolean;
+		/**
+		* Whether the `Expires` header should be checked for expiration.
+		*
+		* If `true`, then the `Expires` header is used to caclulate the expiration time
+		* and determine if the expiration time has passed.
+		*
+		* 'Cache-Control' will take precedence over 'Expires' if both are present.
+		*
+		*/
+		Expires?: boolean;
+		/**
+		* Whether the `X-WarpDrive-Expires` header should be checked for expiration.
+		*
+		* If `true`, then the `X-WarpDrive-Expires` header is used to caclulate the expiration time
+		* and determine if the expiration time has passed.
+		*
+		* This header will take precedence over 'Cache-Control' and 'Expires' if all three are present.
+		*
+		* The header's value should be a [UTC date string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toUTCString).
+		*
+		*/
+		"X-WarpDrive-Expires"?: boolean;
+	};
+	/**
+	* A function that should be called to determine if the request is expired.
+	*
+	* If present, this function will be called with the request and should return
+	* `true` if the request is expired, `false` if it is not expired, and
+	* `null` if the expiration status is unknown.
+	*
+	* If the function does not return `null`,
+	*
+	*/
+	isExpired?: (request: StructuredDocument<ResourceDocument>) => boolean | null;
+}
+/**
 * The configuration options for the {@link DefaultCachePolicy}
 *
-* ```ts
-* import { DefaultCachePolicy } from '@warp-drive/core/store';
+* ```ts [app/services/store.ts]
+* import { Store } from '@warp-drive/core';
+* import { DefaultCachePolicy } from '@warp-drive/core/store'; // [!code focus]
 *
-* new DefaultCachePolicy({
-*   // ... PolicyConfig Settings ... //
-* });
+* export default class AppStore extends Store {
+*   lifetimes = new DefaultCachePolicy({ // [!code focus:3]
+*     // ... PolicyConfig Settings ... //
+*   });
+* }
 * ```
 *
 */
-export type PolicyConfig = {
+export interface PolicyConfig {
 	/**
 	* the number of milliseconds after which a request is considered
 	* stale. If a request is issued again after this time, the request
@@ -92,10 +157,9 @@ export type PolicyConfig = {
 	*
 	* This is calculated against the `date` header of the response.
 	*
-	* If your API does not provide a `date` header, the `Fetch` handler
-	* provided by `@warp-drive/core` will automatically add
-	* it to responses if it is not present. Responses without a `date`
-	* header will be considered stale immediately.
+	* If your API does not provide a `date` header, the {@link Fetch} handler
+	* will automatically add it to responses if it is not present. Responses
+	* without a `date` header will be considered stale immediately.
 	*
 	*/
 	apiCacheSoftExpires: number;
@@ -107,10 +171,9 @@ export type PolicyConfig = {
 	*
 	* This is calculated against the `date` header of the response.
 	*
-	* If your API does not provide a `date` header, the `Fetch` handler
-	* provided by `@warp-drive/core` will automatically add
-	* it to responses if it is not present. Responses without a `date`
-	* header will be considered hard expired immediately.
+	* If your API does not provide a `date` header, the {@link Fetch} handler
+	* will automatically add it to responses if it is not present. Responses
+	* without a `date` header will be considered hard expired immediately.
 	*
 	*/
 	apiCacheHardExpires: number;
@@ -120,8 +183,8 @@ export type PolicyConfig = {
 	*
 	* This helps reduce flakiness and produce predictably rendered results in test suites.
 	*
-	* Requests that specifically set `cacheOptions.backgroundReload = true` will
-	* still be background reloaded in tests.
+	* Requests that specifically set {@link RequestInfo.cacheOptions.backgroundReload | cacheOptions.backgroundReload }
+	* will still be background reloaded in tests.
 	*
 	* This behavior can be opted out of by setting this value to `true`.
 	*
@@ -130,7 +193,7 @@ export type PolicyConfig = {
 	/**
 	* In addition to the simple time-based expiration strategy, CachePolicy
 	* supports various common server-supplied expiration strategies via
-	* headers, as well as custom expiration strategies via the `isExpired`
+	* headers, as well as custom expiration strategies via the {@link PolicyConfigConstraints.isExpired | isExpired}
 	* function.
 	*
 	* Requests will be validated for expiration against these constraints.
@@ -157,118 +220,82 @@ export type PolicyConfig = {
 	* -  ↳ (if null) Cache-Control header
 	* -  ↳ (if null) Expires header
 	*
+	* See {@link PolicyConfigConstraints} for configuration options.
 	*/
-	constraints?: {
-		/**
-		* Headers that should be checked for expiration.
-		*
-		*/
-		headers?: {
-			/**
-			* Whether the `Cache-Control` header should be checked for expiration.
-			* If `true`, then the `max-age` and `s-maxage` directives are used alongside
-			* the `Age` and `Date` headers to determine if the expiration time has passed.
-			*
-			* Other directives are ignored.
-			*
-			* 'Cache-Control' will take precedence over 'Expires' if both are present
-			* and both configured to be checked.
-			*
-			*/
-			"Cache-Control"?: boolean;
-			/**
-			* Whether the `Expires` header should be checked for expiration.
-			*
-			* If `true`, then the `Expires` header is used to caclulate the expiration time
-			* and determine if the expiration time has passed.
-			*
-			* 'Cache-Control' will take precedence over 'Expires' if both are present.
-			*
-			*/
-			Expires?: boolean;
-			/**
-			* Whether the `X-WarpDrive-Expires` header should be checked for expiration.
-			*
-			* If `true`, then the `X-WarpDrive-Expires` header is used to caclulate the expiration time
-			* and determine if the expiration time has passed.
-			*
-			* This header will take precedence over 'Cache-Control' and 'Expires' if all three are present.
-			*
-			* The header's value should be a [UTC date string](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toUTCString).
-			*
-			*/
-			"X-WarpDrive-Expires"?: boolean;
-		};
-		/**
-		* A function that should be called to determine if the request is expired.
-		*
-		* If present, this function will be called with the request and should return
-		* `true` if the request is expired, `false` if it is not expired, and
-		* `null` if the expiration status is unknown.
-		*
-		* If the function does not return `null`,
-		*
-		*/
-		isExpired?: (request: StructuredDocument<ResourceDocument>) => boolean | null;
-	};
-};
+	constraints?: PolicyConfigConstraints;
+}
 /**
-* A basic CachePolicy that can be added to the Store service.
-*
-* Determines staleness based on time since the request was last received from the API
-* using the `date` header.
+* A basic {@link CachePolicy} that can be added to the Store service.
 *
-* Determines expiration based on configured constraints as well as a time based
-* expiration strategy based on the `date` header.
-*
-* In order expiration is determined by:
+* ```ts [app/services/store.ts]
+* import { Store } from '@warp-drive/core';
+* import { DefaultCachePolicy } from '@warp-drive/core/store'; // [!code focus]
 *
-* - Is explicitly invalidated
-* -  ↳ (if null) isExpired function \<IF Constraint Active>
-* -  ↳ (if null) X-WarpDrive-Expires header \<IF Constraint Active>
-* -  ↳ (if null) Cache-Control header \<IF Constraint Active>
-* -  ↳ (if null) Expires header \<IF Constraint Active>
-* -  ↳ (if null) Date header + apiCacheHardExpires \< current time
+* export default class AppStore extends Store {
+*   lifetimes = new DefaultCachePolicy({ // [!code focus:5]
+*     apiCacheSoftExpires: 30_000,
+*     apiCacheHardExpires: 60_000,
+*     // ... Other PolicyConfig Settings ... //
+*   });
+* }
+* ```
 *
-* Invalidates any request for which `cacheOptions.types` was provided when a createRecord
-* request for that type is successful.
+* :::tip 💡 TIP
+* Date headers do not have millisecond precision, so expiration times should
+* generally be larger than 1000ms.
+* :::
 *
-* 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 ResourceKeys
-* of the records that are being created via `records`. Providing both is valid.
+* See also {@link PolicyConfig} for configuration options.
 *
-* > [!NOTE]
-* > only requests that had specified `cacheOptions.types` and occurred prior to the
-* > createRecord request will be invalidated. This means that a given request should always
-* > specify the types that would invalidate it to opt into this behavior. Abstracting this
-* > behavior via builders is recommended to ensure consistency.
+* ### The Mechanics
 *
-* This allows the Store's CacheHandler to determine if a request is expired and
-* should be refetched upon next request.
+* This policy determines staleness based on various configurable constraints falling back to a simple
+* check of the time elapsed since the request was last received from the API using the `date` header
+* from the last response.
 *
-* The `Fetch` handler provided by `@warp-drive/core` will automatically
+* :::tip 💡 TIP
+* The {@link Fetch} handler provided by `@warp-drive/core` will automatically
 * add the `date` header to responses if it is not present.
+* :::
 *
-* > [!NOTE]
-* > Date headers do not have millisecond precision, so expiration times should
-* > generally be larger than 1000ms.
+* - For manual override of reload see {@link CacheOptions.reload | cacheOptions.reload}
+* - For manual override of background reload see {@link CacheOptions.backgroundReload | cacheOptions.backgroundReload}
 *
-* Usage:
+* In order expiration is determined by:
 *
-* ```ts
-* import { Store } from '@warp-drive/core';
-* import { DefaultCachePolicy } from '@warp-drive/core/store';
+* ```md
+* Is explicitly invalidated by `cacheOptions.reload`
+*   ↳ (if falsey) if the request has been explicitly invalidated
+*      since the last request (see Automatic Invalidation below)
+*   ↳ (if false) (If Active) isExpired function
+*   ↳ (if null) (If Active) X-WarpDrive-Expires header
+*   ↳ (if null) (If Active) Cache-Control header
+*   ↳ (if null) (If Active) Expires header
+*   ↳ (if null) Date header + apiCacheHardExpires < current time
 *
-* export class AppStore extends Store {
-*   lifetimes = new DefaultCachePolicy({
-*     apiCacheSoftExpires: 30_000,
-*     apiCacheHardExpires: 60_000
-*   });
-* }
+*   -- <if above is false, a background request is issued if> --
+*
+*   ↳ is invalidated by `cacheOptions.backgroundReload`
+*   ↳ (if falsey) Date header + apiCacheSoftExpires < current time
 * ```
 *
-* In Testing environments, the `apiCacheSoftExpires` will always be `false`
-* and `apiCacheHardExpires` will use the `apiCacheSoftExpires` value.
+* ### Automatic Invalidation / Entanglement
+*
+* It also invalidates any request with an {@link RequestInfo.op | OpCode} of `"query"`
+* for which {@link CacheOptions.types | cacheOptions.types} was provided
+* when a request with an `OpCode` of `"createRecord"` is successful and also includes
+* a matching type in its own `cacheOptions.types` array.
+
+* :::tip 💡 TIP
+* Abstracting this behavior via builders is recommended to ensure consistency.
+* :::
+*
+* ### Testing
+*
+* In Testing environments:
+*
+* - `apiCacheSoftExpires` will always be `false`
+* - `apiCacheHardExpires` will use the `apiCacheSoftExpires` value.
 *
 * This helps reduce flakiness and produce predictably rendered results in test suites.
 *
@@ -280,16 +307,7 @@ export type PolicyConfig = {
 *
 * @public
 */
-export declare class DefaultCachePolicy {
-	config: PolicyConfig;
-	_stores: WeakMap<Store, {
-		invalidated: Set<RequestKey>;
-		types: Map<string, Set<RequestKey>>;
-	}>;
-	_getStore(store: Store): {
-		invalidated: Set<RequestKey>;
-		types: Map<string, Set<RequestKey>>;
-	};
+export declare class DefaultCachePolicy implements CachePolicy {
 	constructor(config: PolicyConfig);
 	/**
 	* Invalidate a request by its CacheKey for the given store instance.
@@ -314,7 +332,7 @@ export declare class DefaultCachePolicy {
 	* of the store.
 	*
 	* This invalidation is done automatically when using this service
-	* for both the CacheHandler and the LegacyNetworkHandler.
+	* for both the {@link CacheHandler} and the [NetworkHandler](/api/@warp-drive/legacy/compat/variables/LegacyNetworkHandler).
 	*
 	* ```ts
 	* store.lifetimes.invalidateRequestsForType(store, 'person');
@@ -328,7 +346,7 @@ export declare class DefaultCachePolicy {
 	* This is invoked by the CacheHandler for both foreground and background requests
 	* once the cache has been updated.
 	*
-	* Note, this is invoked by the CacheHandler regardless of whether
+	* Note, this is invoked by the {@link CacheHandler} regardless of whether
 	* the request has a cache-key.
 	*
 	* This method should not be invoked directly by consumers.
@@ -340,7 +358,7 @@ export declare class DefaultCachePolicy {
 	* Invoked to determine if the request may be fulfilled from cache
 	* if possible.
 	*
-	* Note, this is only invoked by the CacheHandler if the request has
+	* Note, this is only invoked by the {@link CacheHandler} if the request has
 	* a cache-key.
 	*
 	* If no cache entry is found or the entry is hard expired,
@@ -355,7 +373,7 @@ export declare class DefaultCachePolicy {
 	* Invoked if `isHardExpired` is false to determine if the request
 	* should be update behind the scenes if cache data is already available.
 	*
-	* Note, this is only invoked by the CacheHandler if the request has
+	* Note, this is only invoked by the {@link CacheHandler} if the request has
 	* a cache-key.
 	*
 	* If true, the request will be fulfilled from cache while a backgrounded

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

@@ -1,6 +1,6 @@
 import type { RequestKey, ResourceKey } from "../../../types/identifier.js";
+import type { SchemaService } from "../../../types/schema/schema-service.js";
 import type { CacheCapabilitiesManager as StoreWrapper } from "../../-types/q/cache-capabilities-manager.js";
-import type { SchemaService } from "../../-types/q/schema-service.js";
 import type { PrivateStore, Store } from "../store-service.js";
 import type { CacheKeyManager } from "./cache-key-manager.js";
 import type { NotificationType } from "./notification-manager.js";