@warp-drive/core 5.8.0-alpha.3 → 5.8.0-alpha.32

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

@@ -0,0 +1,874 @@
+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;