@warp-drive/core 5.6.0-beta.1 → 5.6.0-beta.3

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

@@ -1,9 +1,9 @@
 import type { Cache, ChangedAttributesHash, RelationshipDiff } from "../../../types/cache.js";
 import type { Change } from "../../../types/cache/change.js";
-import type { MergeOperation } from "../../../types/cache/operations.js";
+import type { Operation } from "../../../types/cache/operations.js";
 import type { CollectionRelationship, ResourceRelationship } from "../../../types/cache/relationship.js";
 import type { LocalRelationshipOperation } from "../../../types/graph.js";
-import type { StableDocumentIdentifier, StableRecordIdentifier } from "../../../types/identifier.js";
+import type { RequestKey, ResourceKey } from "../../../types/identifier.js";
 import type { Value } from "../../../types/json/raw.js";
 import type { StructuredDataDocument, StructuredDocument } from "../../../types/request.js";
 import type { ResourceDocument, SingleResourceDataDocument } from "../../../types/spec/document.js";
@@ -28,11 +28,8 @@ import type { StoreRequestContext } from "../cache-handler/handler.js";
 * @public
 */
 export declare class CacheManager implements Cache {
-	#private;
 	version: "2";
 	constructor(cache: Cache);
-	// Cache Management
-	// ================
 	/**
 	* Cache the response to a request
 	*
@@ -61,14 +58,11 @@ export declare class CacheManager implements Cache {
 	/**
 	* Perform an operation on the cache to update the remote state.
 	*
-	* Note: currently the only valid operation is a MergeOperation
-	* which occurs when a collision of identifiers is detected.
-	*
 	* @public
 	* @param op the operation to perform
 	* @return {void}
 	*/
-	patch(op: MergeOperation): void;
+	patch(op: Operation | Operation[]): void;
 	/**
 	* Update resource data with a local mutation. Currently supports operations
 	* on relationships only.
@@ -105,34 +99,29 @@ export declare class CacheManager implements Cache {
 	* notifications for relational data.
 	*
 	* @public
-	* @param {StableRecordIdentifier | StableDocumentIdentifier} identifier
+	* @param {ResourceKey | RequestKey} cacheKey
 	* @return {ResourceDocument | ResourceBlob | null} the known resource data
 	*/
-	peek(identifier: StableRecordIdentifier): unknown;
-	peek(identifier: StableDocumentIdentifier): ResourceDocument | null;
-	peekRemoteState(identifier: StableRecordIdentifier): unknown;
-	peekRemoteState(identifier: StableDocumentIdentifier): ResourceDocument | null;
+	peek(cacheKey: ResourceKey): unknown;
+	peek(cacheKey: RequestKey): ResourceDocument | null;
+	peekRemoteState(cacheKey: ResourceKey): unknown;
+	peekRemoteState(cacheKey: RequestKey): ResourceDocument | null;
 	/**
 	* Peek the Cache for the existing request data associated with
 	* a cacheable request
 	*
-	* @param {StableDocumentIdentifier}
-	* @return {StableDocumentIdentifier | null}
+	* @param {RequestKey}
+	* @return {RequestKey | null}
 	* @public
 	*/
-	peekRequest(identifier: StableDocumentIdentifier): StructuredDocument<ResourceDocument> | null;
+	peekRequest(key: RequestKey): StructuredDocument<ResourceDocument> | null;
 	/**
-	* Push resource data from a remote source into the cache for this identifier
+	* Push resource data from a remote source into the cache for this ResourceKey
 	*
 	* @public
-	* @param identifier
-	* @param data
-	* @param hasRecord
-	* @return {void | string[]} if `hasRecord` is true then calculated key changes should be returned
+	* @return if `hasRecord` is true then calculated key changes should be returned
 	*/
-	upsert(identifier: StableRecordIdentifier, data: unknown, hasRecord: boolean): void | string[];
-	// Cache Forking Support
-	// =====================
+	upsert(key: ResourceKey, data: unknown, hasRecord: boolean): void | string[];
 	/**
 	* Create a fork of the cache from the current state.
 	*
@@ -165,7 +154,7 @@ export declare class CacheManager implements Cache {
 	* `Change` entry in the returned array.
 	*
 	* A `Change` is described by an object containing up to
-	* three properties: (1) the `identifier` of the entity that
+	* three properties: (1) the `ResourceKey` of the entity that
 	* changed; (2) the `op` code of that change being one of
 	* `upsert` or `remove`, and if the op is `upsert` a `patch`
 	* containing the data to merge into the cache for the given
@@ -180,7 +169,7 @@ export declare class CacheManager implements Cache {
 	*
 	* ```ts
 	* interface Change {
-	*  identifier: StableRecordIdentifier | StableDocumentIdentifier;
+	*  key: ResourceKey | RequestKey;
 	*  op: 'upsert' | 'remove';
 	*  patch?: unknown;
 	* }
@@ -189,8 +178,6 @@ export declare class CacheManager implements Cache {
 	* @public
 	*/
 	diff(): Promise<Change[]>;
-	// SSR Support
-	// ===========
 	/**
 	* Serialize the entire contents of the Cache into a Stream
 	* which may be fed back into a new instance of the same Cache
@@ -217,10 +204,6 @@ export declare class CacheManager implements Cache {
 	* @public
 	*/
 	hydrate(stream: ReadableStream<unknown>): Promise<void>;
-	// Cache
-	// =====
-	// Resource Support
-	// ================
 	/**
 	* [LIFECYCLE] Signal to the cache that a new record has been instantiated on the client
 	*
@@ -228,99 +211,74 @@ export declare class CacheManager implements Cache {
 	* process. This return value behavior is deprecated.
 	*
 	* @public
-	* @param identifier
-	* @param options
 	*/
-	clientDidCreate(identifier: StableRecordIdentifier, options?: Record<string, unknown>): Record<string, unknown>;
+	clientDidCreate(key: ResourceKey, options?: Record<string, unknown>): Record<string, unknown>;
 	/**
 	* [LIFECYCLE] Signals to the cache that a resource
 	* will be part of a save transaction.
 	*
 	* @public
-	* @param identifier
+	* @param key
 	*/
-	willCommit(identifier: StableRecordIdentifier, context: StoreRequestContext): void;
+	willCommit(key: ResourceKey, context: StoreRequestContext): void;
 	/**
 	* [LIFECYCLE] Signals to the cache that a resource
 	* was successfully updated as part of a save transaction.
 	*
 	* @public
-	* @param identifier
-	* @param data
 	*/
-	didCommit(identifier: StableRecordIdentifier, result: StructuredDataDocument<unknown>): SingleResourceDataDocument;
+	didCommit(key: ResourceKey, result: StructuredDataDocument<unknown>): SingleResourceDataDocument;
 	/**
 	* [LIFECYCLE] Signals to the cache that a resource
 	* was update via a save transaction failed.
 	*
 	* @public
-	* @param identifier
-	* @param errors
 	*/
-	commitWasRejected(identifier: StableRecordIdentifier, errors?: ApiError[]): void;
+	commitWasRejected(key: ResourceKey, errors?: ApiError[]): void;
 	/**
 	* [LIFECYCLE] Signals to the cache that all data for a resource
 	* should be cleared.
 	*
 	* @public
-	* @param identifier
 	*/
-	unloadRecord(identifier: StableRecordIdentifier): void;
-	// Granular Resource Data APIs
-	// ===========================
+	unloadRecord(key: ResourceKey): void;
 	/**
 	* Retrieve the data for an attribute from the cache
 	*
 	* @public
-	* @param identifier
-	* @param propertyName
-	* @return {unknown}
 	*/
-	getAttr(identifier: StableRecordIdentifier, propertyName: string): Value | undefined;
+	getAttr(key: ResourceKey, propertyName: string): Value | undefined;
 	/**
 	* Retrieve the remote state for an attribute from the cache
 	*
 	* @public
-	* @param identifier
-	* @param propertyName
-	* @return {unknown}
 	*/
-	getRemoteAttr(identifier: StableRecordIdentifier, propertyName: string): Value | undefined;
+	getRemoteAttr(key: ResourceKey, propertyName: string): Value | undefined;
 	/**
 	* Mutate the data for an attribute in the cache
 	*
 	* @public
-	* @param identifier
-	* @param propertyName
-	* @param value
 	*/
-	setAttr(identifier: StableRecordIdentifier, propertyName: string, value: Value): void;
+	setAttr(key: ResourceKey, propertyName: string, value: Value): void;
 	/**
 	* Query the cache for the changed attributes of a resource.
 	*
 	* @public
-	* @param identifier
-	* @return
 	*/
-	changedAttrs(identifier: StableRecordIdentifier): ChangedAttributesHash;
+	changedAttrs(key: ResourceKey): ChangedAttributesHash;
 	/**
 	* Query the cache for whether any mutated attributes exist
 	*
 	* @public
-	* @param identifier
-	* @return {Boolean}
 	*/
-	hasChangedAttrs(identifier: StableRecordIdentifier): boolean;
+	hasChangedAttrs(key: ResourceKey): boolean;
 	/**
 	* Tell the cache to discard any uncommitted mutations to attributes
 	*
 	* @public
-	* @param identifier
 	* @return the names of attributes that were restored
 	*/
-	rollbackAttrs(identifier: StableRecordIdentifier): string[];
-	// Relationships
-	// =============
+	rollbackAttrs(key: ResourceKey): string[];
 	/**
 	* Query the cache for the changes to relationships of a resource.
 	*
@@ -330,32 +288,28 @@ export declare class CacheManager implements Cache {
 	* type RelationshipDiff =
 	| {
 	kind: 'collection';
-	remoteState: StableRecordIdentifier[];
-	additions: Set<StableRecordIdentifier>;
-	removals: Set<StableRecordIdentifier>;
-	localState: StableRecordIdentifier[];
+	remoteState: ResourceKey[];
+	additions: Set<ResourceKey>;
+	removals: Set<ResourceKey>;
+	localState: ResourceKey[];
 	reordered: boolean;
 	}
 	| {
 	kind: 'resource';
-	remoteState: StableRecordIdentifier | null;
-	localState: StableRecordIdentifier | null;
+	remoteState: ResourceKey | null;
+	localState: ResourceKey | null;
 	};
 	```
 	*
 	* @public
-	* @param {StableRecordIdentifier} identifier
-	* @return {Map<string, RelationshipDiff>}
 	*/
-	changedRelationships(identifier: StableRecordIdentifier): Map<string, RelationshipDiff>;
+	changedRelationships(key: ResourceKey): Map<string, RelationshipDiff>;
 	/**
 	* Query the cache for whether any mutated attributes exist
 	*
 	* @public
-	* @param {StableRecordIdentifier} identifier
-	* @return {Boolean}
 	*/
-	hasChangedRelationships(identifier: StableRecordIdentifier): boolean;
+	hasChangedRelationships(key: ResourceKey): boolean;
 	/**
 	* Tell the cache to discard any uncommitted mutations to relationships.
 	*
@@ -364,80 +318,61 @@ export declare class CacheManager implements Cache {
 	* This method is a candidate to become a mutation
 	*
 	* @public
-	* @param {StableRecordIdentifier} identifier
-	* @return {String[]} the names of relationships that were restored
+	* @return the names of relationships that were restored
 	*/
-	rollbackRelationships(identifier: StableRecordIdentifier): string[];
+	rollbackRelationships(key: ResourceKey): string[];
 	/**
 	* Query the cache for the current state of a relationship property
 	*
 	* @public
-	* @param identifier
-	* @param propertyName
 	* @return resource relationship object
 	*/
-	getRelationship(identifier: StableRecordIdentifier, propertyName: string): ResourceRelationship | CollectionRelationship;
+	getRelationship(key: ResourceKey, propertyName: string): ResourceRelationship | CollectionRelationship;
 	/**
 	* Query the cache for the remote state of a relationship property
 	*
 	* @public
-	* @param identifier
-	* @param propertyName
 	* @return resource relationship object
 	*/
-	getRemoteRelationship(identifier: StableRecordIdentifier, propertyName: string): ResourceRelationship | CollectionRelationship;
-	// Resource State
-	// ===============
+	getRemoteRelationship(key: ResourceKey, propertyName: string): ResourceRelationship | CollectionRelationship;
 	/**
 	* Update the cache state for the given resource to be marked as locally deleted,
 	* or remove such a mark.
 	*
 	* @public
-	* @param identifier
-	* @param isDeleted
 	*/
-	setIsDeleted(identifier: StableRecordIdentifier, isDeleted: boolean): void;
+	setIsDeleted(key: ResourceKey, isDeleted: boolean): void;
 	/**
 	* Query the cache for any validation errors applicable to the given resource.
 	*
 	* @public
-	* @param identifier
-	* @return
 	*/
-	getErrors(identifier: StableRecordIdentifier): ApiError[];
+	getErrors(key: ResourceKey): ApiError[];
 	/**
 	* Query the cache for whether a given resource has any available data
 	*
 	* @public
-	* @param identifier
-	* @return {Boolean}
 	*/
-	isEmpty(identifier: StableRecordIdentifier): boolean;
+	isEmpty(key: ResourceKey): boolean;
 	/**
 	* Query the cache for whether a given resource was created locally and not
 	* yet persisted.
 	*
 	* @public
-	* @param identifier
-	* @return {Boolean}
 	*/
-	isNew(identifier: StableRecordIdentifier): boolean;
+	isNew(key: ResourceKey): boolean;
 	/**
 	* Query the cache for whether a given resource is marked as deleted (but not
 	* necessarily persisted yet).
 	*
 	* @public
-	* @param identifier
-	* @return {Boolean}
 	*/
-	isDeleted(identifier: StableRecordIdentifier): boolean;
+	isDeleted(key: ResourceKey): boolean;
 	/**
 	* Query the cache for whether a given resource has been deleted and that deletion
 	* has also been persisted.
 	*
 	* @public
-	* @param identifier
-	* @return {Boolean}
 	*/
-	isDeletionCommitted(identifier: StableRecordIdentifier): boolean;
+	isDeletionCommitted(key: ResourceKey): boolean;
 }

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

@@ -1,21 +1,19 @@
-import type { StableDocumentIdentifier, StableRecordIdentifier } from "../../../types/identifier.js";
+import type { RequestKey, ResourceKey } 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 interface NotificationCallback {
-	(identifier: StableRecordIdentifier, notificationType: "attributes" | "relationships", key?: string): void;
-	(identifier: StableRecordIdentifier, notificationType: "errors" | "meta" | "identity" | "state"): void;
-	(identifier: StableRecordIdentifier, notificationType: CacheOperation): void;
+	(cacheKey: ResourceKey, notificationType: "attributes" | "relationships", key?: string): void;
+	(cacheKey: ResourceKey, notificationType: "errors" | "meta" | "identity" | "state"): void;
+	(cacheKey: ResourceKey, notificationType: CacheOperation): void;
 }
 export interface ResourceOperationCallback {
-	// resource updates
-	(identifier: StableRecordIdentifier, notificationType: CacheOperation): void;
+	(cacheKey: ResourceKey, notificationType: CacheOperation): void;
 }
 export interface DocumentOperationCallback {
-	// document updates
-	(identifier: StableDocumentIdentifier, notificationType: DocumentCacheOperation): void;
+	(cacheKey: RequestKey, notificationType: DocumentCacheOperation): void;
 }
 /**
 * The NotificationManager provides the ability to subscribe to
@@ -28,48 +26,35 @@ 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 resource identifier, resource addition/removal, or document addition/removal.
+	* Subscribe to changes for a given ResourceKey, RequestKey, or addition/removal of any resource
+	* or document.
 	*
 	* ```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;
+	*   (cacheKey: ResourceKey, notificationType: 'attributes' | 'relationships', key?: string): void;
+	*   (cacheKey: ResourceKey, notificationType: 'errors' | 'meta' | 'identity' | 'state'): void;
+	*   (cacheKey: ResourceKey, notificationType: NotificationType, key?: string): void;
 	* }
 	* export interface ResourceOperationCallback {
 	*   // resource updates
-	*   (identifier: StableRecordIdentifier, notificationType: CacheOperation): void;
+	*   (cacheKey: ResourceKey, notificationType: CacheOperation): void;
 	* }
 	* export interface DocumentOperationCallback {
 	*   // document updates
-	*   (identifier: StableDocumentIdentifier, notificationType: CacheOperation): void;
+	*   (cacheKey: RequestKey, 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
+	* @return 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;
+	subscribe(cacheKey: ResourceKey, callback: NotificationCallback): UnsubscribeToken;
+	subscribe(cacheKey: "resource", callback: ResourceOperationCallback): UnsubscribeToken;
+	subscribe(cacheKey: "document" | RequestKey, callback: DocumentOperationCallback): UnsubscribeToken;
 	/**
 	* remove a previous subscription
 	*
@@ -81,18 +66,18 @@ export default class NotificationManager {
 	*
 	* @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 */
+	notify(cacheKey: ResourceKey, value: "attributes" | "relationships", key?: string | null): boolean;
+	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;
+}
+/**
+* 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;
-	private _flushNotification;
-	private _flushNotification;
-	private _flushNotification;
-	/** @internal */
-	destroy(): void;
 }

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

@@ -1,10 +1,11 @@
 import type { LocalRelationshipOperation } from "../../../types/graph.js";
-import type { StableDocumentIdentifier, StableRecordIdentifier } from "../../../types/identifier.js";
+import type { RequestKey, ResourceKey } 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 { 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.
 *
@@ -38,60 +39,62 @@ import type { UnsubscribeToken } from "./notification-manager.js";
 * Sincerely,
 *   - runspired (Chris Thoburn) 08/21/2022
 *
-* @function fastPush
-* @internal
+* @private
 * @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">;
+interface LegacyQueryInit {
+	type: string;
+	query: ImmutableRequestInfo | Record<string, unknown>;
+}
+interface AnonymousRequestCollectionInit {
+	source: ResourceKey[];
+}
+interface RequestCollectionInit {
+	source: ResourceKey[];
+	requestKey: RequestKey;
+}
+type ChangeSet = Map<ResourceKey, "add" | "del">;
 /**
-@class RecordArrayManager
-@internal
+@hideconstructor
+@private
 */
 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}
+	@private
 	*/
-	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;
+	liveArrayFor(type: string): LegacyLiveArray;
+	getCollection(config: LegacyQueryInit): LegacyQueryArray;
+	getCollection(config: AnonymousRequestCollectionInit): ReactiveResourceArray;
+	getCollection(config: RequestCollectionInit): ReactiveResourceArray;
+	/**
+	* @private
+	*/
+	populateManagedArray(array: ReactiveResourceArray, identifiers: ResourceKey[], payload: CollectionResourceDocument | null): void;
+	pause(): void;
+	resume(): void;
 	destroy(): void;
 }
-export declare function disassociateIdentifier(ArraysCache: Map<StableRecordIdentifier, Set<Collection>>, array: Collection, identifier: StableRecordIdentifier): 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 {};