@warp-drive/core 5.7.0-alpha.26 → 5.7.0-alpha.28

package/declarations/graph/-private/-diff.d.ts

@@ -12,19 +12,6 @@ type Diff<T> = {
 };
 export declare function diffCollection(finalState: ResourceKey[], relationship: CollectionEdge, onAdd: (v: ResourceKey) => void, onDel: (v: ResourceKey) => void): Diff<ResourceKey>;
 export declare function computeLocalState(storage: CollectionEdge): ResourceKey[];
-/**
-* A function which attempts to add a value to the local state of a collection
-* relationship, and returns true if the value was added, or false if it was
-* already present.
-*
-* It will not generate a notification, will not update the relationships to dirty,
-* and will not update the inverse relationships, making it suitable for use as
-* an internal util to perform the just the addition to a specific side of a
-* relationship.
-*
-* @internal
-*/
-export declare function _add(graph: Graph, record: ResourceKey, relationship: CollectionEdge, value: ResourceKey, index: number | null, isRemote: boolean): boolean;
 export declare function _remove(graph: Graph, record: ResourceKey, relationship: CollectionEdge, value: ResourceKey, index: number | null, isRemote: boolean): boolean;
 export declare function _removeLocal(relationship: CollectionEdge, value: ResourceKey): boolean;
 export declare function _removeRemote(relationship: CollectionEdge, value: ResourceKey): boolean;

package/declarations/graph/-private/-edge-definition.d.ts

@@ -70,22 +70,17 @@ export declare function temporaryConvertToLegacy(field: ResourceField | Collecti
 * }
 * ```
 *
-*
-* @class UpgradedMeta
-* @internal
+* @private
 */
 export interface UpgradedMeta {
 	kind: "implicit" | RelationshipFieldKind;
 	/**
 	* The field name on `this` record
-	*
-	* @internal
 	*/
 	key: string;
 	/**
 	* The `type` of the related record
 	*
-	* @internal
 	*/
 	type: string;
 	isAsync: boolean;
@@ -97,12 +92,10 @@ export interface UpgradedMeta {
 	inverseKind: "implicit" | RelationshipFieldKind;
 	/**
 	* The field name on the opposing record
-	* @internal
 	*/
 	inverseKey: string;
 	/**
 	* The `type` of `this` record
-	* @internal
 	*/
 	inverseType: string;
 	inverseIsAsync: boolean;
@@ -131,7 +124,6 @@ export interface EdgeDefinition {
 	* If the relationship is polymorphic, this will be true if
 	* it points back at the same abstract type.
 	*
-	* @internal
 	*/
 	isSelfReferential: boolean;
 	/**
@@ -139,7 +131,6 @@ export interface EdgeDefinition {
 	* if the relationship also points back at the same
 	* field.
 	*
-	* @internal
 	*/
 	isReflexive: boolean;
 }

package/declarations/graph/-private/edges/resource.d.ts

@@ -6,8 +6,7 @@ import type { RelationshipState } from "../-state.js";
 /**
 * Stores the data for one side of a "single" resource relationship.
 *
-* @class ResourceEdge
-* @internal
+* @private
 */
 export interface ResourceEdge {
 	definition: UpgradedMeta;

package/declarations/reactive/-private/record.d.ts

@@ -1,20 +1,6 @@
-import type { Store } from "../../store/-private.js";
-import { RecordStore } from "../../types/symbols.js";
 import type { ObjectContext, ResourceContext } from "./default-mode.js";
-import { Checkout, Commit, Context, Destroy } from "./symbols.js";
+import { Checkout } from "./symbols.js";
 export interface ReactiveResource {
-	/** @internal */
-	[Symbol.toStringTag]: `ReactiveResource<${string}>`;
-	/** @internal */
-	[Context]: ObjectContext | ResourceContext;
-	/** @internal */
-	[RecordStore]: Store;
-	/** @internal */
-	___notifications: object;
-	/** @internal */
-	[Destroy](): void;
-	/** @internal */
-	[Commit](): Promise<void>;
 	/**
 	* Create an editable copy of the record
 	*
@@ -30,7 +16,7 @@ export interface ReactiveResource {
 	*
 	* @returns a promise that resolves to the editable record
 	* @throws if the record is already editable or if the record is embedded
-	* @internal
+	* @private
 	*/
 	[Checkout]<T>(): Promise<T>;
 }

package/declarations/reactive/-private/schema.d.ts

@@ -1,9 +1,8 @@
-import type { Store } from "../../store/-private.js";
 import type { SchemaService as SchemaServiceInterface } from "../../types.js";
 import type { ResourceKey } from "../../types/identifier.js";
 import type { ObjectValue, Value } from "../../types/json/raw.js";
 import type { Derivation, HashFn } from "../../types/schema/concepts.js";
-import { type ArrayField, type CacheableFieldSchema, type DerivedField, type FieldSchema, type GenericField, type HashField, type IdentityField, type LegacyAttributeField, type LegacyBelongsToField, type LegacyHasManyField, type LegacyRelationshipField, type ObjectField, type ObjectSchema, type PolarisResourceSchema, type ResourceSchema, type Trait } from "../../types/schema/fields.js";
+import { type ArrayField, type CacheableFieldSchema, type DerivedField, type FieldSchema, type GenericField, type HashField, type IdentityField, type LegacyAttributeField, type LegacyRelationshipField, type ObjectField, type ObjectSchema, type PolarisResourceSchema, type ResourceSchema, type Trait } from "../../types/schema/fields.js";
 import { Type } from "../../types/symbols.js";
 import type { WithPartial } from "../../types/utils.js";
 import type { ReactiveResource } from "./record.js";
@@ -133,7 +132,6 @@ export declare const fromIdentity: FromIdentityDerivation;
 * ```
 *
 * @public
-* @param {SchemaService} schema
 */
 export declare function registerDerivations(schema: SchemaServiceInterface): void;
 interface InternalSchema {
@@ -154,17 +152,6 @@ export type Transformation<
 	defaultValue?(options: Record<string, unknown> | null, identifier: ResourceKey): T;
 	[Type]: string;
 };
-interface KindFns {
-	belongsTo: {
-		get: (store: Store, record: object, resourceKey: ResourceKey, field: LegacyBelongsToField) => unknown;
-		set: (store: Store, record: object, cacheKey: ResourceKey, field: LegacyBelongsToField, value: unknown) => void;
-	};
-	hasMany: {
-		get: (store: Store, record: object, resourceKey: ResourceKey, field: LegacyHasManyField) => unknown;
-		set: (store: Store, record: object, cacheKey: ResourceKey, field: LegacyHasManyField, value: unknown) => void;
-		notify: (store: Store, record: object, cacheKey: ResourceKey, field: LegacyHasManyField) => boolean;
-	};
-}
 export interface SchemaService {
 	doesTypeExist(type: string): boolean;
 	attributesDefinitionFor(identifier: {
@@ -174,41 +161,12 @@ export interface SchemaService {
 		type: string;
 	}): InternalSchema["relationships"];
 }
-interface InternalTrait {
-	name: string;
-	mode: "legacy" | "polaris";
-	fields: Map<string, FieldSchema>;
-	traits: string[];
-}
 /**
 * A SchemaService designed to work with dynamically registered schemas.
 *
-* @class SchemaService
 * @public
 */
 export declare class SchemaService implements SchemaServiceInterface {
-	/** @internal */
-	_schemas: Map<string, InternalSchema>;
-	/** @internal */
-	_transforms: Map<string, Transformation>;
-	/** @internal */
-	_hashFns: Map<string, HashFn>;
-	/** @internal */
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	_derivations: Map<string, Derivation<any, any, any>>;
-	/** @internal */
-	_traits: Map<string, InternalTrait>;
-	/** @internal */
-	_modes: Map<string, KindFns>;
-	/** @internal */
-	_extensions: {
-		object: Map<string, ProcessedExtension>;
-		array: Map<string, ProcessedExtension>;
-	};
-	_cachedFieldExtensionsByField: {
-		object: Map<object, ProcessedExtension["features"] | null>;
-		array: Map<object, ProcessedExtension["features"] | null>;
-	};
 	constructor();
 	resourceTypes(): Readonly<string[]>;
 	hasTrait(type: string): boolean;
@@ -278,30 +236,6 @@ export declare class SchemaService implements SchemaServiceInterface {
 		name: string;
 	}): boolean;
 	/**
-	* This is an internal method used to register behaviors for legacy mode.
-	* It is not intended for public use.
-	*
-	* We do think a generalized `kind` registration system would be useful,
-	* but we have not yet designed it.
-	*
-	* See https://github.com/emberjs/data/issues/9534
-	*
-	* @internal
-	*/
-	_registerMode(mode: string, kinds: KindFns): void;
-	/**
-	* This is an internal method used to enable legacy behaviors for legacy mode.
-	* It is not intended for public use.
-	*
-	* We do think a generalized `kind` registration system would be useful,
-	* but we have not yet designed it.
-	*
-	* See https://github.com/emberjs/data/issues/9534
-	*
-	* @internal
-	*/
-	_kind<T extends keyof KindFns>(mode: string, kind: T): KindFns[T];
-	/**
 	* Registers a {@link HashFn} for use with a {@link HashField} for
 	* either {@link ObjectSchema} identity or polymorphic type calculation.
 	*

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

@@ -26,7 +26,7 @@ export declare class ContextOwner {
 	setResponse(response: ResponseInfo | Response | null): void;
 }
 export declare class Context {
-	#private;
+	private ___owner;
 	request: ImmutableRequestInfo;
 	id: number;
 	private _isCacheHandler;

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

@@ -90,27 +90,9 @@ import { IS_CACHE_HANDLER } from "./utils.js";
 * type StructuredDocument<T> = StructuredDataDocument<T> | StructuredErrorDocument;
 * ```
 *
-* @hideconstructor
 * @public
 */
 export declare class RequestManager {
-	#private;
-	/** @internal */
-	_hasCacheHandler: boolean;
-	/**
-	* A map of pending requests from request.id to their
-	* associated CacheHandler promise.
-	*
-	* This queue is managed by the CacheHandler
-	*
-	* @internal
-	*/
-	_pending: Map<number, Promise<unknown>>;
-	/** @internal */
-	_deduped: Map<RequestKey, {
-		priority: ManagedRequestPriority;
-		promise: Promise<unknown>;
-	}>;
 	constructor(options?: GenericCreateArgs);
 	/**
 	* Register a handler to use for primary cache intercept.
@@ -153,3 +135,24 @@ export declare class RequestManager {
 	*/
 	static create(options?: GenericCreateArgs): RequestManager;
 }
+/**
+* This type exists for internal use only for
+* where intimate contracts still exist either for
+* the Test Suite or for Legacy code.
+*
+* @private
+*/
+export interface PrivateRequestManager extends RequestManager {
+	/**
+	* A map of pending requests from request.id to their
+	* associated CacheHandler promise.
+	*
+	* This queue is managed by the CacheHandler
+	*
+	*/
+	_pending: Map<number, Promise<unknown>>;
+	_deduped: Map<RequestKey, {
+		priority: ManagedRequestPriority;
+		promise: Promise<unknown>;
+	}>;
+}

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

@@ -1,7 +1,7 @@
 /* eslint-disable no-irregular-whitespace */
 import type { Store } from "../../store/-private.js";
 import type { RequestKey } from "../../types/identifier.js";
-import type { IS_FUTURE, RequestContext, RequestInfo, ResponseInfo, StructuredDataDocument } from "../../types/request.js";
+import type { RequestContext, RequestInfo, ResponseInfo, StructuredDataDocument } from "../../types/request.js";
 import type { RequestManager } from "./manager.js";
 export interface GodContext {
 	controller: AbortController;
@@ -35,8 +35,6 @@ export type DeferredStream = {
 * @public
 */
 export interface Future<T> extends Promise<StructuredDataDocument<T>> {
-	/** @internal */
-	[IS_FUTURE]: true;
 	/**
 	* Cancel this request by firing the {@link AbortController}'s signal.
 	*

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

@@ -32,7 +32,7 @@ export declare function removeRecordIdentifier(record: OpaqueRecordInstance): vo
 export declare const StoreMap: Map<unknown, Store>;
 /**
 * We may eventually make this public, but its likely better for this to be killed off
-* @internal
+* @private
 */
 export declare function storeFor(record: OpaqueRecordInstance, ignoreMissing: boolean): Store | null;
 export type Caches = {

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

@@ -1,22 +1,18 @@
 import type { RequestKey, ResourceKey } from "../../../types/identifier.js";
 import type { CacheCapabilitiesManager as StoreWrapper } from "../../-types/q/cache-capabilities-manager.js";
 import type { SchemaService } from "../../-types/q/schema-service.js";
-import type { Store } from "../store-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";
 export interface CacheCapabilitiesManager {
+	/** @deprecated - use {@link CacheCapabilitiesManager.schema} */
 	getSchemaDefinitionService(): SchemaService;
 }
 export declare class CacheCapabilitiesManager implements StoreWrapper {
-	_willNotify: boolean;
-	_pendingNotifies: Map<ResourceKey, Set<string>>;
-	_store: Store;
 	constructor(_store: Store);
 	get cacheKeyManager(): CacheKeyManager;
 	/** @deprecated use {@link CacheCapabilitiesManager.cacheKeyManager} */
 	get identifierCache(): CacheKeyManager;
-	_scheduleNotification(identifier: ResourceKey, key: string): void;
-	_flushNotifications(): void;
 	notifyChange(identifier: ResourceKey, namespace: "added" | "removed", key: null): void;
 	notifyChange(identifier: RequestKey, namespace: "added" | "updated" | "removed", key: null): void;
 	notifyChange(identifier: ResourceKey, namespace: NotificationType, key: string | null): void;
@@ -25,3 +21,14 @@ export declare class CacheCapabilitiesManager implements StoreWrapper {
 	hasRecord(identifier: ResourceKey): boolean;
 	disconnectRecord(identifier: ResourceKey): void;
 }
+/**
+* This type exists for internal use only for
+* where intimate contracts still exist either for
+* the Test Suite or for Legacy code.
+*
+* @private
+*/
+export interface PrivateCacheCapabilitiesManager extends CacheCapabilitiesManager {
+	_store: PrivateStore;
+}
+export declare function assertPrivateCapabilities(manager: unknown): asserts manager is PrivateCacheCapabilitiesManager;

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

@@ -191,38 +191,8 @@ export declare function setKeyInfoForResource(method: KeyInfoMethod | null): voi
 * @public
 */
 export declare class CacheKeyManager {
-	/** @internal */
-	_cache: StableCache;
-	private _generate;
-	private _update;
-	private _forget;
-	private _reset;
-	private _merge;
-	private _keyInfoForResource;
-	private _id;
 	constructor();
 	/**
-	* Internal hook to allow management of merge conflicts with identifiers.
-	*
-	* we allow late binding of this private internal merge so that
-	* the cache can insert itself here to handle elimination of duplicates
-	*
-	* @private
-	*/
-	__configureMerge(method: MergeMethod | null): void;
-	/** @internal */
-	upgradeIdentifier(resource: {
-		type: string;
-		id: string | null;
-		lid?: string;
-	}): ResourceKey;
-	/**
-	* @private
-	*/
-	private _getRecordIdentifier;
-	private _getRecordIdentifier;
-	private _getRecordIdentifier;
-	/**
 	* allows us to peek without generating when needed
 	* useful for the "create" case when we need to see if
 	* we are accidentally overwritting something
@@ -286,10 +256,6 @@ export declare class CacheKeyManager {
 	// FIXME audit usage
 	updateRecordIdentifier(identifierObject: ResourceKey, data: unknown): ResourceKey;
 	/**
-	* @private
-	*/
-	_mergeRecordIdentifiers(keyInfo: KeyInfo, identifier: ResourceKey, existingIdentifier: ResourceKey, data: unknown): ResourceKey;
-	/**
 	Provides the opportunity to eliminate an identifier from secondary lookup tables
 	as well as eliminates it from ember-data's own lookup tables and book keeping.
 	
@@ -301,7 +267,24 @@ export declare class CacheKeyManager {
 	*/
 	// FIXME audit usage
 	forgetRecordIdentifier(identifierObject: ResourceKey): void;
-	/** @internal */
+}
+/**
+* This type exists for internal use only for
+* where intimate contracts still exist either for
+* the Test Suite or for Legacy code.
+*
+* @private
+*/
+export interface PrivateCacheKeyManager extends CacheKeyManager {
+	_cache: StableCache;
+	/**
+	* Internal hook to allow management of merge conflicts with identifiers.
+	*
+	* we allow late binding of this private internal merge so that
+	* the cache can insert itself here to handle elimination of duplicates
+	*/
+	__configureMerge(method: MergeMethod | null): void;
+	_mergeRecordIdentifiers(keyInfo: KeyInfo, identifier: ResourceKey, existingIdentifier: ResourceKey, data: unknown): ResourceKey;
 	destroy(): void;
 }
 export {};

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

@@ -28,8 +28,8 @@ import type { StoreRequestContext } from "../cache-handler/handler.js";
 * @public
 */
 export declare class CacheManager implements Cache {
-	#private;
 	version: "2";
+	private ___cache;
 	constructor(cache: Cache);
 	// Cache Management
 	// ================

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

@@ -28,18 +28,6 @@ export interface DocumentOperationCallback {
 * @public
 */
 export default class NotificationManager {
-	/** @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 ResourceKey, RequestKey, or addition/removal of any resource
@@ -84,11 +72,15 @@ export default class NotificationManager {
 	notify(cacheKey: ResourceKey, value: "errors" | "meta" | "identity" | "state", key?: null): boolean;
 	notify(cacheKey: ResourceKey, value: CacheOperation, key?: null): boolean;
 	notify(cacheKey: RequestKey, value: DocumentCacheOperation, key?: null): boolean;
-	/** @internal */
-	_onNextFlush(cb: () => void): void;
 	private _scheduleNotify;
-	/** @internal */
+}
+/**
+* This type exists for internal use only for
+* where intimate contracts still exist either for
+* the Test Suite or for Legacy code.
+*
+* @private
+*/
+export interface PrivateNotificationManager extends NotificationManager {
 	_flush(): void;
-	/** @internal */
-	destroy(): void;
 }

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

@@ -6,7 +6,6 @@ import type { LegacyLiveArray } from "../record-arrays/legacy-live-array.js";
 import { type LegacyQueryArray } from "../record-arrays/legacy-query.js";
 import { type ReactiveResourceArray } from "../record-arrays/resource-array.js";
 import type { Store } from "../store-service.js";
-import type { UnsubscribeToken } from "./notification-manager.js";
 /**
 * This is a clever optimization.
 *
@@ -40,7 +39,7 @@ import type { UnsubscribeToken } from "./notification-manager.js";
 * Sincerely,
 *   - runspired (Chris Thoburn) 08/21/2022
 *
-* @internal
+* @private
 * @param target the array to push into
 * @param source the items to push into target
 */
@@ -58,91 +57,45 @@ interface RequestCollectionInit {
 }
 type ChangeSet = Map<ResourceKey, "add" | "del">;
 /**
-@class RecordArrayManager
-@internal
+@hideconstructor
+@private
 */
 export declare class RecordArrayManager {
-	store: Store;
-	isDestroying: boolean;
-	isDestroyed: boolean;
-	/**
-	*
-	*/
-	_set: Map<ReactiveResourceArray, Set<ResourceKey>>;
-	/**
-	* LiveArray (peekAll/findAll) array instances
-	* keyed by their ResourceType.
-	*/
-	_live: Map<string, LegacyLiveArray>;
-	/**
-	*
-	*/
-	_managed: Set<ReactiveResourceArray>;
-	/**
-	* Buffered changes to apply keyed by the array to
-	* which to apply them to.
-	*/
-	_pending: Map<ReactiveResourceArray, ChangeSet>;
-	/**
-	* An inverse map from ResourceKey to the list
-	* of arrays it can be found in, useful for fast updates
-	* when state changes to a resource occur.
-	*/
-	_identifiers: Map<ResourceKey, Set<ReactiveResourceArray>>;
-	/**
-	* When we do not yet have a LiveArray, this keeps track of
-	* the added/removed identifiers to enable us to more efficiently
-	* produce the LiveArray later.
-	*
-	* It's possible that using a Set and only storing additions instead of
-	* additions and deletes would be more efficient.
-	*/
-	_staged: Map<string, ChangeSet>;
-	_subscription: UnsubscribeToken;
-	_documentSubscription: UnsubscribeToken;
-	/**
-	* KeyedArrays are arrays associated to a specific RequestKey.
-	*/
-	_keyedArrays: Map<string, ReactiveResourceArray>;
-	/**
-	* The visibility set tracks whether a given identifier should
-	* be shown in RecordArrays. It is used to dedupe added/removed
-	* and state change events.
-	*
-	* As a Map, it grows to be very large - there may be ways to
-	* reduce its size by instead migrating to it functioning as
-	* an exclusion list. Any entry not in the list would be considered
-	* visible.
-	*/
-	_visibilitySet: Map<ResourceKey, boolean>;
 	constructor(options: {
 		store: Store;
 	});
-	private _subscribeToResourceChanges;
-	_syncArray(array: ReactiveResourceArray): 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}
+	@private
 	*/
 	liveArrayFor(type: string): LegacyLiveArray;
 	getCollection(config: LegacyQueryInit): LegacyQueryArray;
 	getCollection(config: AnonymousRequestCollectionInit): ReactiveResourceArray;
 	getCollection(config: RequestCollectionInit): ReactiveResourceArray;
-	dirtyArray(array: ReactiveResourceArray, delta: number, shouldSyncFromCache: boolean): void;
-	_getPendingFor(identifier: ResourceKey, includeManaged: boolean, isRemove?: boolean): Map<ReactiveResourceArray, ChangeSet> | void;
+	private dirtyArray;
+	/**
+	* @private
+	*/
 	populateManagedArray(array: ReactiveResourceArray, identifiers: ResourceKey[], payload: CollectionResourceDocument | null): void;
-	identifierAdded(identifier: ResourceKey): void;
-	identifierRemoved(identifier: ResourceKey): void;
-	identifierChanged(identifier: ResourceKey): void;
 	pause(): void;
 	resume(): void;
-	clear(isClear?: boolean): void;
 	destroy(): void;
 }
+/**
+* This type exists for internal use only for
+* where intimate contracts still exist either for
+* the Test Suite or for Legacy code.
+*
+* @private
+*/
+export interface PrivateRecordArrayManager extends RecordArrayManager {
+	_live: Map<string, LegacyLiveArray>;
+	_pending: Map<ReactiveResourceArray, ChangeSet>;
+	_managed: Set<ReactiveResourceArray>;
+	clear(isClear?: boolean): void;
+}
 export declare function disassociateIdentifier(ArraysCache: Map<ResourceKey, Set<ReactiveResourceArray>>, array: ReactiveResourceArray, identifier: ResourceKey): void;
 export {};

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

@@ -42,19 +42,7 @@ export type RequestSubscription = (requestState: RequestCacheRequestState) => vo
 * @public
 */
 export declare class RequestStateService {
-	/** @internal */
-	_pending: Map<ResourceKey, InternalRequest[]>;
-	private _done;
-	private _subscriptions;
-	private _toFlush;
-	private _store;
 	constructor(store: Store);
-	/** @internal */
-	_clearEntries(identifier: ResourceKey): void;
-	/** @internal */
-	_enqueue<T>(promise: Promise<T>, queryRequest: Request): Promise<T>;
-	private _triggerSubscriptions;
-	private _flush;
 	private _flushRequest;
 	private _dequeue;
 	private _addDone;
@@ -104,4 +92,16 @@ export declare class RequestStateService {
 	*/
 	getLastRequestForRecord(identifier: ResourceKey): RequestCacheRequestState | null;
 }
+/**
+* This type exists for internal use only for
+* where intimate contracts still exist either for
+* the Test Suite or for Legacy code.
+*
+* @private
+*/
+export interface PrivateRequestStateService extends RequestStateService {
+	_pending: Map<ResourceKey, InternalRequest[]>;
+	_clearEntries(identifier: ResourceKey): void;
+	_enqueue<T>(promise: Promise<T>, queryRequest: Request): Promise<T>;
+}
 export {};