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

package/declarations/store/-private/store-service.d.ts

@@ -1,32 +1,30 @@
 import type { Graph } from "../../graph/-private.js";
 import type { Future } from "../../request.js";
-import type { RequestManager } from "../../request/-private/manager.js";
+import type { PrivateRequestManager, RequestManager } from "../../request/-private/manager.js";
 import type { Cache } from "../../types/cache.js";
-import type { StableExistingRecordIdentifier, StableRecordIdentifier } from "../../types/identifier.js";
+import type { PersistedResourceKey, ResourceKey } from "../../types/identifier.js";
 import type { TypedRecordInstance, TypeFromInstance } from "../../types/record.js";
 import type { CollectionResourceDocument, EmptyResourceDocument, JsonApiDocument, ResourceIdentifierObject, SingleResourceDocument } from "../../types/spec/json-api-raw.js";
 import type { Type } from "../../types/symbols.js";
 import type { CacheCapabilitiesManager } from "../-types/q/cache-capabilities-manager.js";
-import type { ModelSchema } from "../-types/q/ds-model.js";
 import type { OpaqueRecordInstance } from "../-types/q/record-instance.js";
 import type { SchemaService } from "../-types/q/schema-service.js";
-import type { FindAllOptions, FindRecordOptions, LegacyResourceQuery, QueryOptions } from "../-types/q/store.js";
 import type { StoreRequestInput } from "./cache-handler/handler.js";
 import type { CachePolicy } from "./cache-handler/types.js";
-import { IdentifierCache } from "./caches/identifier-cache.js";
 import { InstanceCache, storeFor } from "./caches/instance-cache.js";
-import type RecordReference from "./legacy-model-support/record-reference.js";
+import type { PrivateCacheKeyManager } from "./managers/cache-key-manager.js";
+import { CacheKeyManager } from "./managers/cache-key-manager.js";
+import type { PrivateNotificationManager } from "./managers/notification-manager.js";
 import NotificationManager from "./managers/notification-manager.js";
-import { RecordArrayManager } from "./managers/record-array-manager.js";
+import type { PrivateRecordArrayManager } from "./managers/record-array-manager.js";
+import type { PrivateRequestStateService } from "./network/request-cache.js";
 import { RequestStateService } from "./network/request-cache.js";
-import type { Collection, IdentifierArray } from "./record-arrays/identifier-array.js";
+import type { LegacyLiveArray } from "./record-arrays/legacy-live-array.js";
 export { storeFor };
-// We inline this list of methods to avoid importing EmberObject
 type EmberObjectKey = "_debugContainerKey" | "_super" | "addObserver" | "cacheFor" | "concatenatedProperties" | "decrementProperty" | "destroy" | "get" | "getProperties" | "incrementProperty" | "init" | "isDestroyed" | "isDestroying" | "mergedProperties" | "notifyPropertyChange" | "removeObserver" | "reopen" | "set" | "setProperties" | "toggleProperty" | "toString" | "willDestroy";
 type DSModelKeys = "___(unique) Symbol(Store)" | "___private_notifications" | "___recordState" | "_createSnapshot" | "adapterError" | "attr" | "belongsTo" | "changedAttributes" | "currentState" | "deleteRecord" | "destroyRecord" | "dirtyType" | "eachAttribute" | "eachRelationship" | "errors" | "hasDirtyAttributes" | "hasMany" | "inverseFor" | "isDeleted" | "isEmpty" | "isError" | "isLoaded" | "isLoading" | "isNew" | "isReloading" | "isSaving" | "isValid" | "relationshipFor" | "reload" | "rollbackAttributes" | "save" | "serialize" | "store" | "unloadRecord";
 type DownlevelArrays<T> = T extends Array<infer U> ? U[] : T;
 type AwaitedKeys<T> = { [K in keyof T & string] : DownlevelArrays<Awaited<T[K]>> };
-// `AwaitedKeys` is needed here to resolve any promise types like `PromiseBelongsTo`.
 type FilteredKeys<T> = AwaitedKeys<Omit<T, typeof Type | EmberObjectKey | DSModelKeys | "constructor">>;
 type MaybeHasId = {
 	id?: string | null;
@@ -48,12 +46,22 @@ type MaybeHasId = {
 *
 */
 export type CreateRecordProperties<T = MaybeHasId & Record<string, unknown>> = T extends TypedRecordInstance ? Partial<FilteredKeys<T>> : T extends MaybeHasId ? MaybeHasId & Partial<FilteredKeys<T>> : MaybeHasId & Record<string, unknown>;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export interface CreateContext {
+	lid?: string;
+}
 type ConstructorFunction = new (...args: any[]) => any;
-// eslint-disable-next-line @typescript-eslint/no-extraneous-class
 declare const EmptyClass: ConstructorFunction;
 declare const BaseClass: typeof EmptyClass;
 export interface Store {
+	/**
+	* Instantiation hook allowing applications or addons to configure the store
+	* to utilize a custom Cache implementation.
+	*
+	* This hook should not be called directly by consuming applications or libraries.
+	* Use `Store.cache` to access the Cache instance.
+	*
+	* @public
+	*/
 	createCache(capabilities: CacheCapabilitiesManager): Cache;
 	/**
 	* A hook which an app or addon may implement. Called when
@@ -69,8 +77,7 @@ export interface Store {
 	* @return A record instance
 	* @public
 	*/
-	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	instantiateRecord<T>(identifier: StableRecordIdentifier, createRecordArgs: {
+	instantiateRecord<T>(identifier: ResourceKey, createRecordArgs: {
 		[key: string]: unknown;
 	}): OpaqueRecordInstance;
 	/**
@@ -138,7 +145,6 @@ export interface Store {
 	* be sourced from directly registered schemas, then will fallback
 	* to sourcing a schema from available models if no schema is found.
 	*
-	* @return {SchemaService}
 	* @public
 	*/
 	createSchemaService(): SchemaService;
@@ -184,11 +190,11 @@ export interface Store {
 	*     return this._schema.hasResource(resource);
 	*   }
 	*
-	*   attributesDefinitionFor(identifier: RecordIdentifier | { type: string }): AttributesSchema {
+	*   attributesDefinitionFor(identifier: ResourceKey | { type: string }): AttributesSchema {
 	*     return this._schema.attributesDefinitionFor(identifier);
 	*   }
 	*
-	*   relationshipsDefinitionFor(identifier: RecordIdentifier | { type: string }): RelationshipsSchema {
+	*   relationshipsDefinitionFor(identifier: ResourceKey | { type: string }): RelationshipsSchema {
 	*     const schema = AbstractSchemas.get(identifier.type);
 	*     return schema || this._schema.relationshipsDefinitionFor(identifier);
 	*   }
@@ -238,11 +244,11 @@ export interface Store {
 	*     return this._schema.hasResource(resource);
 	*   }
 	*
-	*   attributesDefinitionFor(identifier: RecordIdentifier | { type: string }): AttributesSchema {
+	*   attributesDefinitionFor(identifier: ResourceKey | { type: string }): AttributesSchema {
 	*     return this._schema.attributesDefinitionFor(identifier);
 	*   }
 	*
-	*   relationshipsDefinitionFor(identifier: RecordIdentifier | { type: string }): RelationshipsSchema {
+	*   relationshipsDefinitionFor(identifier: ResourceKey | { type: string }): RelationshipsSchema {
 	*     const schema = AbstractSchemas.get(identifier.type);
 	*     return schema || this._schema.relationshipsDefinitionFor(identifier);
 	*   }
@@ -283,8 +289,6 @@ export interface Store {
 * @hideconstructor
 */
 export declare class Store extends BaseClass {
-	/** @internal */
-	readonly recordArrayManager: RecordArrayManager;
 	/**
 	* Provides access to the NotificationManager associated
 	* with this Store instance.
@@ -305,18 +309,17 @@ export declare class Store extends BaseClass {
 	* @public
 	*/
 	get schema(): ReturnType<this["createSchemaService"]>;
-	/** @internal */
-	_schema: SchemaService;
 	/**
-	* Provides access to the IdentifierCache instance
+	* Provides access to the CacheKeyManager
 	* for this store.
 	*
-	* The IdentifierCache can be used to generate or
-	* retrieve a stable unique identifier for any resource.
+	* The CacheKeyManager can be used to generate or
+	* retrieve a stable unique CacheKey for any resource
+	* or request.
 	*
 	* @public
 	*/
-	readonly identifierCache: IdentifierCache;
+	readonly cacheKeyManager: CacheKeyManager;
 	/**
 	* Provides access to the requestManager instance associated
 	* with this Store instance.
@@ -347,7 +350,7 @@ export declare class Store extends BaseClass {
 	*
 	* Note, when defined, these methods will only be invoked if a
 	* cache key exists for the request, either because the request
-	* contains `cacheOptions.key` or because the [IdentifierCache](/ember-data/release/classes/IdentifierCache)
+	* contains `cacheOptions.key` or because the [CacheKeyManager](/ember-data/release/classes/CacheKeyManager)
 	* was able to generate a key for the request using the configured
 	* [generation method](/ember-data/release/functions/@ember-data%2Fstore/setIdentifierGenerationMethod).
 	*
@@ -356,12 +359,12 @@ export declare class Store extends BaseClass {
 	* ```ts
 	* store.lifetimes = {
 	*   // make the request and ignore the current cache state
-	*   isHardExpired(identifier: StableDocumentIdentifier): boolean {
+	*   isHardExpired(key: RequestKey): boolean {
 	*     return false;
 	*   }
 	*
 	*   // make the request in the background if true, return cache state
-	*   isSoftExpired(identifier: StableDocumentIdentifier): boolean {
+	*   isSoftExpired(key: RequestKey): boolean {
 	*     return false;
 	*   }
 	* }
@@ -370,65 +373,16 @@ export declare class Store extends BaseClass {
 	* @public
 	*/
 	lifetimes?: CachePolicy;
-	// Private
-	/** @internal */
-	_graph?: Graph;
-	/** @internal */
-	_requestCache: RequestStateService;
-	/** @internal */
-	_instanceCache: InstanceCache;
-	/** @internal */
-	_cbs: {
-		coalesce?: () => void;
-		sync?: () => void;
-		notify?: () => void;
-	} | null;
-	/** @internal */
-	_forceShim: boolean;
-	/**
-	* Async flush buffers notifications until flushed
-	* by finalization of a future configured by store.request
-	*
-	* This is useful for ensuring that notifications are delivered
-	* prior to the promise resolving but without risk of promise
-	* interleaving.
-	*
-	* @internal
-	*/
-	_enableAsyncFlush: boolean | null;
-	// DEBUG-only properties
-	/** @internal */
-	DISABLE_WAITER?: boolean;
-	/** @internal */
-	_isDestroying: boolean;
-	/** @internal */
-	_isDestroyed: boolean;
-	/** @internal */
+	/** @private */
 	get isDestroying(): boolean;
-	/** @internal */
-	set isDestroying(value: boolean);
-	/** @internal */
+	/** @private */
 	get isDestroyed(): boolean;
-	/** @internal */
-	set isDestroyed(value: boolean);
+	/** @deprecated use {@link Store.cacheKeyManager} */
+	get identifierCache(): CacheKeyManager;
 	/**
 	@private
 	*/
 	constructor(createArgs?: unknown);
-	/** @internal */
-	_run(cb: () => void): void;
-	/**
-	* Executes the callback, ensurng that any work that calls
-	* store._schedule is executed after in the right order.
-	*
-	* When queues already exist, scheduled callbacks will
-	* join the existing queue.
-	*
-	* @internal
-	*/
-	_join(cb: () => void): void;
-	/** @internal */
-	_schedule(name: "coalesce" | "sync" | "notify", cb: () => void): void;
 	/**
 	* Retrieve the RequestStateService instance
 	* associated with this Store.
@@ -440,10 +394,6 @@ export declare class Store extends BaseClass {
 	* @public
 	*/
 	getRequestStateService(): RequestStateService;
-	/** @internal */
-	_getAllPending(): (Promise<unknown[]> & {
-		length: number;
-	}) | void;
 	/**
 	* ::: tip 💡 For a more complete overview see the [Request Guide](/guides/2-requests/1-overview)
 	* :::
@@ -458,7 +408,7 @@ export declare class Store extends BaseClass {
 	* {@link CacheOptions.key | cache key} will have the request result
 	* and document cached.
 	*
-	* The cache key used is {@link RequestInfo.cacheOptions | RequestInfo.cacheOptions.key}
+	* The cache key used is {@link RequestInfo.cacheOptions.key | RequestInfo.cacheOptions.key}
 	* if present, falling back to {@link RequestInfo.url}.
 	*
 	* Params are not serialized as part of the cache-key, so
@@ -497,64 +447,77 @@ export declare class Store extends BaseClass {
 	*
 	* @public
 	*/
-	request<
-		RT,
-		T = unknown
-	>(requestConfig: StoreRequestInput<RT, T>): Future<RT>;
+	request<RT>(requestConfig: StoreRequestInput<RT>): Future<RT>;
 	/**
-	Returns the schema for a particular resource type (modelName).
+	Creates a new record in the current store.
 	
-	When used with Model from @ember-data/model the return is the model class,
-	but this is not guaranteed.
+	> [!CAUTION]
+	> This should not be used to mock records or to create
+	> a record representing data that could be fetched from
+	> the API.
 	
-	If looking to query attribute or relationship information it is
-	recommended to use `getSchemaDefinitionService` instead. This method
-	should be considered legacy and exists primarily to continue to support
-	Adapter/Serializer APIs which expect it's return value in their method
-	signatures.
-	
-	The class of a model might be useful if you want to get a list of all the
-	relationship names of the model, see
-	[`relationshipNames`](/ember-data/release/classes/Model?anchor=relationshipNames)
-	for example.
-	
-	@public
-	@deprecated
-	@param {String} type
-	@return {ModelSchema}
-	*/
-	modelFor<T>(type: TypeFromInstance<T>): ModelSchema<T>;
-	modelFor(type: string): ModelSchema;
-	/**
-	Create a new record in the current store. The properties passed
-	to this method are set on the newly created record.
+	The properties passed to this method are set on
+	the newly created record.
 	
-	To create a new instance of a `Post`:
+	For instance: to create a new `post`:
 	
 	```js
 	store.createRecord('post', {
-	title: 'Ember is awesome!'
+	title: 'WarpDrive is Stellar!'
 	});
 	```
 	
-	To create a new instance of a `Post` that has a relationship with a `User` record:
+	Relationships can be set during create. For instance,
+	to create a new `post` that has an existing user as
+	it's author:
 	
 	```js
-	let user = this.store.peekRecord('user', '1');
+	const user = store.peekRecord('user', '1');
+	
 	store.createRecord('post', {
-	title: 'Ember is awesome!',
+	title: 'WarpDrive is Stellar!',
 	user: user
 	});
 	```
 	
+	### lid handling
+	
+	All new records are assigned an `lid` that can be used to handle
+	transactional saves of multiple records, or to link the data to
+	other data in scenarios involving eventual-consistency or remote
+	syncing.
+	
+	```ts
+	const post = store.createRecord('post', {
+	title: 'WarpDrive is Stellar!'
+	});
+	const { lid } = recordIdentifierFor(post);
+	```
+	
+	The `lid` defaults to a uuidv4 string.
+	
+	In order to support receiving knowledge about unpersisted creates
+	from other sources (say a different tab in the same web-browser),
+	createRecord allows for the `lid` to be provided as part of an
+	optional third argument. **If this lid already exists in the store
+	an error will be thrown.**
+	
+	```ts
+	const post = store.createRecord(
+	'post',
+	{ title: 'WarpDrive is Stellar!' },
+	{ lid: '4d47bb88-931f-496e-986d-c4888cef7373' }
+	);
+	```
+	
 	@public
-	@param {String} type the name of the resource
-	@param {Object} inputProperties a hash of properties to set on the
+	@param type the name of the resource
+	@param inputProperties a hash of properties to set on the
 	newly created record.
-	@return {Model} record
+	@return a record in the "isNew" state
 	*/
-	createRecord<T>(type: TypeFromInstance<T>, inputProperties: CreateRecordProperties<T>): T;
-	createRecord(type: string, inputProperties: CreateRecordProperties): OpaqueRecordInstance;
+	createRecord<T>(type: TypeFromInstance<T>, inputProperties: CreateRecordProperties<T>, context?: CreateContext): T;
+	createRecord(type: string, inputProperties: CreateRecordProperties, context?: CreateContext): OpaqueRecordInstance;
 	/**
 	For symmetry, a record can be deleted via the store.
 	
@@ -588,401 +551,6 @@ export declare class Store extends BaseClass {
 	*/
 	unloadRecord<T>(record: T): void;
 	/**
-	This method returns a record for a given identifier or type and id combination.
-	
-	The `findRecord` method will always resolve its promise with the same
-	object for a given identifier or type and `id`.
-	
-	The `findRecord` method will always return a **promise** that will be
-	resolved with the record.
-	
-	**Example 1**
-	
-	```js [app/routes/post.js]
-	export default class PostRoute extends Route {
-	model({ post_id }) {
-	return this.store.findRecord('post', post_id);
-	}
-	}
-	```
-	
-	**Example 2**
-	
-	`findRecord` can be called with a single identifier argument instead of the combination
-	of `type` (modelName) and `id` as separate arguments. You may recognize this combo as
-	the typical pairing from [JSON:API](https://jsonapi.org/format/#document-resource-object-identification)
-	
-	```js [app/routes/post.js]
-	export default class PostRoute extends Route {
-	model({ post_id: id }) {
-	return this.store.findRecord({ type: 'post', id });
-	}
-	}
-	```
-	
-	**Example 3**
-	
-	If you have previously received an lid via an Identifier for this record, and the record
-	has already been assigned an id, you can find the record again using just the lid.
-	
-	```js [app/routes/post.js]
-	store.findRecord({ lid });
-	```
-	
-	If the record is not yet available, the store will ask the adapter's `findRecord`
-	method to retrieve and supply the necessary data. If the record is already present
-	in the store, it depends on the reload behavior _when_ the returned promise
-	resolves.
-	
-	### Preloading
-	
-	You can optionally `preload` specific attributes and relationships that you know of
-	by passing them via the passed `options`.
-	
-	For example, if your Ember route looks like `/posts/1/comments/2` and your API route
-	for the comment also looks like `/posts/1/comments/2` if you want to fetch the comment
-	without also fetching the post you can pass in the post to the `findRecord` call:
-	
-	```js [app/routes/post-comments.js]
-	export default class PostRoute extends Route {
-	model({ post_id, comment_id: id }) {
-	return this.store.findRecord({ type: 'comment', id, { preload: { post: post_id }} });
-	}
-	}
-	```
-	
-	In your adapter you can then access this id without triggering a network request via the
-	snapshot:
-	
-	```js [app/adapters/application.js]
-	export default class Adapter {
-	
-	findRecord(store, schema, id, snapshot) {
-	let type = schema.modelName;
-	
-	if (type === 'comment')
-	let postId = snapshot.belongsTo('post', { id: true });
-	
-	return fetch(`./posts/${postId}/comments/${id}`)
-	.then(response => response.json())
-	}
-	}
-	
-	static create() {
-	return new this();
-	}
-	}
-	```
-	
-	This could also be achieved by supplying the post id to the adapter via the adapterOptions
-	property on the options hash.
-	
-	```js [app/routes/post-comments.js]
-	export default class PostRoute extends Route {
-	model({ post_id, comment_id: id }) {
-	return this.store.findRecord({ type: 'comment', id, { adapterOptions: { post: post_id }} });
-	}
-	}
-	```
-	
-	```js [app/adapters/application.js]
-	export default class Adapter {
-	findRecord(store, schema, id, snapshot) {
-	let type = schema.modelName;
-	
-	if (type === 'comment')
-	let postId = snapshot.adapterOptions.post;
-	
-	return fetch(`./posts/${postId}/comments/${id}`)
-	.then(response => response.json())
-	}
-	}
-	
-	static create() {
-	return new this();
-	}
-	}
-	```
-	
-	If you have access to the post model you can also pass the model itself to preload:
-	
-	```javascript
-	let post = await store.findRecord('post', '1');
-	let comment = await store.findRecord('comment', '2', { post: myPostModel });
-	```
-	
-	### Reloading
-	
-	The reload behavior is configured either via the passed `options` hash or
-	the result of the adapter's `shouldReloadRecord`.
-	
-	If `{ reload: true }` is passed or `adapter.shouldReloadRecord` evaluates
-	to `true`, then the returned promise resolves once the adapter returns
-	data, regardless if the requested record is already in the store:
-	
-	```js
-	store.push({
-	data: {
-	id: 1,
-	type: 'post',
-	revision: 1
-	}
-	});
-	
-	// adapter#findRecord resolves with
-	// [
-	//   {
-	//     id: 1,
-	//     type: 'post',
-	//     revision: 2
-	//   }
-	// ]
-	store.findRecord('post', '1', { reload: true }).then(function(post) {
-	post.revision; // 2
-	});
-	```
-	
-	If no reload is indicated via the above mentioned ways, then the promise
-	immediately resolves with the cached version in the store.
-	
-	### Background Reloading
-	
-	Optionally, if `adapter.shouldBackgroundReloadRecord` evaluates to `true`,
-	then a background reload is started, which updates the records' data, once
-	it is available:
-	
-	```js
-	// app/adapters/post.js
-	import ApplicationAdapter from "./application";
-	
-	export default class PostAdapter extends ApplicationAdapter {
-	shouldReloadRecord(store, snapshot) {
-	return false;
-	},
-	
-	shouldBackgroundReloadRecord(store, snapshot) {
-	return true;
-	}
-	});
-	
-	// ...
-	
-	store.push({
-	data: {
-	id: 1,
-	type: 'post',
-	revision: 1
-	}
-	});
-	
-	let blogPost = store.findRecord('post', '1').then(function(post) {
-	post.revision; // 1
-	});
-	
-	// later, once adapter#findRecord resolved with
-	// [
-	//   {
-	//     id: 1,
-	//     type: 'post',
-	//     revision: 2
-	//   }
-	// ]
-	
-	blogPost.revision; // 2
-	```
-	
-	If you would like to force or prevent background reloading, you can set a
-	boolean value for `backgroundReload` in the options object for
-	`findRecord`.
-	
-	```js [app/routes/post/edit.js]
-	export default class PostEditRoute extends Route {
-	model(params) {
-	return this.store.findRecord('post', params.post_id, { backgroundReload: false });
-	}
-	}
-	```
-	
-	If you pass an object on the `adapterOptions` property of the options
-	argument it will be passed to your adapter via the snapshot
-	
-	```js [app/routes/post/edit.js]
-	export default class PostEditRoute extends Route {
-	model(params) {
-	return this.store.findRecord('post', params.post_id, {
-	adapterOptions: { subscribe: false }
-	});
-	}
-	}
-	```
-	
-	```js [app/adapters/post.js]
-	import MyCustomAdapter from './custom-adapter';
-	
-	export default class PostAdapter extends MyCustomAdapter {
-	findRecord(store, type, id, snapshot) {
-	if (snapshot.adapterOptions.subscribe) {
-	// ...
-	}
-	// ...
-	}
-	}
-	```
-	
-	See [peekRecord](../methods/peekRecord?anchor=peekRecord) to get the cached version of a record.
-	
-	### Retrieving Related Model Records
-	
-	If you use an adapter such as Ember's default
-	[`JSONAPIAdapter`](/ember-data/release/classes/JSONAPIAdapter)
-	that supports the [JSON API specification](http://jsonapi.org/) and if your server
-	endpoint supports the use of an
-	['include' query parameter](http://jsonapi.org/format/#fetching-includes),
-	you can use `findRecord()` or `findAll()` to automatically retrieve additional records related to
-	the one you request by supplying an `include` parameter in the `options` object.
-	
-	For example, given a `post` model that has a `hasMany` relationship with a `comment`
-	model, when we retrieve a specific post we can have the server also return that post's
-	comments in the same request:
-	
-	```js [app/routes/post.js]
-	export default class PostRoute extends Route {
-	model(params) {
-	return this.store.findRecord('post', params.post_id, { include: ['comments'] });
-	}
-	}
-	```
-	
-	```js [app/adapters/application.js]
-	export default class Adapter {
-	findRecord(store, schema, id, snapshot) {
-	let type = schema.modelName;
-	
-	if (type === 'post')
-	let includes = snapshot.adapterOptions.include;
-	
-	return fetch(`./posts/${postId}?include=${includes}`)
-	.then(response => response.json())
-	}
-	}
-	
-	static create() {
-	return new this();
-	}
-	}
-	```
-	
-	In this case, the post's comments would then be available in your template as
-	`model.comments`.
-	
-	Multiple relationships can be requested using an `include` parameter consisting of a
-	list of relationship names, while nested relationships can be specified
-	using a dot-separated sequence of relationship names. So to request both the post's
-	comments and the authors of those comments the request would look like this:
-	
-	```js [app/routes/post.js]
-	export default class PostRoute extends Route {
-	model(params) {
-	return this.store.findRecord('post', params.post_id, { include: ['comments','comments.author'] });
-	}
-	}
-	```
-	
-	### Retrieving Specific Fields by Type
-	
-	If your server endpoint supports the use of a ['fields' query parameter](https://jsonapi.org/format/#fetching-sparse-fieldsets),
-	you can use pass those fields through to your server.  At this point in time, this requires a few manual steps on your part.
-	
-	1. Implement `buildQuery` in your adapter.
-	
-	```js [app/adapters/application.js]
-	buildQuery(snapshot) {
-	let query = super.buildQuery(...arguments);
-	
-	let { fields } = snapshot.adapterOptions;
-	
-	if (fields) {
-	query.fields = fields;
-	}
-	
-	return query;
-	}
-	```
-	
-	2. Then pass through the applicable fields to your `findRecord` request.
-	
-	Given a `post` model with attributes body, title, publishDate and meta, you can retrieve a filtered list of attributes.
-	
-	```js [app/routes/post.js]
-	export default class extends Route {
-	model(params) {
-	return this.store.findRecord('post', params.post_id, { adapterOptions: { fields: { post: 'body,title' } });
-	}
-	}
-	```
-	
-	Moreover, you can filter attributes on related models as well. If a `post` has a `belongsTo` relationship to a user,
-	just include the relationship key and attributes.
-	
-	```js [app/routes/post.js]
-	export default class extends Route {
-	model(params) {
-	return this.store.findRecord('post', params.post_id, { adapterOptions: { fields: { post: 'body,title', user: 'name,email' } });
-	}
-	}
-	```
-	
-	@since 1.13.0
-	@public
-	@param {String|object} type - either a string representing the name of the resource or a ResourceIdentifier object containing both the type (a string) and the id (a string) for the record or an lid (a string) of an existing record
-	@param {(String|Integer|Object)} id - optional object with options for the request only if the first param is a ResourceIdentifier, else the string id of the record to be retrieved
-	@param {Object} [options] - if the first param is a string this will be the optional options for the request. See examples for available options.
-	@return {Promise} promise
-	*/
-	findRecord<T>(type: TypeFromInstance<T>, id: string | number, options?: FindRecordOptions<T>): Promise<T>;
-	findRecord(type: string, id: string | number, options?: FindRecordOptions): Promise<unknown>;
-	findRecord<T>(resource: ResourceIdentifierObject<TypeFromInstance<T>>, options?: FindRecordOptions<T>): Promise<T>;
-	findRecord(resource: ResourceIdentifierObject, options?: FindRecordOptions): Promise<unknown>;
-	/**
-	Get the reference for the specified record.
-	
-	Example
-	
-	```javascript
-	let userRef = store.getReference('user', '1');
-	
-	// check if the user is loaded
-	let isLoaded = userRef.value() !== null;
-	
-	// get the record of the reference (null if not yet available)
-	let user = userRef.value();
-	
-	// get the identifier of the reference
-	if (userRef.remoteType() === 'id') {
-	let id = userRef.id();
-	}
-	
-	// load user (via store.find)
-	userRef.load().then(...)
-	
-	// or trigger a reload
-	userRef.reload().then(...)
-	
-	// provide data for reference
-	userRef.push({ id: 1, username: '@user' }).then(function(user) {
-	userRef.value() === user;
-	});
-	```
-	
-	@public
-	@param {String|object} resource - modelName (string) or Identifier (object)
-	@param {String|Integer} id
-	@since 2.5.0
-	@return {RecordReference}
-	*/
-	// TODO @deprecate getReference (and references generally)
-	getReference(resource: string | ResourceIdentifierObject, id: string | number): RecordReference;
-	/**
 	Get a record by a given type and ID without triggering a fetch.
 	
 	This method will synchronously return the record if it is available in the store,
@@ -1034,336 +602,6 @@ export declare class Store extends BaseClass {
 	peekRecord<T>(identifier: ResourceIdentifierObject<TypeFromInstance<T>>): T | null;
 	peekRecord(identifier: ResourceIdentifierObject): unknown | null;
 	/**
-	This method delegates a query to the adapter. This is the one place where
-	adapter-level semantics are exposed to the application.
-	
-	Each time this method is called a new request is made through the adapter.
-	
-	Exposing queries this way seems preferable to creating an abstract query
-	language for all server-side queries, and then require all adapters to
-	implement them.
-	
-	---
-	
-	If you do something like this:
-	
-	```javascript
-	store.query('person', { page: 1 });
-	```
-	
-	The request made to the server will look something like this:
-	
-	```
-	GET "/api/v1/person?page=1"
-	```
-	
-	---
-	
-	If you do something like this:
-	
-	```javascript
-	store.query('person', { ids: ['1', '2', '3'] });
-	```
-	
-	The request made to the server will look something like this:
-	
-	```
-	GET "/api/v1/person?ids%5B%5D=1&ids%5B%5D=2&ids%5B%5D=3"
-	decoded: "/api/v1/person?ids[]=1&ids[]=2&ids[]=3"
-	```
-	
-	This method returns a promise, which is resolved with a
-	[`Collection`](/ember-data/release/classes/Collection)
-	once the server returns.
-	
-	@since 1.13.0
-	@public
-	@param {String} type the name of the resource
-	@param {Object} query a query to be used by the adapter
-	@param {Object} options optional, may include `adapterOptions` hash which will be passed to adapter.query
-	@return {Promise} promise
-	*/
-	query<T>(type: TypeFromInstance<T>, query: LegacyResourceQuery<T>, options?: QueryOptions): Promise<Collection<T>>;
-	query(type: string, query: LegacyResourceQuery, options?: QueryOptions): Promise<Collection>;
-	/**
-	This method makes a request for one record, where the `id` is not known
-	beforehand (if the `id` is known, use [`findRecord`](../methods/findRecord?anchor=findRecord)
-	instead).
-	
-	This method can be used when it is certain that the server will return a
-	single object for the primary data.
-	
-	Each time this method is called a new request is made through the adapter.
-	
-	Let's assume our API provides an endpoint for the currently logged in user
-	via:
-	
-	```
-	// GET /api/current_user
-	{
-	user: {
-	id: 1234,
-	username: 'admin'
-	}
-	}
-	```
-	
-	Since the specific `id` of the `user` is not known beforehand, we can use
-	`queryRecord` to get the user:
-	
-	```javascript
-	store.queryRecord('user', {}).then(function(user) {
-	let username = user.username;
-	// do thing
-	});
-	```
-	
-	The request is made through the adapters' `queryRecord`:
-	
-	```js [app/adapters/user.js]
-	import Adapter from '@ember-data/adapter';
-	import $ from 'jquery';
-	
-	export default class UserAdapter extends Adapter {
-	queryRecord(modelName, query) {
-	return $.getJSON('/api/current_user');
-	}
-	}
-	```
-	
-	Note: the primary use case for `store.queryRecord` is when a single record
-	is queried and the `id` is not known beforehand. In all other cases
-	`store.query` and using the first item of the array is likely the preferred
-	way:
-	
-	```
-	// GET /users?username=unique
-	{
-	data: [{
-	id: 1234,
-	type: 'user',
-	attributes: {
-	username: "unique"
-	}
-	}]
-	}
-	```
-	
-	```javascript
-	store.query('user', { username: 'unique' }).then(function(users) {
-	return users.firstObject;
-	}).then(function(user) {
-	let id = user.id;
-	});
-	```
-	
-	This method returns a promise, which resolves with the found record.
-	
-	If the adapter returns no data for the primary data of the payload, then
-	`queryRecord` resolves with `null`:
-	
-	```
-	// GET /users?username=unique
-	{
-	data: null
-	}
-	```
-	
-	```javascript
-	store.queryRecord('user', { username: 'unique' }).then(function(user) {
-	// user is null
-	});
-	```
-	
-	@since 1.13.0
-	@public
-	@param {String} type
-	@param {Object} query an opaque query to be used by the adapter
-	@param {Object} options optional, may include `adapterOptions` hash which will be passed to adapter.queryRecord
-	@return {Promise} promise which resolves with the found record or `null`
-	*/
-	queryRecord<T>(type: TypeFromInstance<T>, query: LegacyResourceQuery<T>, options?: QueryOptions): Promise<T | null>;
-	queryRecord(type: string, query: LegacyResourceQuery, options?: QueryOptions): Promise<unknown | null>;
-	/**
-	`findAll` asks the adapter's `findAll` method to find the records for the
-	given type, and returns a promise which will resolve with all records of
-	this type present in the store, even if the adapter only returns a subset
-	of them.
-	
-	```js [app/routes/authors.js]
-	export default class AuthorsRoute extends Route {
-	model(params) {
-	return this.store.findAll('author');
-	}
-	}
-	```
-	
-	_When_ the returned promise resolves depends on the reload behavior,
-	configured via the passed `options` hash and the result of the adapter's
-	`shouldReloadAll` method.
-	
-	### Reloading
-	
-	If `{ reload: true }` is passed or `adapter.shouldReloadAll` evaluates to
-	`true`, then the returned promise resolves once the adapter returns data,
-	regardless if there are already records in the store:
-	
-	```js
-	store.push({
-	data: {
-	id: 'first',
-	type: 'author'
-	}
-	});
-	
-	// adapter#findAll resolves with
-	// [
-	//   {
-	//     id: 'second',
-	//     type: 'author'
-	//   }
-	// ]
-	store.findAll('author', { reload: true }).then(function(authors) {
-	authors.getEach('id'); // ['first', 'second']
-	});
-	```
-	
-	If no reload is indicated via the above mentioned ways, then the promise
-	immediately resolves with all the records currently loaded in the store.
-	
-	### Background Reloading
-	
-	Optionally, if `adapter.shouldBackgroundReloadAll` evaluates to `true`,
-	then a background reload is started. Once this resolves, the array with
-	which the promise resolves, is updated automatically so it contains all the
-	records in the store:
-	
-	```js [app/adapters/application.js]
-	import Adapter from '@ember-data/adapter';
-	
-	export default class ApplicationAdapter extends Adapter {
-	shouldReloadAll(store, snapshotsArray) {
-	return false;
-	},
-	
-	shouldBackgroundReloadAll(store, snapshotsArray) {
-	return true;
-	}
-	});
-	
-	// ...
-	
-	store.push({
-	data: {
-	id: 'first',
-	type: 'author'
-	}
-	});
-	
-	let allAuthors;
-	store.findAll('author').then(function(authors) {
-	authors.getEach('id'); // ['first']
-	
-	allAuthors = authors;
-	});
-	
-	// later, once adapter#findAll resolved with
-	// [
-	//   {
-	//     id: 'second',
-	//     type: 'author'
-	//   }
-	// ]
-	
-	allAuthors.getEach('id'); // ['first', 'second']
-	```
-	
-	If you would like to force or prevent background reloading, you can set a
-	boolean value for `backgroundReload` in the options object for
-	`findAll`.
-	
-	```js [app/routes/post/edit.js]
-	export default class PostEditRoute extends Route {
-	model() {
-	return this.store.findAll('post', { backgroundReload: false });
-	}
-	}
-	```
-	
-	If you pass an object on the `adapterOptions` property of the options
-	argument it will be passed to you adapter via the `snapshotRecordArray`
-	
-	```js [app/routes/posts.js]
-	export default class PostsRoute extends Route {
-	model(params) {
-	return this.store.findAll('post', {
-	adapterOptions: { subscribe: false }
-	});
-	}
-	}
-	```
-	
-	```js [app/adapters/post.js]
-	import MyCustomAdapter from './custom-adapter';
-	
-	export default class UserAdapter extends MyCustomAdapter {
-	findAll(store, type, sinceToken, snapshotRecordArray) {
-	if (snapshotRecordArray.adapterOptions.subscribe) {
-	// ...
-	}
-	// ...
-	}
-	}
-	```
-	
-	See [peekAll](../methods/peekAll?anchor=peekAll) to get an array of current records in the
-	store, without waiting until a reload is finished.
-	
-	### Retrieving Related Model Records
-	
-	If you use an adapter such as Ember's default
-	[`JSONAPIAdapter`](/ember-data/release/classes/JSONAPIAdapter)
-	that supports the [JSON API specification](http://jsonapi.org/) and if your server
-	endpoint supports the use of an
-	['include' query parameter](http://jsonapi.org/format/#fetching-includes),
-	you can use `findAll()` to automatically retrieve additional records related to
-	those requested by supplying an `include` parameter in the `options` object.
-	
-	For example, given a `post` model that has a `hasMany` relationship with a `comment`
-	model, when we retrieve all of the post records we can have the server also return
-	all of the posts' comments in the same request:
-	
-	```js [app/routes/posts.js]
-	export default class PostsRoute extends Route {
-	model() {
-	return this.store.findAll('post', { include: ['comments'] });
-	}
-	}
-	```
-	Multiple relationships can be requested using an `include` parameter consisting of a
-	list or relationship names, while nested relationships can be specified
-	using a dot-separated sequence of relationship names. So to request both the posts'
-	comments and the authors of those comments the request would look like this:
-	
-	```js [app/routes/posts.js]
-	export default class PostsRoute extends Route {
-	model() {
-	return this.store.findAll('post', { include: ['comments','comments.author'] });
-	}
-	}
-	```
-	
-	See [query](../methods/query?anchor=query) to only get a subset of records from the server.
-	
-	@since 1.13.0
-	@public
-	@param {String} type the name of the resource
-	@param {Object} options
-	@return {Promise} promise
-	*/
-	findAll<T>(type: TypeFromInstance<T>, options?: FindAllOptions<T>): Promise<IdentifierArray<T>>;
-	findAll(type: string, options?: FindAllOptions): Promise<IdentifierArray>;
-	/**
 	This method returns a filtered array that contains all of the
 	known records for a given type in the store.
 	
@@ -1387,8 +625,8 @@ export declare class Store extends BaseClass {
 	@param {String} type the name of the resource
 	@return {RecordArray}
 	*/
-	peekAll<T>(type: TypeFromInstance<T>): IdentifierArray<T>;
-	peekAll(type: string): IdentifierArray;
+	peekAll<T>(type: TypeFromInstance<T>): LegacyLiveArray<T>;
+	peekAll(type: string): LegacyLiveArray;
 	/**
 	This method unloads all records in the store.
 	It schedules unloading to happen during the next run loop.
@@ -1566,40 +804,92 @@ export declare class Store extends BaseClass {
 	
 	@private
 	@param {Object} jsonApiDoc
-	@return {StableRecordIdentifier|Array<StableRecordIdentifier>|null} identifiers for the primary records that had data loaded
+	@return {ResourceKey|Array<ResourceKey>|null} identifiers for the primary records that had data loaded
 	*/
-	_push(jsonApiDoc: JsonApiDocument, asyncFlush?: boolean): StableExistingRecordIdentifier | StableExistingRecordIdentifier[] | null;
+	_push(jsonApiDoc: JsonApiDocument, asyncFlush?: boolean): PersistedResourceKey | PersistedResourceKey[] | null;
 	/**
-	* Trigger a save for a Record.
-	*
-	* Returns a promise resolving with the same record when the save is complete.
+	* Returns the cache instance associated to this Store, instantiates the Cache
+	* if necessary via `Store.createCache`
 	*
 	* @public
-	* @param {unknown} record
-	* @param options
-	* @return {Promise<record>}
 	*/
-	saveRecord<T>(record: T, options?: Record<string, unknown>): Promise<T>;
+	get cache(): ReturnType<this["createCache"]>;
+	/** @private */
+	destroy(): void;
 	/**
-	* Instantiation hook allowing applications or addons to configure the store
-	* to utilize a custom Cache implementation.
+	* This method
 	*
-	* This hook should not be called directly by consuming applications or libraries.
-	* Use `Store.cache` to access the Cache instance.
+	* @private
+	*/
+	static create(args?: Record<string, unknown>): Store;
+}
+/**
+* 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 PrivateStore extends Store {
+	readonly recordArrayManager: PrivateRecordArrayManager;
+	notifications: PrivateNotificationManager;
+	requestManager: PrivateRequestManager;
+	cacheKeyManager: PrivateCacheKeyManager;
+	_schema: SchemaService;
+	_graph?: Graph;
+	_requestCache: PrivateRequestStateService;
+	getRequestStateService(): PrivateRequestStateService;
+	_instanceCache: InstanceCache;
+	_cbs: {
+		coalesce?: () => void;
+		sync?: () => void;
+		notify?: () => void;
+	} | null;
+	_forceShim: boolean;
+	/**
+	* Async flush buffers notifications until flushed
+	* by finalization of a future configured by store.request
 	*
-	* @public
-	* @param storeWrapper
-	* @return {Cache}
+	* This is useful for ensuring that notifications are delivered
+	* prior to the promise resolving but without risk of promise
+	* interleaving.
 	*/
+	_enableAsyncFlush: boolean | null;
 	/**
-	* Returns the cache instance associated to this Store, instantiates the Cache
-	* if necessary via `Store.createCache`
+	* Available in DEBUG Only
+	*/
+	DISABLE_WAITER?: boolean;
+	_isDestroying: boolean;
+	_isDestroyed: boolean;
+	isDestroying: boolean;
+	isDestroyed: boolean;
+	_run(cb: () => void): void;
+	/**
+	* Executes the callback, ensurng that any work that calls
+	* store._schedule is executed after in the right order.
+	*
+	* When queues already exist, scheduled callbacks will
+	* join the existing queue.
 	*
-	* @property cache
-	* @type {Cache}
-	* @public
 	*/
-	get cache(): ReturnType<this["createCache"]>;
-	destroy(): void;
-	static create(args?: Record<string, unknown>): Store;
+	_join(cb: () => void): void;
+	_schedule(name: "coalesce" | "sync" | "notify", cb: () => void): void;
+	_getAllPending(): (Promise<unknown[]> & {
+		length: number;
+	}) | void;
 }
+/**
+* Upgrade the type for Store to PrivateStore, which will also
+* upgrade any associated types to their private equivalents.
+*
+* @private
+*/
+export declare function assertPrivateStore(store: unknown): asserts store is PrivateStore;
+/**
+* Upgrade the type for Store to PrivateStore, which will also
+* upgrade any associated types to their private equivalents.
+*
+* @private
+*/
+export declare function isPrivateStore(store: unknown): PrivateStore;
+export declare function isMaybeIdentifier(maybeIdentifier: string | ResourceIdentifierObject): maybeIdentifier is ResourceIdentifierObject;