@ember-data-types/store 5.6.0-beta.0 → 5.6.0-beta.1

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

@@ -1,1601 +0,0 @@
-declare module '@ember-data/store/-private/store-service' {
-  import type RequestManager from '@ember-data/request';
-  import type { Future } from '@ember-data/request';
-  import type { Cache } from '@warp-drive/core-types/cache';
-  import type { Graph } from '@warp-drive/core-types/graph';
-  import type { 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/json-api-raw';
-  import type { Type } from '@warp-drive/core-types/symbols';
-  import type { CacheCapabilitiesManager } from '@ember-data/store/-types/q/cache-capabilities-manager';
-  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, LegacyResourceQuery, QueryOptions } from '@ember-data/store/-types/q/store';
-  import type { StoreRequestInput } from '@ember-data/store/-private/cache-handler/handler';
-  import type { CachePolicy } from '@ember-data/store/-private/cache-handler/types';
-  import { IdentifierCache } from '@ember-data/store/-private/caches/identifier-cache';
-  import { InstanceCache, storeFor } from '@ember-data/store/-private/caches/instance-cache';
-  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, IdentifierArray } from '@ember-data/store/-private/record-arrays/identifier-array';
-  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.
-   *
-   * @typedoc
-   */
-  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>;
-  const BaseClass: {
-      new (args?: unknown): {};
-  };
-  export interface Store {
-      createCache(capabilities: CacheCapabilitiesManager): Cache;
-      instantiateRecord<T>(identifier: StableRecordIdentifier, createRecordArgs: {
-          [key: string]: unknown;
-      }): OpaqueRecordInstance;
-      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 SchemaRecord
-       *
-       * ```ts
-       * import { SchemaService } from '@warp-drive/schema-record';
-       *
-       * class extends Store {
-       *   createSchemaService() {
-       *     return new SchemaService();
-       *   }
-       * }
-       * ```
-       *
-       * Or to use the SchemaService for @ember-data/model
-       *
-       * ```ts
-       * import { buildSchema } from '@ember-data/model/hooks';
-       *
-       * 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
-       * `@ember-data/model` to `@warp-drive/schema-record` a
-       * SchemaService is provided that handles this transition
-       * for you:
-       *
-       * ```ts
-       * import { DelegatingSchemaService } from '@ember-data/model/migration-support';
-       * import { SchemaService } from '@warp-drive/schema-record';
-       *
-       * 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.
-       *
-       * @method createSchemaService (hook)
-       * @return {SchemaService}
-       * @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.
-       *
-       * @method getSchemaDefinitionService
-       * @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 '@ember-data/store';
-       *
-       * 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: 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.createSchemaService();
-       *     this.registerSchemaDefinitionService(new SchemaDelegator(schema));
-       *   }
-       * }
-       * ```
-       *
-       * @method registerSchemaDefinitionService
-       * @param {SchemaService} 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 '@ember-data/store';
-       *
-       * 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: 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
-       * @deprecated
-       * @public
-       */
-      registerSchema(schema: SchemaService): void;
-  }
-  export class Store extends BaseClass {
-      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 notifications
-       * @type {NotificationManager}
-       * @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 schema
-       * @type {SchemaService}
-       * @public
-       */
-      get schema(): ReturnType<this['createSchemaService']>;
-      _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
-       * @type {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 {
-       *   requestManager = new RequestManager()
-       *    .use([Fetch])
-       *    .useCache(CacheHandler);
-       * }
-       * ```
-       *
-       * @public
-       * @property requestManager
-       * @type {RequestManager}
-       */
-      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 [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 lifetimes
-       * @type {CachePolicy|undefined}
-       */
-      lifetimes?: CachePolicy;
-      _graph?: Graph;
-      _requestCache: RequestStateService;
-      _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.
-       *
-       * @internal
-       */
-      _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;
-      /**
-       * Executes the callback, ensurng that any work that calls
-       * store._schedule is executed after in the right order.
-       *
-       * When queues already exist, scheduled callbacks will
-       * join the existing queue.
-       *
-       * @internal
-       */
-      _join(cb: () => void): void;
-      _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 CachePolicy
-       * 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<RT, T = unknown>(requestConfig: StoreRequestInput<T, RT>): Future<RT>;
-      /**
-       * 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.
-       *
-       * @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
-       */
-      /**
-        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
-        @deprecated
-        @param {String} type
-        @return {ModelSchema}
-        */
-      modelFor<T>(type: TypeFromInstance<T>): ModelSchema<T>;
-      modelFor(type: string): ModelSchema;
-      /**
-        Create a new record in the current store. The properties passed
-        to this method are set on the newly created record.
-    
-        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
-        const { content: { data: post } } = await store.request(findRecord({ type: 'post', id: '1' }));
-        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
-        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
-        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
-        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
-        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
-        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
-        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
-        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
-        list of relationship names, while nested relationships can be specified
-        using a dot-separated sequence of relationship names. So to request both the post's
-        comments and the authors of those comments the request would look like this:
-    
-        ```app/routes/post.js
-        export default class PostRoute extends Route {
-          model(params) {
-            return this.store.findRecord('post', params.post_id, { include: ['comments','comments.author'] });
-          }
-        }
-        ```
-    
-        ### Retrieving Specific Fields by Type
-    
-        If your server endpoint supports the use of a ['fields' query parameter](https://jsonapi.org/format/#fetching-sparse-fieldsets),
-        you can use pass those fields through to your server.  At this point in time, this requires a few manual steps on your part.
-    
-        1. Implement `buildQuery` in your adapter.
-    
-        ```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
-        export default class extends Route {
-          model(params) {
-            return this.store.findRecord('post', params.post_id, { adapterOptions: { fields: { post: 'body,title' } });
-          }
-        }
-        ```
-    
-        Moreover, you can filter attributes on related models as well. If a `post` has a `belongsTo` relationship to a user,
-        just include the relationship key and attributes.
-    
-        ```app/routes/post.js
-        export default class extends Route {
-          model(params) {
-            return this.store.findRecord('post', params.post_id, { adapterOptions: { fields: { post: 'body,title', user: 'name,email' } });
-          }
-        }
-        ```
-    
-        @since 1.13.0
-        @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>(type: TypeFromInstance<T>, id: string | number, options?: FindRecordOptions<T>): Promise<T>;
-      findRecord(type: string, id: string | number, options?: FindRecordOptions): Promise<unknown>;
-      findRecord<T>(resource: ResourceIdentifierObject<TypeFromInstance<T>>, options?: FindRecordOptions<T>): Promise<T>;
-      findRecord(resource: ResourceIdentifierObject, options?: FindRecordOptions): Promise<unknown>;
-      /**
-        Get the reference for the specified record.
-    
-        Example
-    
-        ```javascript
-        let userRef = store.getReference('user', '1');
-    
-        // check if the user is loaded
-        let isLoaded = userRef.value() !== null;
-    
-        // get the record of the reference (null if not yet available)
-        let user = userRef.value();
-    
-        // get the identifier of the reference
-        if (userRef.remoteType() === 'id') {
-        let id = userRef.id();
-        }
-    
-        // load user (via store.find)
-        userRef.load().then(...)
-    
-        // or trigger a reload
-        userRef.reload().then(...)
-    
-        // provide data for reference
-        userRef.push({ id: 1, username: '@user' }).then(function(user) {
-          userRef.value() === user;
-        });
-        ```
-    
-        @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>(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 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: LegacyResourceQuery<T>, options?: QueryOptions): Promise<Collection<T>>;
-      query(type: string, query: LegacyResourceQuery, options?: QueryOptions): Promise<Collection>;
-      /**
-        This method makes a request for one record, where the `id` is not known
-        beforehand (if the `id` is known, use [`findRecord`](../methods/findRecord?anchor=findRecord)
-        instead).
-    
-        This method can be used when it is certain that the server will return a
-        single object for the primary data.
-    
-        Each time this method is called a new request is made through the adapter.
-    
-        Let's assume our API provides an endpoint for the currently logged in user
-        via:
-    
-        ```
-        // GET /api/current_user
-        {
-          user: {
-            id: 1234,
-            username: 'admin'
-          }
-        }
-        ```
-    
-        Since the specific `id` of the `user` is not known beforehand, we can use
-        `queryRecord` to get the user:
-    
-        ```javascript
-        store.queryRecord('user', {}).then(function(user) {
-          let username = user.username;
-          // do thing
-        });
-        ```
-    
-        The request is made through the adapters' `queryRecord`:
-    
-        ```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} type
-        @param {Object} query an opaque query to be used by the adapter
-        @param {Object} options optional, may include `adapterOptions` hash which will be passed to adapter.queryRecord
-        @return {Promise} promise which resolves with the found record or `null`
-      */
-      queryRecord<T>(type: TypeFromInstance<T>, query: LegacyResourceQuery<T>, options?: QueryOptions): Promise<T | null>;
-      queryRecord(type: string, query: LegacyResourceQuery, options?: QueryOptions): Promise<unknown | null>;
-      /**
-        `findAll` asks the adapter's `findAll` method to find the records for the
-        given type, and returns a promise which will resolve with all records of
-        this type present in the store, even if the adapter only returns a subset
-        of them.
-    
-        ```app/routes/authors.js
-        export default class AuthorsRoute extends Route {
-          model(params) {
-            return this.store.findAll('author');
-          }
-        }
-        ```
-    
-        _When_ the returned promise resolves depends on the reload behavior,
-        configured via the passed `options` hash and the result of the adapter's
-        `shouldReloadAll` method.
-    
-        ### Reloading
-    
-        If `{ reload: true }` is passed or `adapter.shouldReloadAll` evaluates to
-        `true`, then the returned promise resolves once the adapter returns data,
-        regardless if there are already records in the store:
-    
-        ```js
-        store.push({
-          data: {
-            id: 'first',
-            type: 'author'
-          }
-        });
-    
-        // adapter#findAll resolves with
-        // [
-        //   {
-        //     id: 'second',
-        //     type: 'author'
-        //   }
-        // ]
-        store.findAll('author', { reload: true }).then(function(authors) {
-          authors.getEach('id'); // ['first', 'second']
-        });
-        ```
-    
-        If no reload is indicated via the above mentioned ways, then the promise
-        immediately resolves with all the records currently loaded in the store.
-    
-        ### Background Reloading
-    
-        Optionally, if `adapter.shouldBackgroundReloadAll` evaluates to `true`,
-        then a background reload is started. Once this resolves, the array with
-        which the promise resolves, is updated automatically so it contains all the
-        records in the store:
-    
-        ```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
-        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
-        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
-        export default class PostsRoute extends Route {
-          model() {
-            return this.store.findAll('post', { include: ['comments'] });
-          }
-        }
-        ```
-        Multiple relationships can be requested using an `include` parameter consisting of a
-        list or relationship names, while nested relationships can be specified
-        using a dot-separated sequence of relationship names. So to request both the posts'
-        comments and the authors of those comments the request would look like this:
-    
-        ```app/routes/posts.js
-        export default class PostsRoute extends Route {
-          model() {
-            return this.store.findAll('post', { include: ['comments','comments.author'] });
-          }
-        }
-        ```
-    
-        See [query](../methods/query?anchor=query) to only get a subset of records from the server.
-    
-        @since 1.13.0
-        @method findAll
-        @public
-        @param {String} type the name of the resource
-        @param {Object} options
-        @return {Promise} promise
-      */
-      findAll<T>(type: TypeFromInstance<T>, options?: FindAllOptions<T>): Promise<IdentifierArray<T>>;
-      findAll(type: string, options?: FindAllOptions): Promise<IdentifierArray>;
-      /**
-        This method returns a filtered array that contains all of the
-        known records for a given type in the store.
-    
-        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
-       * @type {Cache}
-       * @public
-       */
-      get cache(): ReturnType<this['createCache']>;
-      destroy(): void;
-      static create(args?: Record<string, unknown>): Store;
-  }
-}
-//# sourceMappingURL=store-service.d.ts.map