@warp-drive/legacy 5.7.0-alpha.8 → 5.7.0-beta.0

package/declarations/adapter/-private/build-url-mixin.d.ts

@@ -1,15 +1,5 @@
 import Mixin from "@ember/object/mixin";
 import type { Snapshot, SnapshotRecordArray } from "../../compat/-private.js";
-/*
-The structure of this file is such because typing Mixins is hard. Here we've structured it in
-such a way as to maximize the type information that a consumer can utilize. There are simpler
-ways to type a mixin but we would not be able to provide the nice overload signature for buildURL
-*/
-// the interface must fully declare the function signatures that the individual functions
-// will also declare. If instead we try to keep them in sync by doing something like
-// `interface BuildURLMixin { buildURL: typeof buildURL }`
-// then an extending class overwriting one of the methods will break because typescript
-// thinks it is a switch from an instance prop (that is a method) to an instance method.
 export interface BuildURLMixin {
 	buildURL(this: MixtBuildURLMixin, modelName: string, id: string, snapshot: Snapshot, requestType: "findRecord"): string;
 	buildURL(this: MixtBuildURLMixin, modelName: string, id: null, snapshot: SnapshotRecordArray, requestType: "findAll"): string;
@@ -36,9 +26,6 @@ export interface BuildURLMixin {
 	urlPrefix(this: MixtBuildURLMixin, path?: string | null, parentURL?: string): string;
 	pathForType(this: MixtBuildURLMixin, modelName: string): string;
 }
-// prevents the final constructed object from needing to add
-// host and namespace which are provided by the final consuming
-// class to the prototype which can result in overwrite errors
 export interface MixtBuildURLMixin extends BuildURLMixin {
 	host: string | null;
 	namespace: string | null;

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/-private/utils/serialize-query-params.d.ts

@@ -1,9 +1,5 @@
 interface PlainObject {
 	[key: string]: string | PlainObject | PlainObject[] | string[];
 }
-/*
-* Helper function that turns the data/body of a request into a query param string.
-* This is directly copied from jQuery.param.
-*/
 export declare function serializeQueryParams(queryParamsObject: PlainObject | string): string;
 export {};

package/declarations/adapter/error.d.ts

@@ -71,7 +71,6 @@ wrap the error payload unaltered.
 @class InvalidError
 @public
 */
-// TODO @deprecate extractError documentation
 export type InvalidError = AdapterRequestError<"InvalidError">;
 export declare const InvalidError: AdapterRequestErrorConstructor<InvalidError>;
 /**

package/declarations/adapter/rest.d.ts

@@ -650,7 +650,6 @@ declare class RESTAdapter extends AdapterWithBuildURLMixin {
 	*/
 	deleteRecord(store: Store, schema: ModelSchema, snapshot: Snapshot): Promise<AdapterPayload>;
 	_stripIDFromURL(store: Store, snapshot: Snapshot): string;
-	// http://stackoverflow.com/questions/417142/what-is-the-maximum-length-of-a-url-in-different-browsers
 	maxURLLength: number;
 	/**
 	Organize records into groups, each of which is to be passed to separate
@@ -806,7 +805,6 @@ declare class RESTAdapter extends AdapterWithBuildURLMixin {
 	*/
 	buildQuery(snapshot: Snapshot | SnapshotRecordArray): QueryState;
 }
-// eslint-disable-next-line @typescript-eslint/no-empty-object-type
 interface RESTAdapter extends MixtBuildURLMixin {}
 /**
 * Helper function that translates the options passed to `jQuery.ajax` into a format that `fetch` expects.

package/declarations/adapter.d.ts

@@ -277,7 +277,6 @@ export declare class Adapter extends EmberObject implements MinimumAdapterInterf
 	
 	@public
 	*/
-	// @ts-expect-error
 	findRecord(store: Store, type: ModelSchema, id: string, snapshot: Snapshot): Promise<AdapterPayload>;
 	/**
 	The `findAll()` method is used to retrieve all records for a given type.
@@ -331,7 +330,6 @@ export declare class Adapter extends EmberObject implements MinimumAdapterInterf
 	
 	@public
 	*/
-	// @ts-expect-error
 	query(store: Store, type: ModelSchema, query: Record<string, unknown>): Promise<AdapterPayload>;
 	/**
 	The `queryRecord()` method is invoked when the store is asked for a single
@@ -448,7 +446,6 @@ export declare class Adapter extends EmberObject implements MinimumAdapterInterf
 	
 	@public
 	*/
-	// @ts-expect-error
 	createRecord(store: Store, type: ModelSchema, snapshot: Snapshot): Promise<AdapterPayload>;
 	/**
 	Implement this method in a subclass to handle the updating of
@@ -499,7 +496,6 @@ export declare class Adapter extends EmberObject implements MinimumAdapterInterf
 	@return {Promise} promise
 	@public
 	*/
-	// @ts-expect-error
 	updateRecord(store: Store, type: ModelSchema, snapshot: Snapshot): Promise<AdapterPayload>;
 	/**
 	Implement this method in a subclass to handle the deletion of
@@ -542,7 +538,6 @@ export declare class Adapter extends EmberObject implements MinimumAdapterInterf
 	@return {Promise} promise
 	@public
 	*/
-	// @ts-expect-error
 	deleteRecord(store: Store, type: ModelSchema, snapshot: Snapshot): Promise<AdapterPayload>;
 	/**
 	By default the store will try to coalesce all `findRecord` calls within the same runloop

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,43 @@ 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,15 +1,10 @@
 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";
 import type { SnapshotRecordArray } from "./snapshot-record-array.js";
 type Group = Snapshot[];
-// TODO this should probably just alias unknown
-// since in theory a user could pass a blob or a string
-// however those deserialization cases are handled
-// far easier in the adapter itself and are unlikely
-// to be passed to the serializer today.
 export type AdapterPayload = Record<string, unknown> | unknown[];
 /**
 * <blockquote style="margin: 1em; padding: .1em 1em .1em 1em; border-left: solid 1em #E34C32; background: #e0e0e0;">
@@ -113,11 +108,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
@@ -72,7 +72,6 @@ store.push(store.normalize(modelName, data));
 @param modelName The name of the model type for this payload
 @return The normalized payload
 */
-// TODO @runspired @deprecate users should call normalize on the associated serializer directly
 export declare function normalize(this: Store, modelName: string, payload: ObjectValue): SingleResourceDocument;
 /**
 Push some raw data into the store.
@@ -129,8 +128,6 @@ store.pushPayload('post', pushData); // Will use the post serializer
 @param {String} modelName Optionally, a model type used to determine which serializer will be used
 @param {Object} inputPayload
 */
-// TODO @runspired @deprecate pushPayload in favor of looking up the serializer
 export declare function pushPayload(this: Store, modelName: string, inputPayload: ObjectValue): void;
-// TODO @runspired @deprecate records should implement their own serialization if desired
 export declare function serializeRecord(this: Store, record: unknown, options?: SerializerOptions): unknown;
 export declare function cleanup(this: Store): void;