@warp-drive/core 5.8.0-alpha.37 → 5.8.0-alpha.40

package/dist/unpkg/dev-deprecated/declarations/store/-private/store-service.d.ts

@@ -1,874 +0,0 @@
-import type { Graph } from "../../graph/-private.js";
-import type { Future } from "../../request.js";
-import type { PrivateRequestManager, RequestManager } from "../../request/-private/manager.js";
-import type { Cache } from "../../types/cache.js";
-import type { PersistedResourceKey, ResourceKey } from "../../types/identifier.js";
-import type { TypedRecordInstance, TypeFromInstance } from "../../types/record.js";
-import type { SchemaService } from "../../types/schema/schema-service.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 { OpaqueRecordInstance } from "../-types/q/record-instance.js";
-import type { StoreRequestInput } from "./cache-handler/handler.js";
-import type { CachePolicy } from "./cache-handler/types.js";
-import { InstanceCache, storeFor } from "./caches/instance-cache.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 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 { LegacyLiveArray } from "./record-arrays/legacy-live-array.js";
-export { storeFor };
-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]>> };
-type FilteredKeys<T> = AwaitedKeys<Omit<T, typeof Type | EmberObjectKey | DSModelKeys | "constructor">>;
-type MaybeHasId = {
-	id?: string | null;
-};
-/**
-* Currently only records that extend object can be created via
-* store.createRecord. This is a limitation of the current API,
-* but can be worked around by creating a new identifier, running
-* the cache.clientDidCreate method, and then peeking the record
-* for the identifier.
-*
-* To assign primary key to a record during creation, only `id` will
-* work correctly for `store.createRecord`, other primary key may be
-* handled by updating the record after creation or using the flow
-* described above.
-*
-* TODO: These are limitations we want to (and can) address. If you
-* have need of lifting these limitations, please open an issue.
-*
-*/
-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>;
-export interface CreateContext {
-	lid?: string;
-}
-type ConstructorFunction = new (...args: any[]) => any;
-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
-	* the Store is attempting to create a Record Instance for
-	* a resource.
-	*
-	* This hook can be used to select or instantiate any desired
-	* mechanism of presenting cache data to the ui for access
-	* mutation, and interaction.
-	*
-	* @param identifier - The Resource CacheKey
-	* @param createRecordArgs - An object containing any properties passed to `store.createRecord`
-	* @return A record instance
-	* @public
-	*/
-	instantiateRecord<T>(identifier: ResourceKey, createRecordArgs: {
-		[key: string]: unknown;
-	}): OpaqueRecordInstance;
-	/**
-	* A hook which an app or addon may implement. Called when
-	* the Store is destroying a Record Instance. This hook should
-	* be used to teardown any custom record instances instantiated
-	* with `instantiateRecord`.
-	*
-	* @public
-	* @param record
-	*/
-	teardownRecord(record: OpaqueRecordInstance): void;
-	/**
-	* This hook enables an app to supply a SchemaService
-	* for use when information about a resource's schema needs
-	* to be queried.
-	*
-	* This method will only be called once to instantiate the singleton
-	* service, which can then be accessed via `store.schema`.
-	*
-	* For Example, to use the default SchemaService for ReactiveResource
-	*
-	* ```ts
-	* import { SchemaService } from '@warp-drive/core/reactive';
-	*
-	* class extends Store {
-	*   createSchemaService() {
-	*     return new SchemaService();
-	*   }
-	* }
-	* ```
-	*
-	* Or to use the SchemaService for @warp-drive/legacy/model
-	*
-	* ```ts
-	* import { buildSchema } from '@warp-drive/legacy/model';
-	*
-	* class extends Store {
-	*   createSchemaService() {
-	*     return buildSchema(this);
-	*   }
-	* }
-	* ```
-	*
-	* If you wish to chain services, you must either
-	* instantiate each schema source directly or super to retrieve
-	* an existing service. For convenience, when migrating from
-	* `@warp-drive/legacy/model` to {@link ReactiveResource} a
-	* SchemaService is provided that handles this transition
-	* for you:
-	*
-	* ```ts
-	* import { DelegatingSchemaService } from '@warp-drive/legacy/model/migration-support';
-	* import { SchemaService } from '@warp-drive/core/reactive';
-	*
-	* class extends Store {
-	*   createSchemaService() {
-	*     const schema = new SchemaService();
-	*     return new DelegatingSchemaService(this, schema);
-	*   }
-	* }
-	* ```
-	*
-	* When using the DelegateSchemaService, the schema will first
-	* be sourced from directly registered schemas, then will fallback
-	* to sourcing a schema from available models if no schema is found.
-	*
-	* @public
-	*/
-	createSchemaService(): SchemaService;
-	/**
-	* DEPRECATED - Use the property `store.schema` instead.
-	*
-	* Provides access to the SchemaDefinitionService instance
-	* for this Store instance.
-	*
-	* The SchemaDefinitionService can be used to query for
-	* information about the schema of a resource.
-	*
-	* @deprecated
-	* @public
-	*/
-	getSchemaDefinitionService(): SchemaService;
-	/**
-	* DEPRECATED - Use `createSchemaService` instead.
-	*
-	* Allows an app to register a custom SchemaService
-	* for use when information about a resource's schema needs
-	* to be queried.
-	*
-	* This method can only be called more than once, but only one schema
-	* definition service may exist. Therefore if you wish to chain services
-	* you must lookup the existing service and close over it with the new
-	* service by accessing `store.schema` prior to registration.
-	*
-	* For Example:
-	*
-	* ```ts
-	* import { Store } from '@warp-drive/core';
-	*
-	* class SchemaDelegator {
-	*   constructor(schema) {
-	*     this._schema = schema;
-	*   }
-	*
-	*   hasResource(resource: { type: string }): boolean {
-	*     if (AbstractSchemas.has(resource.type)) {
-	*       return true;
-	*     }
-	*     return this._schema.hasResource(resource);
-	*   }
-	*
-	*   attributesDefinitionFor(identifier: ResourceKey | { type: string }): AttributesSchema {
-	*     return this._schema.attributesDefinitionFor(identifier);
-	*   }
-	*
-	*   relationshipsDefinitionFor(identifier: ResourceKey | { type: string }): RelationshipsSchema {
-	*     const schema = AbstractSchemas.get(identifier.type);
-	*     return schema || this._schema.relationshipsDefinitionFor(identifier);
-	*   }
-	* }
-	*
-	* export default class extends Store {
-	*   constructor(...args) {
-	*     super(...args);
-	*
-	*     const schema = this.createSchemaService();
-	*     this.registerSchemaDefinitionService(new SchemaDelegator(schema));
-	*   }
-	* }
-	* ```
-	*
-	* @deprecated
-	* @public
-	*/
-	registerSchemaDefinitionService(schema: SchemaService): void;
-	/**
-	* DEPRECATED - Use `createSchemaService` instead.
-	*
-	* Allows an app to register a custom SchemaService
-	* for use when information about a resource's schema needs
-	* to be queried.
-	*
-	* This method can only be called more than once, but only one schema
-	* definition service may exist. Therefore if you wish to chain services
-	* you must lookup the existing service and close over it with the new
-	* service by accessing `store.schema` prior to registration.
-	*
-	* For Example:
-	*
-	* ```ts
-	* import { Store } from '@warp-drive/core';
-	*
-	* class SchemaDelegator {
-	*   constructor(schema) {
-	*     this._schema = schema;
-	*   }
-	*
-	*   hasResource(resource: { type: string }): boolean {
-	*     if (AbstractSchemas.has(resource.type)) {
-	*       return true;
-	*     }
-	*     return this._schema.hasResource(resource);
-	*   }
-	*
-	*   attributesDefinitionFor(identifier: ResourceKey | { type: string }): AttributesSchema {
-	*     return this._schema.attributesDefinitionFor(identifier);
-	*   }
-	*
-	*   relationshipsDefinitionFor(identifier: ResourceKey | { type: string }): RelationshipsSchema {
-	*     const schema = AbstractSchemas.get(identifier.type);
-	*     return schema || this._schema.relationshipsDefinitionFor(identifier);
-	*   }
-	* }
-	*
-	* export default class extends Store {
-	*   constructor(...args) {
-	*     super(...args);
-	*
-	*     const schema = this.schema;
-	*     this.registerSchema(new SchemaDelegator(schema));
-	*   }
-	* }
-	* ```
-	*
-	* @deprecated
-	* @public
-	*/
-	registerSchema(schema: SchemaService): void;
-}
-/**
-* ```ts
-* import { Store } from '@warp-drive/core';
-* ```
-*
-* The `Store` is the central piece of the ***Warp*Drive** experience. It connects
-* requests for data with schemas, caching and reactivity.
-*
-* While it's easy to use ***just*** ***Warp*Drive**'s request management, most projects will find they
-* require far more than basic fetch management. For this reason it's often best to start with a `Store`
-* even when you aren't sure yet.
-*
-* Most projects will only have a single `Store`, though using multiple distinct stores
-* is possible.
-*
-* @public
-* @hideconstructor
-*/
-export declare class Store extends BaseClass {
-	/**
-	* Provides access to the {@link NotificationManager} associated
-	* with this Store instance.
-	*
-	* The NotificationManager can be used to subscribe to
-	* changes to the cache.
-	*
-	* @public
-	*/
-	readonly notifications: NotificationManager;
-	/**
-	* Provides access to the SchemaService instance
-	* for this Store instance.
-	*
-	* The SchemaService can be used to query for
-	* information about the schema of a resource.
-	*
-	* @public
-	*/
-	get schema(): ReturnType<this["createSchemaService"]>;
-	/**
-	* Provides access to the CacheKeyManager
-	* for this store.
-	*
-	* The CacheKeyManager can be used to generate or
-	* retrieve a stable unique CacheKey for any resource
-	* or request.
-	*
-	* @public
-	*/
-	readonly cacheKeyManager: CacheKeyManager;
-	/**
-	* Provides access to the {@link RequestManager} instance associated
-	* with this Store instance.
-	*
-	* See also:
-	* - {@link Fetch}
-	* - {@link CacheHandlerInterface | CacheHandler (Interface)}
-	* - {@link CacheHandler | CacheHandler (Class)}
-	*
-	* ```ts
-	* import { CacheHandler, Fetch, RequestManager, Store } from '@warp-drive/core';
-	*
-	* class AppStore extends Store {
-	*   requestManager = new RequestManager()
-	*    .use([Fetch])
-	*    .useCache(CacheHandler);
-	* }
-	* ```
-	*
-	* @public
-	*/
-	requestManager: RequestManager;
-	/**
-	* A Property which an App may set to provide a CachePolicy
-	* to control when a cached request becomes stale.
-	*
-	* 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 {@link CacheKeyManager}
-	* was able to generate a key for the request using the configured
-	* {@link setIdentifierGenerationMethod | generation method}.
-	*
-	* `isSoftExpired` will only be invoked if `isHardExpired` returns `false`.
-	*
-	* ```ts
-	* store.lifetimes = {
-	*   // make the request and ignore the current cache state
-	*   isHardExpired(key: RequestKey): boolean {
-	*     return false;
-	*   }
-	*
-	*   // make the request in the background if true, return cache state
-	*   isSoftExpired(key: RequestKey): boolean {
-	*     return false;
-	*   }
-	* }
-	* ```
-	*
-	* @public
-	*/
-	lifetimes?: CachePolicy;
-	/** @private */
-	get isDestroying(): boolean;
-	/** @private */
-	get isDestroyed(): boolean;
-	/** @deprecated use {@link Store.cacheKeyManager} */
-	get identifierCache(): CacheKeyManager;
-	/**
-	@private
-	*/
-	constructor(createArgs?: unknown);
-	/**
-	* Retrieve the RequestStateService instance
-	* associated with this Store.
-	*
-	* This can be used to query the status of requests
-	* that have been initiated for a given identifier.
-	*
-	* @return {RequestStateService}
-	* @public
-	*/
-	getRequestStateService(): RequestStateService;
-	/**
-	* ::: tip 💡 For a more complete overview see the [Request Guide](/guides/2-requests/1-overview)
-	* :::
-	*
-	* Issue a request via the configured {@link RequestManager},
-	* inserting the response into the {@link Store.cache | cache} and handing
-	* back a {@link Future} which resolves to a {@link ReactiveDocument | ReactiveDocument}
-	*
-	* #### Request Cache Keys
-	*
-	* Only {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Methods/GET | GET} requests with a url or requests with an explicit
-	* {@link CacheOptions.key | cache key} will have the request result
-	* and document cached.
-	*
-	* 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
-	* either ensure they are already in the url or utilize
-	* `requestConfig.cacheOptions.key`. For queries issued
-	* via the {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Methods/POST | POST} method `requestConfig.cacheOptions.key`
-	* MUST be supplied for the document to be cached.
-	*
-	* #### Requesting Without a Cache Key
-	*
-	* Resource data within the request is always updated in the cache,
-	* regardless of whether a cache key is present for the request.
-	*
-	* #### Fulfilling From Cache
-	*
-	* When a cache-key is determined, the request may fulfill
-	* from cache provided the cache is not stale.
-	*
-	* Cache staleness is determined by the configured {@link CachePolicy}
-	* with priority given to the  {@link CacheOptions.reload} and
-	* {@link CacheOptions.backgroundReload} on the request if present.
-	*
-	* If the cache data has soft expired or the request asks for a background
-	* reload, the request will fulfill from cache if possible and
-	* make a non-blocking request in the background to update the cache.
-	*
-	* If the cache data has hard expired or the request asks for a reload,
-	* the request will not fulfill from cache and will make a blocking
-	* request to update the cache.
-	*
-	* #### The Response
-	*
-	* The primary difference between {@link RequestManager.request} and `store.request`
-	* is that `store.request` will convert the response into a {@link ReactiveDocument}
-	* containing {@link Store.instantiateRecord | ReactiveResources}.
-	*
-	* @public
-	*/
-	request<RT>(requestConfig: StoreRequestInput<RT>): Future<RT>;
-	/**
-	Creates a new record in the current store.
-	
-	> [!CAUTION]
-	> This should not be used to mock records or to create
-	> a record representing data that could be fetched from
-	> the API.
-	
-	The properties passed to this method are set on
-	the newly created record.
-	
-	For instance: to create a new `post`:
-	
-	```js
-	store.createRecord('post', {
-	title: 'WarpDrive is Stellar!'
-	});
-	```
-	
-	Relationships can be set during create. For instance,
-	to create a new `post` that has an existing user as
-	it's author:
-	
-	```js
-	const user = store.peekRecord('user', '1');
-	
-	store.createRecord('post', {
-	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 type the name of the resource
-	@param inputProperties a hash of properties to set on the
-	newly created record.
-	@return a record in the "isNew" state
-	*/
-	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.
-	
-	Example
-	
-	```javascript
-	let post = store.createRecord('post', {
-	title: 'Ember is awesome!'
-	});
-	
-	store.deleteRecord(post);
-	```
-	
-	@public
-	@param {unknown} record
-	*/
-	deleteRecord<T>(record: T): void;
-	/**
-	For symmetry, a record can be unloaded via the store.
-	This will cause the record to be destroyed and freed up for garbage collection.
-	
-	Example
-	
-	```javascript
-	const { content: { data: post } } = await store.request(findRecord({ type: 'post', id: '1' }));
-	store.unloadRecord(post);
-	```
-	
-	@public
-	@param {Model} record
-	*/
-	unloadRecord<T>(record: T): void;
-	/**
-	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,
-	otherwise it will return `null`. A record is available if it has been fetched earlier, or
-	pushed manually into the store.
-	
-	**Example 1**
-	
-	```ts
-	const post = store.peekRecord('post', '1');
-	
-	post.id; // '1'
-	```
-	
-	`peekRecord` 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)
-	
-	**Example 2**
-	
-	```ts
-	const post = store.peekRecord({ type: 'post', id: '1' });
-	post.id; // '1'
-	```
-	
-	If you have previously received an lid from an Identifier for this record, you can lookup the record again using
-	just the lid.
-	
-	**Example 3**
-	
-	```js
-	let post = store.peekRecord({ lid });
-	post.id; // '1'
-	```
-	
-	@since 1.13.0
-	@public
-	@param type - either a string representing the modelName 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 id - optional only if the first param is a ResourceIdentifier, else the string id of the record to be retrieved.
-	*/
-	peekRecord<T>(type: TypeFromInstance<T>, id: string | number): T | null;
-	peekRecord(type: string, id: string | number): unknown | null;
-	peekRecord<T>(identifier: ResourceIdentifierObject<TypeFromInstance<T>>): T | null;
-	peekRecord(identifier: ResourceIdentifierObject): unknown | null;
-	/**
-	This method returns the {@link LegacyLiveArray} that contains all of the
-	known records for a given type in the store. Each ResourceType has only
-	one LiveArray instance, so multiple calls to `peekAll` with the same type
-	will always return the same instance.
-	
-	Note that because it's a LiveArray, the result will contain any
-	locally created records of the type, however, it will not make a
-	request to the backend to retrieve additional records.
-	
-	Example
-	
-	```ts
-	const allPosts = store.peekAll('post');
-	```
-	
-	@since 1.13.0
-	@public
-	@param type the name of the resource
-	*/
-	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.
-	
-	Optionally you can pass a type which unload all records for a given type.
-	
-	```javascript
-	store.unloadAll();
-	store.unloadAll('post');
-	```
-	
-	@param {String} type the name of the resource
-	@public
-	*/
-	unloadAll<T>(type: TypeFromInstance<T>): void;
-	unloadAll(type?: string): void;
-	/**
-	Push some data for a given type into the store.
-	
-	This method expects normalized [JSON API](http://jsonapi.org/) document. This means you have to follow [JSON API specification](http://jsonapi.org/format/) with few minor adjustments:
-	- record's `type` should always be in singular, dasherized form
-	- members (properties) should be camelCased
-	
-	[Your primary data should be wrapped inside `data` property](http://jsonapi.org/format/#document-top-level):
-	
-	```js
-	store.push({
-	data: {
-	// primary data for single record of type `Person`
-	id: '1',
-	type: 'person',
-	attributes: {
-	firstName: 'Daniel',
-	lastName: 'Kmak'
-	}
-	}
-	});
-	```
-	
-	[Demo.](http://ember-twiddle.com/fb99f18cd3b4d3e2a4c7)
-	
-	`data` property can also hold an array (of records):
-	
-	```js
-	store.push({
-	data: [
-	// an array of records
-	{
-	id: '1',
-	type: 'person',
-	attributes: {
-	firstName: 'Daniel',
-	lastName: 'Kmak'
-	}
-	},
-	{
-	id: '2',
-	type: 'person',
-	attributes: {
-	firstName: 'Tom',
-	lastName: 'Dale'
-	}
-	}
-	]
-	});
-	```
-	
-	[Demo.](http://ember-twiddle.com/69cdbeaa3702159dc355)
-	
-	There are some typical properties for `JSONAPI` payload:
-	* `id` - mandatory, unique record's key
-	* `type` - mandatory string which matches `model`'s dasherized name in singular form
-	* `attributes` - object which holds data for record attributes - `attr`'s declared in model
-	* `relationships` - object which must contain any of the following properties under each relationships' respective key (example path is `relationships.achievements.data`):
-	- [`links`](http://jsonapi.org/format/#document-links)
-	- [`data`](http://jsonapi.org/format/#document-resource-object-linkage) - place for primary data
-	- [`meta`](http://jsonapi.org/format/#document-meta) - object which contains meta-information about relationship
-	
-	For this model:
-	
-	```js [app/models/person.js]
-	import Model, { attr, hasMany } from '@warp-drive/legacy/model';
-	
-	export default class PersonRoute extends Route {
-	@attr('string') firstName;
-	@attr('string') lastName;
-	
-	@hasMany('person') children;
-	}
-	```
-	
-	To represent the children as IDs:
-	
-	```js
-	{
-	data: {
-	id: '1',
-	type: 'person',
-	attributes: {
-	firstName: 'Tom',
-	lastName: 'Dale'
-	},
-	relationships: {
-	children: {
-	data: [
-	{
-	id: '2',
-	type: 'person'
-	},
-	{
-	id: '3',
-	type: 'person'
-	},
-	{
-	id: '4',
-	type: 'person'
-	}
-	]
-	}
-	}
-	}
-	}
-	```
-	
-	[Demo.](http://ember-twiddle.com/343e1735e034091f5bde)
-	
-	To represent the children relationship as a URL:
-	
-	```js
-	{
-	data: {
-	id: '1',
-	type: 'person',
-	attributes: {
-	firstName: 'Tom',
-	lastName: 'Dale'
-	},
-	relationships: {
-	children: {
-	links: {
-	related: '/people/1/children'
-	}
-	}
-	}
-	}
-	}
-	```
-	
-	If you're streaming data, or implementing response handling, make sure
-	that you have converted the incoming data into this form.
-	
-	This method can be used both to push in brand new
-	records, as well as to update existing records.
-	
-	See also {@link Cache.patch}
-	
-	@public
-	@param data
-	@return the primary record(s) that created or updated.
-	*/
-	push(data: EmptyResourceDocument): null;
-	push<T>(data: SingleResourceDocument<TypeFromInstance<T>>): T;
-	push(data: SingleResourceDocument): OpaqueRecordInstance;
-	push<T>(data: CollectionResourceDocument<TypeFromInstance<T>>): T[];
-	push(data: CollectionResourceDocument): OpaqueRecordInstance[];
-	/**
-	Push some data in the form of a json-api document into the store,
-	without creating materialized records.
-	
-	@private
-	@return identifiers for the primary records that had data loaded
-	*/
-	_push(jsonApiDoc: JsonApiDocument, asyncFlush?: boolean): PersistedResourceKey | PersistedResourceKey[] | null;
-	/**
-	* Returns the cache instance associated to this Store, instantiates the Cache
-	* if necessary via `Store.createCache`
-	*
-	* @public
-	*/
-	get cache(): ReturnType<this["createCache"]>;
-	/** @private */
-	destroy(): void;
-	/**
-	* This method
-	*
-	* @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
-	*
-	* This is useful for ensuring that notifications are delivered
-	* prior to the promise resolving but without risk of promise
-	* interleaving.
-	*/
-	_enableAsyncFlush: boolean | null;
-	/**
-	* 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.
-	*
-	*/
-	_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;