@ember-data-types/store 5.4.0-alpha.49

package/unstable-preview-types/-private/store-service.d.ts

@@ -0,0 +1,1554 @@
+declare module '@ember-data/store/-private/store-service' {
+  /// <reference types="ember-source/types" />
+  import EmberObject from '@ember/object';
+  import type RequestManager from '@ember-data/request';
+  import type { Future } from '@ember-data/request/-private/types';
+  import type { Graph } from '@warp-drive/core-types/graph';
+  import type { StableDocumentIdentifier, StableExistingRecordIdentifier, StableRecordIdentifier } from '@warp-drive/core-types/identifier';
+  import type { TypedRecordInstance, TypeFromInstance } from '@warp-drive/core-types/record';
+  import type { CollectionResourceDocument, EmptyResourceDocument, JsonApiDocument, ResourceIdentifierObject, SingleResourceDocument } from '@warp-drive/core-types/spec/raw';
+  import type { ResourceType } from '@warp-drive/core-types/symbols';
+  import type { Cache, CacheV1 } from '@ember-data/store/-types/q/cache';
+  import type { CacheCapabilitiesManager } from '@ember-data/store/-types/q/cache-store-wrapper';
+  import type { ModelSchema } from '@ember-data/store/-types/q/ds-model';
+  import type { OpaqueRecordInstance } from '@ember-data/store/-types/q/record-instance';
+  import type { SchemaService } from '@ember-data/store/-types/q/schema-service';
+  import type { FindAllOptions, FindRecordOptions, QueryOptions } from '@ember-data/store/-types/q/store';
+  import type { LifetimesService, StoreRequestInput } from '@ember-data/store/-private/cache-handler';
+  import { IdentifierCache } from '@ember-data/store/-private/caches/identifier-cache';
+  import { InstanceCache, storeFor } from '@ember-data/store/-private/caches/instance-cache';
+  import type { Document } from '@ember-data/store/-private/document';
+  import type RecordReference from '@ember-data/store/-private/legacy-model-support/record-reference';
+  import NotificationManager from '@ember-data/store/-private/managers/notification-manager';
+  import RecordArrayManager from '@ember-data/store/-private/managers/record-array-manager';
+  import RequestStateService from '@ember-data/store/-private/network/request-cache';
+  import type { Collection } from '@ember-data/store/-private/record-arrays/identifier-array';
+  import type IdentifierArray from '@ember-data/store/-private/record-arrays/identifier-array';
+  export { storeFor };
+  type FilteredKeys<T> = Omit<T, typeof ResourceType | keyof EmberObject | '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.
+   *
+   * @typedoc
+   */
+  export type CreateRecordProperties<T = MaybeHasId & Record<string, unknown>> = T extends TypedRecordInstance ? FilteredKeys<Partial<T>> : T extends MaybeHasId ? MaybeHasId & FilteredKeys<Partial<T>> : MaybeHasId & Record<string, unknown>;
+  /**
+   * A Store coordinates interaction between your application, a [Cache](https://api.emberjs.com/ember-data/release/classes/%3CInterface%3E%20Cache),
+   * and sources of data (such as your API or a local persistence layer)
+   * accessed via a [RequestManager](https://github.com/emberjs/data/tree/main/packages/request).
+   *
+   * ```app/services/store.js
+   * import Store from '@ember-data/store';
+   *
+   * export default class extends Store {}
+   * ```
+   *
+   * Most Ember applications will only have a single `Store` configured as a Service
+   * in this manner. However, setting up multiple stores is possible, including using
+   * each as a unique service.
+   *
+  
+    @class Store
+    @public
+  */
+  interface Store {
+      createRecordDataFor?(identifier: StableRecordIdentifier, wrapper: CacheCapabilitiesManager): Cache | CacheV1;
+      createCache(storeWrapper: CacheCapabilitiesManager): Cache;
+      instantiateRecord(identifier: StableRecordIdentifier, createRecordArgs: {
+          [key: string]: unknown;
+      }): OpaqueRecordInstance;
+      teardownRecord(record: OpaqueRecordInstance): void;
+  }
+  class Store extends EmberObject {
+      recordArrayManager: RecordArrayManager;
+      /**
+       * Provides access to the NotificationManager associated
+       * with this Store instance.
+       *
+       * The NotificationManager can be used to subscribe to
+       * changes to the cache.
+       *
+       * @property {NotificationManager} notifications
+       * @public
+       */
+      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.
+       *
+       * @property {SchemaService} schema
+       * @public
+       */
+      get schema(): SchemaService;
+      _schema: SchemaService;
+      /**
+       * Provides access to the IdentifierCache instance
+       * for this store.
+       *
+       * The IdentifierCache can be used to generate or
+       * retrieve a stable unique identifier for any resource.
+       *
+       * @property {IdentifierCache} identifierCache
+       * @public
+       */
+      identifierCache: IdentifierCache;
+      /**
+       * Provides access to the requestManager instance associated
+       * with this Store instance.
+       *
+       * When using `ember-data` this property is automatically
+       * set to an instance of `RequestManager`. When not using `ember-data`
+       * you must configure this property yourself, either by declaring
+       * it as a service or by initializing it.
+       *
+       * ```ts
+       * import Store, { CacheHandler } from '@ember-data/store';
+       * import RequestManager from '@ember-data/request';
+       * import Fetch from '@ember/data/request/fetch';
+       *
+       * class extends Store {
+       *   constructor() {
+       *     super(...arguments);
+       *     this.requestManager = new RequestManager();
+       *     this.requestManager.use([Fetch]);
+       *     this.requestManager.useCache(CacheHandler);
+       *   }
+       * }
+       * ```
+       *
+       * @public
+       * @property {RequestManager} requestManager
+       */
+      requestManager: RequestManager;
+      /**
+       * A Property which an App may set to provide a Lifetimes Service
+       * 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 [IdentifierCache](/ember-data/release/classes/IdentifierCache)
+       * was able to generate a key for the request using the configured
+       * [generation method](/ember-data/release/functions/@ember-data%2Fstore/setIdentifierGenerationMethod).
+       *
+       * `isSoftExpired` will only be invoked if `isHardExpired` returns `false`.
+       *
+       * ```ts
+       * store.lifetimes = {
+       *   // make the request and ignore the current cache state
+       *   isHardExpired(identifier: StableDocumentIdentifier): boolean {
+       *     return false;
+       *   }
+       *
+       *   // make the request in the background if true, return cache state
+       *   isSoftExpired(identifier: StableDocumentIdentifier): boolean {
+       *     return false;
+       *   }
+       * }
+       * ```
+       *
+       * @public
+       * @property {LivetimesService|undefined} lifetimes
+       */
+      lifetimes?: LifetimesService;
+      _graph?: Graph;
+      _requestCache: RequestStateService;
+      _instanceCache: InstanceCache;
+      _documentCache: Map<StableDocumentIdentifier, Document<OpaqueRecordInstance | OpaqueRecordInstance[] | null | undefined>>;
+      _cbs: {
+          coalesce?: () => void;
+          sync?: () => void;
+          notify?: () => void;
+      } | null;
+      _forceShim: boolean;
+      _enableAsyncFlush: boolean | null;
+      DISABLE_WAITER?: boolean;
+      _isDestroying: boolean;
+      _isDestroyed: boolean;
+      get isDestroying(): boolean;
+      set isDestroying(value: boolean);
+      get isDestroyed(): boolean;
+      set isDestroyed(value: boolean);
+      /**
+        @method init
+        @private
+      */
+      constructor(createArgs?: unknown);
+      _run(cb: () => void): void;
+      _join(cb: () => void): void;
+      _schedule(name: 'coalesce' | 'sync' | 'notify', cb: () => void): void;
+      /**
+       * 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.
+       *
+       * @method getRequestStateService
+       * @return {RequestStateService}
+       * @public
+       */
+      getRequestStateService(): RequestStateService;
+      _getAllPending(): (Promise<unknown[]> & {
+          length: number;
+      }) | void;
+      /**
+       * Issue a request via the configured RequestManager,
+       * inserting the response into the cache and handing
+       * back a Future which resolves to a ResponseDocument
+       *
+       * ## Cache Keys
+       *
+       * Only GET requests with a url or requests with an explicit
+       * cache key (`cacheOptions.key`) will have the request result
+       * and document cached.
+       *
+       * The cache key used is `requestConfig.cacheOptions.key`
+       * if present, falling back to `requestconfig.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 `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 LifetimesService
+       * with priority given to the `cacheOptions.reload` and
+       * `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 `requestManager.request` and `store.request`
+       * is that `store.request` will attempt to hydrate the response content into
+       * a response Document containing RecordInstances.
+       *
+       * @method request
+       * @param {StoreRequestInput} requestConfig
+       * @return {Future}
+       * @public
+       */
+      request<T>(requestConfig: StoreRequestInput): Future<T>;
+      /**
+       * 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 presentating cache data to the ui for access
+       * mutation, and interaction.
+       *
+       * @method instantiateRecord (hook)
+       * @param identifier
+       * @param createRecordArgs
+       * @param recordDataFor deprecated use this.cache
+       * @param notificationManager deprecated use this.notifications
+       * @return A record instance
+       * @public
+       */
+      /**
+       * 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`.
+       *
+       * @method teardownRecord (hook)
+       * @public
+       * @param record
+       */
+      /**
+       * 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.
+       *
+       * @method getSchemaDefinitionService
+       * @public
+       */
+      getSchemaDefinitionService(): SchemaService;
+      /**
+       * DEPRECATED - Use `registerSchema` 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 '@ember-data/store';
+       *
+       * class SchemaDelegator {
+       *   constructor(schema) {
+       *     this._schema = schema;
+       *   }
+       *
+       *   doesTypeExist(type: string): boolean {
+       *     if (AbstractSchemas.has(type)) {
+       *       return true;
+       *     }
+       *     return this._schema.doesTypeExist(type);
+       *   }
+       *
+       *   attributesDefinitionFor(identifier: RecordIdentifier | { type: string }): AttributesSchema {
+       *     return this._schema.attributesDefinitionFor(identifier);
+       *   }
+       *
+       *   relationshipsDefinitionFor(identifier: RecordIdentifier | { 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.registerSchemaDefinitionService(new SchemaDelegator(schema));
+       *   }
+       * }
+       * ```
+       *
+       * @method registerSchemaDefinitionService
+       * @param {SchemaService} schema
+       * @deprecated
+       * @public
+       */
+      registerSchemaDefinitionService(schema: SchemaService): void;
+      /**
+       * 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 '@ember-data/store';
+       *
+       * class SchemaDelegator {
+       *   constructor(schema) {
+       *     this._schema = schema;
+       *   }
+       *
+       *   doesTypeExist(type: string): boolean {
+       *     if (AbstractSchemas.has(type)) {
+       *       return true;
+       *     }
+       *     return this._schema.doesTypeExist(type);
+       *   }
+       *
+       *   attributesDefinitionFor(identifier: RecordIdentifier | { type: string }): AttributesSchema {
+       *     return this._schema.attributesDefinitionFor(identifier);
+       *   }
+       *
+       *   relationshipsDefinitionFor(identifier: RecordIdentifier | { 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));
+       *   }
+       * }
+       * ```
+       *
+       * @method registerSchema
+       * @param {SchemaService} schema
+       * @public
+       */
+      registerSchema(schema: SchemaService): void;
+      /**
+        Returns the schema for a particular resource type (modelName).
+    
+        When used with Model from @ember-data/model the return is the model class,
+        but this is not guaranteed.
+    
+        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.
+    
+        @method modelFor
+        @public
+        @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.
+    
+        To create a new instance of a `Post`:
+    
+        ```js
+        store.createRecord('post', {
+          title: 'Ember is awesome!'
+        });
+        ```
+    
+        To create a new instance of a `Post` that has a relationship with a `User` record:
+    
+        ```js
+        let user = this.store.peekRecord('user', 1);
+        store.createRecord('post', {
+          title: 'Ember is awesome!',
+          user: user
+        });
+        ```
+    
+        @method createRecord
+        @public
+        @param {String} type the name of the resource
+        @param {Object} inputProperties a hash of properties to set on the
+          newly created record.
+        @return {Model} record
+      */
+      createRecord<T>(type: TypeFromInstance<T>, inputProperties: CreateRecordProperties<T>): T;
+      createRecord(type: string, inputProperties: CreateRecordProperties): 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);
+        ```
+    
+        @method deleteRecord
+        @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
+        store.findRecord('post', 1).then(function(post) {
+          store.unloadRecord(post);
+        });
+        ```
+    
+        @method unloadRecord
+        @public
+        @param {Model} record
+      */
+      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**
+    
+        ```app/routes/post.js
+        import Route from '@ember/routing/route';
+    
+        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)
+    
+        ```app/routes/post.js
+        import Route from '@ember/routing/route';
+    
+        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.
+    
+        ```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:
+    
+        ```app/routes/post-comments.js
+        import Route from '@ember/routing/route';
+    
+        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:
+    
+        ```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.
+    
+        ```app/routes/post-comments.js
+        import Route from '@ember/routing/route';
+    
+        export default class PostRoute extends Route {
+          model({ post_id, comment_id: id }) {
+            return this.store.findRecord({ type: 'comment', id, { adapterOptions: { post: post_id }} });
+          }
+        }
+        ```
+    
+        ```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`.
+    
+        ```app/routes/post/edit.js
+        import Route from '@ember/routing/route';
+    
+        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
+    
+        ```app/routes/post/edit.js
+        import Route from '@ember/routing/route';
+    
+        export default class PostEditRoute extends Route {
+          model(params) {
+            return this.store.findRecord('post', params.post_id, {
+              adapterOptions: { subscribe: false }
+            });
+          }
+        }
+        ```
+    
+        ```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:
+    
+        ```app/routes/post.js
+        import Route from '@ember/routing/route';
+    
+        export default class PostRoute extends Route {
+          model(params) {
+            return this.store.findRecord('post', params.post_id, { include: 'comments' });
+          }
+        }
+        ```
+    
+        ```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
+        comma-separated list (without white-space) 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:
+    
+        ```app/routes/post.js
+        import Route from '@ember/routing/route';
+    
+        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.
+    
+        ```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.
+    
+        ```app/routes/post.js
+        import Route from '@ember/routing/route';
+        export default Route.extend({
+          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.
+    
+        ```app/routes/post.js
+        import Route from '@ember/routing/route';
+        export default Route.extend({
+          model(params) {
+            return this.store.findRecord('post', params.post_id, { adapterOptions: { fields: { post: 'body,title', user: 'name,email' } });
+          }
+        });
+        ```
+    
+        @since 1.13.0
+        @method findRecord
+        @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>(resource: TypeFromInstance<T>, id: string | number, options?: FindRecordOptions): Promise<T>;
+      findRecord(resource: string, id: string | number, options?: FindRecordOptions): Promise<unknown>;
+      findRecord<T>(resource: ResourceIdentifierObject<TypeFromInstance<T>>, id?: FindRecordOptions): Promise<T>;
+      findRecord(resource: ResourceIdentifierObject, id?: 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;
+        });
+        ```
+    
+        @method getReference
+        @public
+        @param {String|object} resource - modelName (string) or Identifier (object)
+        @param {String|Integer} id
+        @since 2.5.0
+        @return {RecordReference}
+      */
+      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,
+        otherwise it will return `null`. A record is available if it has been fetched earlier, or
+        pushed manually into the store.
+    
+        See [findRecord](../methods/findRecord?anchor=findRecord) if you would like to request this record from the backend.
+    
+        _Note: This is a synchronous method and does not return a promise._
+    
+        **Example 1**
+    
+        ```js
+        let 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**
+    
+        ```js
+        let post = store.peekRecord({ type: 'post', id });
+        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
+        @method peekRecord
+        @public
+        @param {String|object} modelName - 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 {String|Integer} id - optional only if the first param is a ResourceIdentifier, else the string id of the record to be retrieved.
+        @return {Model|null} record
+      */
+      peekRecord<T = OpaqueRecordInstance>(identifier: string, id: string | number): T | null;
+      peekRecord<T = OpaqueRecordInstance>(identifier: ResourceIdentifierObject): T | 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
+        @method query
+        @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: Record<string, unknown>, options?: QueryOptions): Promise<Collection<T>>;
+      query(type: string, query: Record<string, unknown>, 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`:
+    
+        ```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
+        @method queryRecord
+        @public
+        @param {String} modelName
+        @param {any} 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(modelName: string, query: Record<string, unknown>, options?: QueryOptions): Promise<OpaqueRecordInstance | 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.
+    
+        ```app/routes/authors.js
+        import Route from '@ember/routing/route';
+    
+        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:
+    
+        ```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`.
+    
+        ```app/routes/post/edit.js
+        import Route from '@ember/routing/route';
+    
+        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`
+    
+        ```app/routes/posts.js
+        import Route from '@ember/routing/route';
+    
+        export default class PostsRoute extends Route {
+          model(params) {
+            return this.store.findAll('post', {
+              adapterOptions: { subscribe: false }
+            });
+          }
+        }
+        ```
+    
+        ```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:
+    
+        ```app/routes/posts.js
+        import Route from '@ember/routing/route';
+    
+        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
+        comma-separated list (without white-space) 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:
+    
+        ```app/routes/posts.js
+        import Route from '@ember/routing/route';
+    
+        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
+        @method findAll
+        @public
+        @param {string} type the name of the resource
+        @param {object} options
+        @return {Promise} promise
+      */
+      findAll<T>(type: TypeFromInstance<T>, options?: FindAllOptions): 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.
+    
+        Note that because it's just a filter, 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. If you
+        would like to request all the records from the backend please use
+        [store.findAll](../methods/findAll?anchor=findAll).
+    
+        Also note that multiple calls to `peekAll` for a given type will always
+        return the same `RecordArray`.
+    
+        Example
+    
+        ```javascript
+        let localPosts = store.peekAll('post');
+        ```
+    
+        @since 1.13.0
+        @method peekAll
+        @public
+        @param {string} type the name of the resource
+        @return {RecordArray}
+      */
+      peekAll<T>(type: TypeFromInstance<T>): IdentifierArray<T>;
+      peekAll(type: string): IdentifierArray;
+      /**
+        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');
+        ```
+    
+        @method unloadAll
+        @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:
+    
+        ```app/models/person.js
+        import Model, { attr, hasMany } from '@ember-data/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 an adapter, make sure
+        that you have converted the incoming data into this form. The
+        store's [normalize](../methods/normalize?anchor=normalize) method is a convenience
+        helper for converting a json payload into the form Ember Data
+        expects.
+    
+        ```js
+        store.push(store.normalize('person', data));
+        ```
+    
+        This method can be used both to push in brand new
+        records, as well as to update existing records.
+    
+        @method push
+        @public
+        @param {Object} data
+        @return the record(s) that was 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.
+    
+        @method _push
+        @private
+        @param {Object} jsonApiDoc
+        @return {StableRecordIdentifier|Array<StableRecordIdentifier>|null} identifiers for the primary records that had data loaded
+      */
+      _push(jsonApiDoc: JsonApiDocument, asyncFlush?: boolean): StableExistingRecordIdentifier | StableExistingRecordIdentifier[] | null;
+      /**
+       * Trigger a save for a Record.
+       *
+       * Returns a promise resolving with the same record when the save is complete.
+       *
+       * @method saveRecord
+       * @public
+       * @param {unknown} record
+       * @param options
+       * @return {Promise<record>}
+       */
+      saveRecord<T>(record: T, options?: Record<string, unknown>): Promise<T>;
+      /**
+       * 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.
+       *
+       * @method createCache (hook)
+       * @public
+       * @param storeWrapper
+       * @return {Cache}
+       */
+      /**
+       * Returns the cache instance associated to this Store, instantiates the Cache
+       * if necessary via `Store.createCache`
+       *
+       * @property {Cache} cache
+       * @public
+       */
+      get cache(): Cache;
+      destroy(): void;
+      static create(args?: Record<string, unknown>): Store;
+  }
+  export default Store;
+}
+//# sourceMappingURL=store-service.d.ts.map