@warp-drive/legacy 5.6.0-beta.0 → 5.6.0-beta.2

package/declarations/adapter/-private/utils/continue-on-reject.d.ts

@@ -1,7 +1 @@
-/**
-* A utility function that returns a promise that resolves
-* even when the source promise rejects.
-*
-* @internal
-*/
-export declare function continueOnReject<T>(promise: Promise<T>): Promise<T>;
+export {};

package/declarations/adapter/error.d.ts

@@ -1,8 +1,8 @@
-import type { JsonApiError } from "@warp-drive/core/store/-types/q/record-data-json-api";
+import type { ApiError } from "@warp-drive/core/types/spec/error";
 export interface AdapterRequestError<T extends string = string> extends Error {
 	isAdapterError: true;
 	code: T;
-	errors: JsonApiError[];
+	errors: ApiError[];
 }
 export interface AdapterRequestErrorConstructor<Instance extends AdapterRequestError = AdapterRequestError> {
 	new (errors?: unknown[], message?: string): Instance;

package/declarations/compat/builders/find-all.d.ts

@@ -13,7 +13,7 @@ type FindAllRequestInput<
 	};
 	[RequestSignature]?: RT;
 };
-type FindAllBuilderOptions<T = unknown> = FindAllOptions<T>;
+type FindAllBuilderOptions = FindAllOptions;
 /**
 This function builds a request config to perform a `findAll` request for the given type.
 When passed to `store.request`, this config will result in the same behavior as a `store.findAll` request.
@@ -30,6 +30,6 @@ To that end, these builders are deprecated and will be removed in a future versi
 @param {FindAllBuilderOptions} [options] optional, may include `adapterOptions` hash which will be passed to adapter.findAll
 @return {FindAllRequestInput} request config
 */
-export declare function findAllBuilder<T extends TypedRecordInstance>(type: TypeFromInstance<T>, options?: FindAllBuilderOptions<T>): FindAllRequestInput<TypeFromInstance<T>, T[]>;
+export declare function findAllBuilder<T extends TypedRecordInstance>(type: TypeFromInstance<T>, options?: FindAllBuilderOptions): FindAllRequestInput<TypeFromInstance<T>, T[]>;
 export declare function findAllBuilder(type: string, options?: FindAllBuilderOptions): FindAllRequestInput;
 export {};

package/declarations/compat/builders/query.d.ts

@@ -31,7 +31,7 @@ To that end, these builders are deprecated and will be removed in a future versi
 @param {QueryBuilderOptions} [options] optional, may include `adapterOptions` hash which will be passed to adapter.query
 @return {QueryRequestInput} request config
 */
-export declare function queryBuilder<T extends TypedRecordInstance>(type: TypeFromInstance<T>, query: LegacyResourceQuery<T>, options?: QueryBuilderOptions): QueryRequestInput<TypeFromInstance<T>, T[]>;
+export declare function queryBuilder<T extends TypedRecordInstance>(type: TypeFromInstance<T>, query: LegacyResourceQuery, options?: QueryBuilderOptions): QueryRequestInput<TypeFromInstance<T>, T[]>;
 export declare function queryBuilder(type: string, query: LegacyResourceQuery, options?: QueryBuilderOptions): QueryRequestInput;
 type QueryRecordRequestInput<
 	T extends string = string,
@@ -61,6 +61,6 @@ To that end, these builders are deprecated and will be removed in a future versi
 @param {QueryBuilderOptions} [options] optional, may include `adapterOptions` hash which will be passed to adapter.query
 @return {QueryRecordRequestInput} request config
 */
-export declare function queryRecordBuilder<T extends TypedRecordInstance>(type: TypeFromInstance<T>, query: LegacyResourceQuery<T>, options?: QueryBuilderOptions): QueryRecordRequestInput<TypeFromInstance<T>, T | null>;
+export declare function queryRecordBuilder<T extends TypedRecordInstance>(type: TypeFromInstance<T>, query: LegacyResourceQuery, options?: QueryBuilderOptions): QueryRecordRequestInput<TypeFromInstance<T>, T | null>;
 export declare function queryRecordBuilder(type: string, query: LegacyResourceQuery, options?: QueryBuilderOptions): QueryRecordRequestInput;
 export {};

package/declarations/compat/builders/save-record.d.ts

@@ -1,5 +1,5 @@
 import { type StoreRequestInput } from "@warp-drive/core";
-import type { StableRecordIdentifier } from "@warp-drive/core/types";
+import type { ResourceKey } from "@warp-drive/core/types";
 import type { TypedRecordInstance, TypeFromInstance } from "@warp-drive/core/types/record";
 import type { RequestSignature } from "@warp-drive/core/types/symbols";
 type SaveRecordRequestInput<
@@ -8,10 +8,10 @@ type SaveRecordRequestInput<
 > = StoreRequestInput & {
 	op: "createRecord" | "deleteRecord" | "updateRecord";
 	data: {
-		record: StableRecordIdentifier<T>;
+		record: ResourceKey<T>;
 		options: SaveRecordBuilderOptions;
 	};
-	records: [StableRecordIdentifier<T>];
+	records: [ResourceKey<T>];
 	[RequestSignature]?: RT;
 };
 type SaveRecordBuilderOptions = Record<string, unknown>;

package/declarations/compat/legacy-network-handler/fetch-manager.d.ts

@@ -1,8 +1,8 @@
 import type { Store } from "@warp-drive/core";
 import { createDeferred } from "@warp-drive/core/request";
-import type { Request, RequestStateService } from "@warp-drive/core/store/-private";
+import type { Request } from "@warp-drive/core/store/-private";
 import type { FindRecordOptions } from "@warp-drive/core/types";
-import type { StableExistingRecordIdentifier, StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { PersistedResourceKey, ResourceKey } from "@warp-drive/core/types/identifier";
 import type { TypeFromInstance } from "@warp-drive/core/types/record";
 import type { ImmutableRequestInfo } from "@warp-drive/core/types/request";
 import type { SingleResourceDocument } from "@warp-drive/core/types/spec/json-api-raw";
@@ -13,36 +13,44 @@ export type FetchMutationOptions = FindRecordOptions & {
 	[SaveOp]: "createRecord" | "deleteRecord" | "updateRecord";
 };
 interface PendingFetchItem {
-	identifier: StableExistingRecordIdentifier;
+	identifier: PersistedResourceKey;
 	queryRequest: Request;
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	resolver: Deferred<any>;
 	options: FindRecordOptions;
 	trace?: unknown;
-	promise: Promise<StableExistingRecordIdentifier>;
+	promise: Promise<PersistedResourceKey>;
 }
+/**
+* @private
+*/
 export declare class FetchManager {
-	isDestroyed: boolean;
-	requestCache: RequestStateService;
-	// fetches pending in the runloop, waiting to be coalesced
-	_pendingFetch: Map<string, Map<StableExistingRecordIdentifier, PendingFetchItem[]>>;
-	_store: Store;
 	constructor(store: Store);
-	createSnapshot<T>(identifier: StableRecordIdentifier<TypeFromInstance<T>>, options?: FindRecordOptions): Snapshot<T>;
-	createSnapshot(identifier: StableRecordIdentifier, options?: FindRecordOptions): Snapshot;
+	createSnapshot<T>(identifier: ResourceKey<TypeFromInstance<T>>, options?: FindRecordOptions): Snapshot<T>;
+	createSnapshot(identifier: ResourceKey, options?: FindRecordOptions): Snapshot;
 	/**
 	This method is called by `record.save`, and gets passed a
 	resolver for the promise that `record.save` returns.
 	
 	It schedules saving to happen at the end of the run loop.
 	
-	@internal
+	@private
 	*/
-	scheduleSave(identifier: StableRecordIdentifier, options: FetchMutationOptions): Promise<null | SingleResourceDocument>;
-	scheduleFetch(identifier: StableExistingRecordIdentifier, options: FindRecordOptions, request: ImmutableRequestInfo): Promise<StableExistingRecordIdentifier>;
-	getPendingFetch(identifier: StableExistingRecordIdentifier, options: FindRecordOptions): Promise<StableExistingRecordIdentifier> | undefined;
+	scheduleSave(identifier: ResourceKey, options: FetchMutationOptions): Promise<null | SingleResourceDocument>;
+	scheduleFetch(identifier: PersistedResourceKey, options: FindRecordOptions, request: ImmutableRequestInfo): Promise<PersistedResourceKey>;
+	getPendingFetch(identifier: PersistedResourceKey, options: FindRecordOptions): Promise<PersistedResourceKey> | undefined;
 	flushAllPendingFetches(): void;
-	fetchDataIfNeededForIdentifier(identifier: StableExistingRecordIdentifier, options: FindRecordOptions | undefined, request: ImmutableRequestInfo): Promise<StableExistingRecordIdentifier>;
+	fetchDataIfNeededForIdentifier(identifier: PersistedResourceKey, options: FindRecordOptions | undefined, request: ImmutableRequestInfo): Promise<PersistedResourceKey>;
 	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 PrivateFetchManager extends FetchManager {
+	_pendingFetch: Map<string, Map<PersistedResourceKey, PendingFetchItem[]>>;
+}
 export {};

package/declarations/compat/legacy-network-handler/identifier-has-id.d.ts

@@ -1,2 +1,2 @@
-import type { StableExistingRecordIdentifier } from "@warp-drive/core/types/identifier";
-export declare function assertIdentifierHasId(identifier: unknown): asserts identifier is StableExistingRecordIdentifier;
+import type { PersistedResourceKey } from "@warp-drive/core/types/identifier";
+export declare function assertIdentifierHasId(identifier: unknown): asserts identifier is PersistedResourceKey;

package/declarations/compat/legacy-network-handler/legacy-data-fetch.d.ts

@@ -1,11 +1,11 @@
 import type { Store } from "@warp-drive/core";
 import type { BaseFinderOptions } from "@warp-drive/core/types";
-import type { StableExistingRecordIdentifier, StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { PersistedResourceKey, ResourceKey } from "@warp-drive/core/types/identifier";
 import type { LegacyRelationshipField as RelationshipSchema } from "@warp-drive/core/types/schema/fields";
 import type { MinimumAdapterInterface } from "./minimum-adapter-interface.js";
-export declare function _findHasMany(adapter: MinimumAdapterInterface, store: Store, identifier: StableRecordIdentifier, link: string | null | {
+export declare function _findHasMany(adapter: MinimumAdapterInterface, store: Store, identifier: ResourceKey, link: string | null | {
 	href: string;
-}, relationship: RelationshipSchema, options: BaseFinderOptions): Promise<StableExistingRecordIdentifier[]>;
-export declare function _findBelongsTo(store: Store, identifier: StableRecordIdentifier, link: string | null | {
+}, relationship: RelationshipSchema, options: BaseFinderOptions): Promise<PersistedResourceKey[]>;
+export declare function _findBelongsTo(store: Store, identifier: ResourceKey, link: string | null | {
 	href: string;
-}, relationship: RelationshipSchema, options: BaseFinderOptions): Promise<StableExistingRecordIdentifier | null>;
+}, relationship: RelationshipSchema, options: BaseFinderOptions): Promise<PersistedResourceKey | null>;

package/declarations/compat/legacy-network-handler/minimum-adapter-interface.d.ts

@@ -1,5 +1,5 @@
 import type { Store } from "@warp-drive/core";
-import type { CollectionRecordArray } from "@warp-drive/core/store/-private";
+import type { LegacyQueryArray } from "@warp-drive/core/store/-private";
 import type { ModelSchema } from "@warp-drive/core/types";
 import type { LegacyRelationshipField as RelationshipSchema } from "@warp-drive/core/types/schema/fields";
 import type { Snapshot } from "./snapshot.js";
@@ -113,11 +113,11 @@ export interface MinimumAdapterInterface {
 	* @param {ModelSchema} schema An object with methods for accessing information about
 	*  the type, attributes and relationships of the primary type associated with the request.
 	* @param {Object} query
-	* @param {CollectionRecordArray} recordArray
+	* @param {LegacyQueryArray} recordArray
 	* @param {Object} options
 	* @return {Promise} a promise resolving with resource data to feed to the associated serializer
 	*/
-	query(store: Store, schema: ModelSchema, query: Record<string, unknown>, recordArray: CollectionRecordArray, options: {
+	query(store: Store, schema: ModelSchema, query: Record<string, unknown>, recordArray: LegacyQueryArray, options: {
 		adapterOptions?: unknown;
 	}): Promise<AdapterPayload>;
 	/**

package/declarations/compat/legacy-network-handler/snapshot-record-array.d.ts

@@ -1,21 +1,55 @@
 import type { Store } from "@warp-drive/core";
-import type { LiveArray } from "@warp-drive/core/store/-private";
-import type { FindAllOptions, ModelSchema } from "@warp-drive/core/types";
+import type { FindAllOptions } from "@warp-drive/core/types";
 import type { Snapshot } from "./snapshot.js";
 /**
 SnapshotRecordArray is not directly instantiable.
 Instances are provided to consuming application's
 adapters for certain `findAll` requests.
 
-@class SnapshotRecordArray
+@hideconstructor
 @public
 */
 export declare class SnapshotRecordArray {
-	_snapshots: Snapshot[] | null;
-	_type: ModelSchema | null;
+	/**
+	* The ResourceType of the underlying records for the {@link Snapshot | Snapshots} in the array
+	*/
 	modelName: string;
-	__store: Store;
+	/**
+	*  A hash of adapter options passed into the store method for this request.
+	
+	Example
+	
+	```js [app/adapters/post.js]
+	import MyCustomAdapter from './custom-adapter';
+	
+	export default class PostAdapter extends MyCustomAdapter {
+	findAll(store, type, sinceToken, snapshotRecordArray) {
+	if (snapshotRecordArray.adapterOptions.subscribe) {
+	// ...
+	}
+	// ...
+	}
+	}
+	```
+	*/
 	adapterOptions?: Record<string, unknown>;
+	/**
+	* The relationships to include for this request.
+	
+	Example
+	
+	```js [app/adapters/application.js]
+	import Adapter from '@ember-data/adapter';
+	
+	export default class ApplicationAdapter extends Adapter {
+	findAll(store, type, snapshotRecordArray) {
+	let url = `/${type.modelName}?include=${encodeURIComponent(snapshotRecordArray.include)}`;
+	
+	return fetch(url).then((response) => response.json())
+	}
+	}
+	```
+	*/
 	include?: string | string[];
 	/**
 	SnapshotRecordArray is not directly instantiable.
@@ -30,14 +64,6 @@ export declare class SnapshotRecordArray {
 	*/
 	constructor(store: Store, type: string, options?: FindAllOptions);
 	/**
-	An array of records
-	
-	@property _recordArray
-	@private
-	@type {Array}
-	*/
-	get _recordArray(): LiveArray;
-	/**
 	Number of records in the array
 	
 	Example
@@ -51,10 +77,6 @@ export declare class SnapshotRecordArray {
 	}
 	});
 	```
-	
-	@property length
-	@public
-	@type {Number}
 	*/
 	get length(): number;
 	/**

package/declarations/compat/legacy-network-handler/snapshot.d.ts

@@ -1,7 +1,7 @@
 import type { Store } from "@warp-drive/core";
 import type { FindRecordOptions } from "@warp-drive/core/types";
 import type { ChangedAttributesHash } from "@warp-drive/core/types/cache";
-import type { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { ResourceKey } from "@warp-drive/core/types/identifier";
 import type { TypedRecordInstance, TypeFromInstance } from "@warp-drive/core/types/record";
 import type { LegacyAttributeField, LegacyRelationshipField } from "@warp-drive/core/types/schema/fields";
 import type { SerializerOptions } from "./minimum-serializer-interface.js";
@@ -14,46 +14,64 @@ adapters and serializers for certain requests.
 Snapshots are only available when using `@ember-data/legacy-compat`
 for legacy compatibility with adapters and serializers.
 
-@class Snapshot
+For serialization of records in modern paradigms, request data from
+the cache or off the record directly.
+
+@hideconstructor
 @public
 */
 export declare class Snapshot<R = unknown> {
-	__attributes: Record<keyof R & string, unknown> | null;
-	_belongsToRelationships: Record<string, Snapshot>;
-	_belongsToIds: Record<string, RecordId>;
-	_hasManyRelationships: Record<string, Snapshot[]>;
-	_hasManyIds: Record<string, RecordId[]>;
-	_changedAttributes: ChangedAttributesHash;
-	identifier: StableRecordIdentifier<R extends TypedRecordInstance ? TypeFromInstance<R> : string>;
+	/**
+	The unique ResourceKey associated with this Snapshot.
+	
+	@public
+	*/
+	identifier: ResourceKey<R extends TypedRecordInstance ? TypeFromInstance<R> : string>;
+	/**
+	The ResourceType of the underlying record for this Snapshot, as a string.
+	
+	@public
+	*/
 	modelName: R extends TypedRecordInstance ? TypeFromInstance<R> : string;
+	/**
+	The id of the snapshot's underlying record
+	
+	Example
+	
+	```js
+	// store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });
+	postSnapshot.id; // => '1'
+	```
+	
+	@public
+	*/
 	id: string | null;
+	/**
+	If `include` was passed to the options for the request, the value
+	would be available here.
+	
+	@public
+	*/
 	include?: string | string[];
-	adapterOptions?: Record<string, unknown>;
-	_store: Store;
 	/**
-	* @constructor
-	* @private
-	* @param options
-	* @param identifier
-	* @param _store
+	The adapterOptions passed to the request which generated this Snapshot, if any
+	
+	@public
 	*/
-	constructor(options: FindRecordOptions, identifier: StableRecordIdentifier<R extends TypedRecordInstance ? TypeFromInstance<R> : string>, store: Store);
+	adapterOptions?: Record<string, unknown>;
+	constructor(options: FindRecordOptions, identifier: ResourceKey<R extends TypedRecordInstance ? TypeFromInstance<R> : string>, store: Store);
 	/**
 	The underlying record for this snapshot. Can be used to access methods and
 	properties defined on the record.
 	
-	Example
-	
-	```javascript
-	let json = snapshot.record.toJSON();
+	```js
+	const someValue = snapshot.record.someProp;
 	```
 	
 	@property record
-	@type {Model}
 	@public
 	*/
 	get record(): R | null;
-	get _attributes(): Record<keyof R & string, unknown>;
 	get isNew(): boolean;
 	/**
 	Returns the value of an attribute.
@@ -68,22 +86,28 @@ export declare class Snapshot<R = unknown> {
 	
 	Note: Values are loaded eagerly and cached when the snapshot is created.
 	
-	@param {String} keyName
-	@return {Object} The attribute value or undefined
+	@return The attribute value or undefined
 	@public
 	*/
 	attr(keyName: keyof R & string): unknown;
 	/**
 	Returns all attributes and their corresponding values.
 	
+	::: warning ⚠️ WARNING
+	Attributes are SHALLOW copied from the cache.
+	Because they are NOT deep copied from the cache, mutating
+	any object or array fields will cause unintended side-effects
+	and bugs.
+	:::
+	
 	Example
 	
-	```javascript
+	```js
 	// store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });
 	postSnapshot.attributes(); // => { author: 'Tomster', title: 'Ember.js rocks' }
 	```
 	
-	@return {Object} All attributes of the current snapshot
+	@return All attributes of the current snapshot
 	@public
 	*/
 	attributes(): Record<keyof R & string, unknown>;
@@ -92,13 +116,13 @@ export declare class Snapshot<R = unknown> {
 	
 	Example
 	
-	```javascript
+	```js
 	// store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });
 	postModel.set('title', 'Ember.js rocks!');
 	postSnapshot.changedAttributes(); // => { title: ['Ember.js rocks', 'Ember.js rocks!'] }
 	```
 	
-	@return {Object} All changed attributes of the current snapshot
+	@return All changed attributes of the current snapshot
 	@public
 	*/
 	changedAttributes(): ChangedAttributesHash;
@@ -113,7 +137,7 @@ export declare class Snapshot<R = unknown> {
 	
 	Example
 	
-	```javascript
+	```js
 	// store.push('post', { id: 1, title: 'Hello World' });
 	// store.createRecord('comment', { body: 'Lorem ipsum', post: post });
 	commentSnapshot.belongsTo('post'); // => Snapshot
@@ -130,12 +154,10 @@ export declare class Snapshot<R = unknown> {
 	
 	Note: Relationships are loaded lazily and cached upon first access.
 	
-	@param {String} keyName
-	@param {Object} [options]
 	@public
-	@return {(Snapshot|String|null|undefined)} A snapshot or ID of a known
-	relationship or null if the relationship is known but unset. undefined
-	will be returned if the contents of the relationship is unknown.
+	@return A snapshot or ID of a known relationship or null if the
+	relationship is known but unset. undefined will be returned if the
+	contents of the relationship are unknown.
 	*/
 	belongsTo(keyName: string, options?: {
 		id?: boolean;
@@ -162,10 +184,8 @@ export declare class Snapshot<R = unknown> {
 	
 	Note: Relationships are loaded lazily and cached upon first access.
 	
-	@param {String} keyName
-	@param {Object} [options]
 	@public
-	@return {(Array|undefined)} An array of snapshots or IDs of a known
+	@return An array of snapshots or IDs of a known
 	relationship or an empty array if the relationship is known but unset.
 	undefined will be returned if the contents of the relationship is unknown.
 	*/
@@ -184,8 +204,8 @@ export declare class Snapshot<R = unknown> {
 	});
 	```
 	
-	@param {Function} callback the callback to execute
-	@param {Object} [binding] the value to which the callback's `this` should be bound
+	@param callback the callback to execute
+	@param binding the optional value to which the callback's `this` should be bound
 	@public
 	*/
 	eachAttribute(callback: (key: string, meta: LegacyAttributeField) => void, binding?: unknown): void;
@@ -201,8 +221,8 @@ export declare class Snapshot<R = unknown> {
 	});
 	```
 	
-	@param {Function} callback the callback to execute
-	@param {Object} [binding] the value to which the callback's `this` should be bound
+	@param callback the callback to execute
+	@param binding the optional value to which the callback's `this` should be bound
 	@public
 	*/
 	eachRelationship(callback: (key: string, meta: LegacyRelationshipField) => void, binding?: unknown): void;
@@ -227,8 +247,7 @@ export declare class Snapshot<R = unknown> {
 	});
 	```
 	
-	@param {Object} options
-	@return {Object} an object whose values are primitive JSON values only
+	@return an object whose values are primitive JSON values only
 	@public
 	*/
 	serialize(options?: SerializerOptions): unknown;

package/declarations/compat.d.ts

@@ -6,7 +6,7 @@ import type { AdapterPayload, MinimumAdapterInterface } from "./compat/legacy-ne
 import type { MinimumSerializerInterface, SerializerOptions } from "./compat/legacy-network-handler/minimum-serializer-interface.js";
 export { LegacyNetworkHandler } from "./compat/legacy-network-handler/legacy-network-handler.js";
 export type { MinimumAdapterInterface, MinimumSerializerInterface, SerializerOptions, AdapterPayload };
-export type LegacyStoreCompat = {
+export interface LegacyStoreCompat extends Store {
 	_fetchManager: FetchManager;
 	adapterFor(this: Store, modelName: string): MinimumAdapterInterface;
 	adapterFor(this: Store, modelName: string, _allowMissing: true): MinimumAdapterInterface | undefined;
@@ -20,8 +20,8 @@ export type LegacyStoreCompat = {
 	_serializerCache: Record<string, MinimumSerializerInterface & {
 		store: Store;
 	}>;
-};
-export type CompatStore = Store & LegacyStoreCompat;
+}
+export type CompatStore = LegacyStoreCompat;
 /**
 Returns an instance of the adapter for a given type. For
 example, `adapterFor('person')` will return an instance of

package/declarations/model/-private/attr.d.ts

@@ -1,5 +1,5 @@
 import type { ArrayValue, ObjectValue, PrimitiveValue } from "@warp-drive/core/types/json/raw";
-import type { TransformName } from "@warp-drive/core/types/symbols";
+import { type TransformName } from "@warp-drive/core/types/symbols";
 import type { DecoratorPropertyDescriptor } from "./util.js";
 /**
 * Options provided to the attr decorator are

package/declarations/model/-private/debug/assert-polymorphic-type.d.ts

@@ -1,6 +1,6 @@
 import type { Store } from "@warp-drive/core";
 import type { UpgradedMeta } from "@warp-drive/core/graph/-private";
-import type { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { ResourceKey } from "@warp-drive/core/types/identifier";
 /*
 Assert that `addedRecord` has a valid type so it can be added to the
 relationship of the `record`.
@@ -13,5 +13,5 @@ be stable record identifiers and the `relationshipMeta` needs to be the meta
 information about the relationship, retrieved via
 `record.relationshipFor(key)`.
 */
-declare let assertPolymorphicType: (parentIdentifier: StableRecordIdentifier, parentDefinition: UpgradedMeta, addedIdentifier: StableRecordIdentifier, store: Store) => void;
+declare let assertPolymorphicType: (parentIdentifier: ResourceKey, parentDefinition: UpgradedMeta, addedIdentifier: ResourceKey, store: Store) => void;
 export { assertPolymorphicType };

package/declarations/model/-private/hooks.d.ts

@@ -1,8 +1,8 @@
 import { type Store } from "@warp-drive/core/store/-private";
-import type { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { ResourceKey } from "@warp-drive/core/types/identifier";
 import type { TypeFromInstance } from "@warp-drive/core/types/record";
 import type { Model } from "./model.js";
-export declare function instantiateRecord(this: Store, identifier: StableRecordIdentifier, createRecordArgs: {
+export declare function instantiateRecord(this: Store, identifier: ResourceKey, createRecordArgs: {
 	[key: string]: unknown;
 }): Model;
 export declare function teardownRecord(record: Model): void;

package/declarations/model/-private/legacy-relationships-support.d.ts

@@ -1,9 +1,7 @@
 import type { Store } from "@warp-drive/core";
-import type { CollectionEdge, Graph, ResourceEdge, UpgradedMeta } from "@warp-drive/core/graph/-private";
-import type { LiveArray } from "@warp-drive/core/store/-private";
-import { RelatedCollection as ManyArray } from "@warp-drive/core/store/-private";
-import type { BaseFinderOptions, StableRecordIdentifier } from "@warp-drive/core/types";
-import type { Cache } from "@warp-drive/core/types/cache";
+import type { CollectionEdge, ResourceEdge, UpgradedMeta } from "@warp-drive/core/graph/-private";
+import type { LegacyManyArray } from "@warp-drive/core/store/-private";
+import type { BaseFinderOptions, ResourceKey } from "@warp-drive/core/types";
 import type { CollectionRelationship } from "@warp-drive/core/types/cache/relationship";
 import type { LocalRelationshipOperation } from "@warp-drive/core/types/graph";
 import type { OpaqueRecordInstance, TypeFromInstanceOrString } from "@warp-drive/core/types/record";
@@ -15,33 +13,26 @@ import type { HasManyProxyCreateArgs } from "./promise-many-array.js";
 import { PromiseManyArray } from "./promise-many-array.js";
 import BelongsToReference from "./references/belongs-to.js";
 import HasManyReference from "./references/has-many.js";
-export declare const LEGACY_SUPPORT: Map<StableRecordIdentifier | MinimalLegacyRecord, LegacySupport>;
+export declare const LEGACY_SUPPORT: Map<ResourceKey | MinimalLegacyRecord, LegacySupport>;
 export declare function lookupLegacySupport(record: MinimalLegacyRecord): LegacySupport;
+/**
+* @hideconstructor
+*/
 export declare class LegacySupport {
-	record: MinimalLegacyRecord;
-	store: Store;
-	graph: Graph;
-	cache: Cache;
-	references: Record<string, BelongsToReference | HasManyReference>;
-	identifier: StableRecordIdentifier;
-	_manyArrayCache: Record<string, ManyArray>;
-	_relationshipPromisesCache: Record<string, Promise<ManyArray | OpaqueRecordInstance>>;
-	_relationshipProxyCache: Record<string, PromiseManyArray | PromiseBelongsTo | undefined>;
-	_pending: Record<string, Promise<StableRecordIdentifier | null> | undefined>;
-	isDestroying: boolean;
-	isDestroyed: boolean;
-	constructor(record: MinimalLegacyRecord);
-	_syncArray(array: LiveArray): void;
+	identifier: ResourceKey;
+	constructor(record: MinimalLegacyRecord, identifier: ResourceKey);
+	/** @private */
+	_syncArray(array: LegacyManyArray): void;
 	mutate(mutation: LocalRelationshipOperation): void;
 	_findBelongsTo(key: string, resource: SingleResourceRelationship, relationship: ResourceEdge, options?: BaseFinderOptions): Promise<OpaqueRecordInstance | null>;
 	reloadBelongsTo(key: string, options?: BaseFinderOptions): Promise<OpaqueRecordInstance | null>;
 	getBelongsTo(key: string, options?: BaseFinderOptions): PromiseBelongsTo | OpaqueRecordInstance | null;
 	setDirtyBelongsTo(key: string, value: OpaqueRecordInstance | null): void;
-	_getCurrentState<T>(identifier: StableRecordIdentifier, field: string): [StableRecordIdentifier<TypeFromInstanceOrString<T>>[], CollectionRelationship];
-	getManyArray<T>(key: string, definition?: UpgradedMeta): ManyArray<T>;
-	fetchAsyncHasMany(key: string, relationship: CollectionEdge, manyArray: ManyArray, options?: BaseFinderOptions): Promise<ManyArray>;
-	reloadHasMany<T>(key: string, options?: BaseFinderOptions): Promise<ManyArray<T>> | PromiseManyArray<T>;
-	getHasMany(key: string, options?: BaseFinderOptions): PromiseManyArray | ManyArray;
+	_getCurrentState<T>(identifier: ResourceKey, field: string): [ResourceKey<TypeFromInstanceOrString<T>>[], CollectionRelationship];
+	getManyArray<T>(key: string, definition?: UpgradedMeta): LegacyManyArray<T>;
+	fetchAsyncHasMany(key: string, relationship: CollectionEdge, manyArray: LegacyManyArray, options?: BaseFinderOptions): Promise<LegacyManyArray>;
+	reloadHasMany<T>(key: string, options?: BaseFinderOptions): Promise<LegacyManyArray<T>> | PromiseManyArray<T>;
+	getHasMany(key: string, options?: BaseFinderOptions): PromiseManyArray | LegacyManyArray;
 	_updatePromiseProxyFor(kind: "hasMany", key: string, args: HasManyProxyCreateArgs): PromiseManyArray;
 	_updatePromiseProxyFor(kind: "belongsTo", key: string, args: BelongsToProxyCreateArgs): PromiseBelongsTo;
 	_updatePromiseProxyFor(kind: "belongsTo", key: string, args: {
@@ -49,8 +40,8 @@ export declare class LegacySupport {
 	}): PromiseBelongsTo;
 	referenceFor(kind: "belongsTo", name: string): BelongsToReference;
 	referenceFor(kind: "hasMany", name: string): HasManyReference;
-	_findHasManyByJsonApiResource(resource: CollectionResourceRelationship, parentIdentifier: StableRecordIdentifier, relationship: CollectionEdge, options?: BaseFinderOptions): Promise<void | unknown[]> | void;
-	_findBelongsToByJsonApiResource(resource: SingleResourceRelationship, parentIdentifier: StableRecordIdentifier, relationship: ResourceEdge, options?: BaseFinderOptions): Promise<StableRecordIdentifier | null>;
+	_findHasManyByJsonApiResource(resource: CollectionResourceRelationship, parentIdentifier: ResourceKey, relationship: CollectionEdge, options?: BaseFinderOptions): Promise<void | unknown[]> | void;
+	_findBelongsToByJsonApiResource(resource: SingleResourceRelationship, parentIdentifier: ResourceKey, relationship: ResourceEdge, options?: BaseFinderOptions): Promise<ResourceKey | null>;
 	destroy(): void;
 }
 export declare function areAllInverseRecordsLoaded(store: Store, resource: InnerRelationshipDocument): boolean;