@warp-drive/legacy 5.7.0-alpha.2 → 5.7.0-alpha.21

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

@@ -2,7 +2,7 @@ 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 { 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,23 +13,23 @@ 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>;
 }
 export declare class FetchManager {
 	isDestroyed: boolean;
 	requestCache: RequestStateService;
 	// fetches pending in the runloop, waiting to be coalesced
-	_pendingFetch: Map<string, Map<StableExistingRecordIdentifier, PendingFetchItem[]>>;
+	_pendingFetch: Map<string, Map<PersistedResourceKey, 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.
@@ -38,11 +38,11 @@ export declare class FetchManager {
 	
 	@internal
 	*/
-	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;
 }
 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,5 +1,5 @@
 import type { Store } from "@warp-drive/core";
-import type { LiveArray } from "@warp-drive/core/store/-private";
+import type { LegacyLiveArray } from "@warp-drive/core/store/-private";
 import type { FindAllOptions, ModelSchema } from "@warp-drive/core/types";
 import type { Snapshot } from "./snapshot.js";
 /**
@@ -36,7 +36,7 @@ export declare class SnapshotRecordArray {
 	@private
 	@type {Array}
 	*/
-	get _recordArray(): LiveArray;
+	get _recordArray(): LegacyLiveArray;
 	/**
 	Number of records in the array
 	

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,73 @@ 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>;
+	private __attributes;
+	private _belongsToRelationships;
+	private _belongsToIds;
+	private _hasManyRelationships;
+	private _hasManyIds;
+	private _changedAttributes;
+	private _store;
+	/**
+	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>;
+	/** @internal */
+	private get _attributes();
 	get isNew(): boolean;
 	/**
 	Returns the value of an attribute.
@@ -68,22 +95,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 +125,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 +146,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 +163,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 +193,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 +213,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 +230,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 +256,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/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,8 +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 { LegacyManyArray } from "@warp-drive/core/store/-private";
+import type { BaseFinderOptions, ResourceKey } from "@warp-drive/core/types";
 import type { Cache } from "@warp-drive/core/types/cache";
 import type { CollectionRelationship } from "@warp-drive/core/types/cache/relationship";
 import type { LocalRelationshipOperation } from "@warp-drive/core/types/graph";
@@ -15,7 +14,7 @@ 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;
 export declare class LegacySupport {
 	record: MinimalLegacyRecord;
@@ -23,25 +22,25 @@ export declare class LegacySupport {
 	graph: Graph;
 	cache: Cache;
 	references: Record<string, BelongsToReference | HasManyReference>;
-	identifier: StableRecordIdentifier;
-	_manyArrayCache: Record<string, ManyArray>;
-	_relationshipPromisesCache: Record<string, Promise<ManyArray | OpaqueRecordInstance>>;
+	identifier: ResourceKey;
+	_manyArrayCache: Record<string, LegacyManyArray>;
+	_relationshipPromisesCache: Record<string, Promise<LegacyManyArray | OpaqueRecordInstance>>;
 	_relationshipProxyCache: Record<string, PromiseManyArray | PromiseBelongsTo | undefined>;
-	_pending: Record<string, Promise<StableRecordIdentifier | null> | undefined>;
+	_pending: Record<string, Promise<ResourceKey | null> | undefined>;
 	isDestroying: boolean;
 	isDestroyed: boolean;
-	constructor(record: MinimalLegacyRecord);
-	_syncArray(array: LiveArray): void;
+	constructor(record: MinimalLegacyRecord, identifier: ResourceKey);
+	_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 +48,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;

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

@@ -1,7 +1,7 @@
 import EmberObject from "@ember/object";
 import type { Store } from "@warp-drive/core";
-import type { ModelSchema, StableRecordIdentifier } from "@warp-drive/core/types";
-import type { Cache, ChangedAttributesHash } from "@warp-drive/core/types/cache";
+import type { ModelSchema, ResourceKey } from "@warp-drive/core/types";
+import type { ChangedAttributesHash } from "@warp-drive/core/types/cache";
 import type { LegacyAttributeField, LegacyRelationshipField } from "@warp-drive/core/types/schema/fields";
 import { RecordStore } from "@warp-drive/core/types/symbols";
 import type { Snapshot } from "../../compat/-private.js";
@@ -15,10 +15,9 @@ export type ModelCreateArgs = {
 	_createProps: Record<string, unknown>;
 	// TODO @deprecate consider deprecating accessing record properties during init which the below is necessary for
 	_secretInit: {
-		identifier: StableRecordIdentifier;
-		cache: Cache;
+		identifier: ResourceKey;
 		store: Store;
-		cb: (record: Model, cache: Cache, identifier: StableRecordIdentifier, store: Store) => void;
+		cb: (record: Model, identifier: ResourceKey, store: Store) => void;
 	};
 };
 export type StaticModel = typeof Model & {

package/declarations/model/-private/notify-changes.d.ts

@@ -1,4 +1,4 @@
 import type { NotificationType, Store } from "@warp-drive/core";
-import type { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { ResourceKey } from "@warp-drive/core/types/identifier";
 import type { Model } from "./model.js";
-export default function notifyChanges(identifier: StableRecordIdentifier, value: NotificationType, key: string | undefined, record: Model, store: Store): void;
+export default function notifyChanges(identifier: ResourceKey, value: NotificationType, key: string | undefined, record: Model, store: Store): void;

package/declarations/model/-private/record-state.d.ts

@@ -1,7 +1,7 @@
 import type { Store } from "@warp-drive/core";
 import type { RequestCacheRequestState, RequestStateService } from "@warp-drive/core/store/-private";
 import type { Cache } 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 { Errors } from "./errors.js";
 import type { MinimalLegacyRecord } from "./model-methods.js";
 /**
@@ -45,7 +45,7 @@ inFlight
 */
 export default class RecordState {
 	store: Store;
-	identifier: StableRecordIdentifier;
+	identifier: ResourceKey;
 	record: MinimalLegacyRecord;
 	rs: RequestStateService;
 	pendingCount: number;

package/declarations/model/-private/references/belongs-to.d.ts

@@ -1,6 +1,6 @@
 import type { Store } from "@warp-drive/core";
 import type { Graph, ResourceEdge } from "@warp-drive/core/graph/-private";
-import type { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { ResourceKey } from "@warp-drive/core/types/identifier";
 import type { TypeFromInstance, TypeFromInstanceOrString } from "@warp-drive/core/types/record";
 import type { Links, Meta, SingleResourceDocument, SingleResourceRelationship } from "@warp-drive/core/types/spec/json-api-raw";
 import type { IsUnknown } from "../belongs-to.js";
@@ -59,20 +59,20 @@ export default class BelongsToReference<
 	type: TypeFromInstanceOrString<Related>;
 	// unsubscribe tokens given to us by the notification manager
 	___token: object;
-	___identifier: StableRecordIdentifier<TypeFromInstanceOrString<T>>;
+	___identifier: ResourceKey<TypeFromInstanceOrString<T>>;
 	___relatedToken: object | null;
 	_ref: number;
-	constructor(store: Store, graph: Graph, parentIdentifier: StableRecordIdentifier<TypeFromInstanceOrString<T>>, belongsToRelationship: ResourceEdge, key: K);
+	constructor(store: Store, graph: Graph, parentIdentifier: ResourceKey<TypeFromInstanceOrString<T>>, belongsToRelationship: ResourceEdge, key: K);
 	destroy(): void;
 	/**
 	* The identifier of the record that this reference refers to.
 	* `null` if no related record is known.
 	*
 	* @property identifier
-	* @type {StableRecordIdentifier | null}
+	* @type {ResourceKey | null}
 	* @public
 	*/
-	get identifier(): StableRecordIdentifier<TypeFromInstanceOrString<Related>> | null;
+	get identifier(): ResourceKey<TypeFromInstanceOrString<Related>> | null;
 	/**
 	The `id` of the record that this reference refers to. Together, the
 	`type()` and `id()` methods form a composite key for the identity
@@ -198,7 +198,7 @@ export default class BelongsToReference<
 	@return {Object} The meta information for the belongs-to relationship.
 	*/
 	meta(): Meta | null;
-	_resource(): SingleResourceRelationship<StableRecordIdentifier<TypeFromInstance<Related>>>;
+	_resource(): SingleResourceRelationship<ResourceKey<TypeFromInstance<Related>>>;
 	/**
 	This returns a string that represents how the reference will be
 	looked up when it is loaded. If the relationship has a link it will

package/declarations/model/-private/references/has-many.d.ts

@@ -2,7 +2,7 @@ import type { Store } from "@warp-drive/core";
 import type { CollectionEdge, Graph } from "@warp-drive/core/graph/-private";
 import type { RelatedCollection as ManyArray } from "@warp-drive/core/store/-private";
 import type { BaseFinderOptions } from "@warp-drive/core/types";
-import type { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { ResourceKey } from "@warp-drive/core/types/identifier";
 import type { TypeFromInstanceOrString } from "@warp-drive/core/types/record";
 import type { CollectionResourceDocument, CollectionResourceRelationship, ExistingResourceObject, LinkObject, Meta, PaginationLinks } from "@warp-drive/core/types/spec/json-api-raw";
 import type { IsUnknown } from "../belongs-to.js";
@@ -68,10 +68,10 @@ export default class HasManyReference<
 	type: TypeFromInstanceOrString<Related>;
 	// unsubscribe tokens given to us by the notification manager
 	___token: object;
-	___identifier: StableRecordIdentifier<TypeFromInstanceOrString<T>>;
-	___relatedTokenMap: Map<StableRecordIdentifier, object>;
+	___identifier: ResourceKey<TypeFromInstanceOrString<T>>;
+	___relatedTokenMap: Map<ResourceKey, object>;
 	_ref: number;
-	constructor(store: Store, graph: Graph, parentIdentifier: StableRecordIdentifier<TypeFromInstanceOrString<T>>, hasManyRelationship: CollectionEdge, key: K);
+	constructor(store: Store, graph: Graph, parentIdentifier: ResourceKey<TypeFromInstanceOrString<T>>, hasManyRelationship: CollectionEdge, key: K);
 	/**
 	* This method should never be called by user code.
 	*
@@ -82,10 +82,10 @@ export default class HasManyReference<
 	* An array of identifiers for the records that this reference refers to.
 	*
 	* @property identifiers
-	* @type {StableRecordIdentifier[]}
+	* @type {ResourceKey[]}
 	* @public
 	*/
-	get identifiers(): StableRecordIdentifier<TypeFromInstanceOrString<Related>>[];
+	get identifiers(): ResourceKey<TypeFromInstanceOrString<Related>>[];
 	_resource(): CollectionResourceRelationship;
 	/**
 	This returns a string that represents how the reference will be