@warp-drive/legacy 5.9.0-alpha.21 → 5.9.0-alpha.22

package/dist/compat-BbNNmTM-.d.ts

@@ -0,0 +1,1386 @@
+import { Store } from "@warp-drive/core";
+import { LegacyLiveArray, LegacyQueryArray, Request } from "@warp-drive/core/store/-private";
+import { Handler, createDeferred } from "@warp-drive/core/request";
+import { ImmutableRequestInfo } from "@warp-drive/core/types/request";
+import { FindAllOptions, FindRecordOptions, ModelSchema } from "@warp-drive/core/types";
+import { ObjectValue } from "@warp-drive/core/types/json/raw";
+import { JsonApiDocument, SingleResourceDocument } from "@warp-drive/core/types/spec/json-api-raw";
+import { ChangedAttributesHash } from "@warp-drive/core/types/cache";
+import { PersistedResourceKey, ResourceKey as ResourceKey$1 } from "@warp-drive/core/types/identifier";
+import { TypeFromInstance, TypedRecordInstance } from "@warp-drive/core/types/record";
+import { LegacyAttributeField, LegacyRelationshipField } from "@warp-drive/core/types/schema/fields";
+//#region src/compat/legacy-network-handler/minimum-adapter-interface.d.ts
+type Group = Snapshot[];
+/**
+ * The raw payload shape returned by a legacy adapter's request methods,
+ * prior to being normalized by a {@link MinimumSerializerInterface}.
+ */
+type AdapterPayload = Record<string, unknown> | unknown[];
+/**
+* :::danger
+⚠️ **This is LEGACY documentation** for a feature that is no longer encouraged to be used.
+If starting a new app or thinking of implementing a new adapter, consider writing a
+{@link Handler} instead to be used with the {@link RequestManager}
+:::
+
+The following documentation describes the methods an
+adapter should implement with descriptions around when an
+application might expect these methods to be called.
+
+Methods that are not required are marked as **optional**.
+
+@class (Interface) Adapter
+@public
+*/
+interface MinimumAdapterInterface {
+  /**
+   * `adapter.findRecord` takes a request for a resource of a given `type` and `id` combination
+   * and should return a `Promise` which fulfills with data for a single resource matching that
+   * `type` and `id`.
+   *
+   * The response will be fed to the associated serializer's `normalizeResponse` method with the
+   * `requestType` set to `findRecord`, which should return a `JSON:API` document.
+   *
+   * The final result after normalization to `JSON:API` will be added to store via `store.push` where
+   * it will merge with any existing data for the record.
+   *
+   * ⚠️ If the adapter's response resolves to a false-y value, the associated `serializer.normalizeResponse`
+   * call will NOT be made. In this scenario you may need to do at least a minimum amount of response
+   * processing within the adapter.
+   *
+   * `adapter.findRecord` is called whenever the `store` needs to load, reload, or backgroundReload
+   * the resource data for a given `type` and `id`.
+   *
+   * @public
+   * @param {Store} store The store service that initiated the request being normalized
+   * @param {ModelSchema} schema An object with methods for accessing information about
+   *  the type, attributes and relationships of the primary type associated with the request.
+   * @param {String} id
+   * @param {Snapshot} snapshot
+   * @return {Promise} a promise resolving with resource data to feed to the associated serializer
+   */
+  findRecord(store: Store, schema: ModelSchema, id: string, snapshot: Snapshot): Promise<AdapterPayload>;
+  /**
+   * `adapter.findAll` takes a request for resources of a given `type` and should return
+   *  a `Promise` which fulfills with a collection of resource data matching that `type`.
+   *
+   * The response will be fed to the associated serializer's `normalizeResponse` method
+   *  with the `requestType` set to `findAll`, which should return a `JSON:API` document.
+   *
+   * The final result after normalization to `JSON:API` will be added to store via `store.push` where
+   * it will merge with any existing records for `type`. Existing records for the `type` will not be removed.
+   *
+   * ⚠️ If the adapter's response resolves to a false-y value, the associated `serializer.normalizeResponse`
+   * call will NOT be made. In this scenario you may need to do at least a minimum amount of response
+   * processing within the adapter.
+   *
+   * `adapter.findAll` is called whenever `store.findAll` is asked to reload or backgroundReload.
+   * The records in the response are merged with the contents of the store. Existing records for
+   * the `type` will not be removed.
+   *
+   * See also `shouldReloadAll` and `shouldBackgroundReloadAll`
+   *
+   * @public
+   * @param {Store} store The store service that initiated the request being normalized
+   * @param {ModelSchema} schema An object with methods for accessing information about
+   *  the type, attributes and relationships of the primary type associated with the request.
+   * @param {null} sinceToken This parameter is no longer used and will always be null.
+   * @param {SnapshotRecordArray} snapshotRecordArray an object containing any passed in options,
+   *  adapterOptions, and the ability to access a snapshot for each existing record of the type.
+   * @return {Promise} a promise resolving with resource data to feed to the associated serializer
+   */
+  findAll(store: Store, schema: ModelSchema, sinceToken: null, snapshotRecordArray: SnapshotRecordArray): Promise<AdapterPayload>;
+  /**
+   * `adapter.query` takes a request for resources of a given `type` and should return
+   *  a `Promise` which fulfills with a collection of resource data matching that `type`.
+   *
+   * The response will be fed to the associated serializer's `normalizeResponse` method
+   *  with the `requestType` set to `query`, which should return a `JSON:API` document.
+   *
+   * As with `findAll`, the final result after normalization to `JSON:API` will be added to
+   * store via `store.push` where it will merge with any existing records for `type`.
+   *
+   * ⚠️ If the adapter's response resolves to a false-y value, the associated `serializer.normalizeResponse`
+   * call will NOT be made. In this scenario you may need to do at least a minimum amount of response
+   * processing within the adapter.
+   *
+   * `adapter.query` is called whenever `store.query` is called or a previous query result is
+   * asked to reload.
+   *
+   * Existing records for the `type` will not be removed. The key difference is in the result
+   * returned by the `store`. For `findAll` the result is all known records of the `type`,
+   * while for `query` it will only be the records returned from `adapter.query`.
+   *
+   * @public
+   * @param {Store} store The store service that initiated the request being normalized
+   * @param {ModelSchema} schema An object with methods for accessing information about
+   *  the type, attributes and relationships of the primary type associated with the request.
+   * @param {Object} query
+   * @param {LegacyQueryArray} recordArray
+   * @param {Object} options
+   * @return {Promise} a promise resolving with resource data to feed to the associated serializer
+   */
+  query(store: Store, schema: ModelSchema, query: Record<string, unknown>, recordArray: LegacyQueryArray, options: {
+    adapterOptions?: unknown;
+  }): Promise<AdapterPayload>;
+  /**
+   * `adapter.queryRecord` takes a request for resource of a given `type` and should return
+   *  a `Promise` which fulfills with data for a single resource matching that `type`.
+   *
+   * The response will be fed to the associated serializer's `normalizeResponse` method
+   *  with the `requestType` set to `queryRecord`, which should return a `JSON:API` document.
+   *
+   * The final result after normalization to `JSON:API` will be added to store via `store.push` where
+   * it will merge with any existing data for the returned record.
+   *
+   * ⚠️ If the adapter's response resolves to a false-y value, the associated `serializer.normalizeResponse`
+   * call will NOT be made. In this scenario you may need to do at least a minimum amount of response
+   * processing within the adapter.
+   *
+   * @public
+   * @param {Store} store The store service that initiated the request being normalized
+   * @param {ModelSchema} schema An object with methods for accessing information about
+   *  the type, attributes and relationships of the primary type associated with the request.
+   * @param query
+   * @param options
+   * @return {Promise} a promise resolving with resource data to feed to the associated serializer
+   */
+  queryRecord(store: Store, schema: ModelSchema, query: Record<string, unknown>, options: {
+    adapterOptions?: unknown;
+  }): Promise<AdapterPayload>;
+  /**
+   * `adapter.createRecord` takes a request to create a resource of a given `type` and should
+   * return a `Promise` which fulfills with data for the newly created resource.
+   *
+   * The response will be fed to the associated serializer's `normalizeResponse` method
+   *  with the `requestType` set to `createRecord`, which should return a `JSON:API` document.
+   *
+   * The final result after normalization to `JSON:API` will be added to store via `store.push` where
+   * it will merge with any existing data for the record.
+   *
+   * ⚠️ If the adapter's response resolves to a false-y value, the associated `serializer.normalizeResponse`
+   * call will NOT be made. In this scenario you may need to do at least a minimum amount of response
+   * processing within the adapter.
+   *
+   * If the adapter rejects or throws an error the record will enter an error state and the attributes
+   * that had attempted to be saved will still be considered dirty.
+   *
+   * ### InvalidErrors
+   *
+   * When rejecting a `createRecord` request due to validation issues during save (typically a 422 status code),
+   * you may throw an `InvalidError`.
+   *
+   * Throwing an `InvalidError` makes per-attribute errors available for records to use in the UI as needed.
+   * Records can also use this information to mark themselves as being in an `invalid` state.
+   * For more reading [see the RecordData Errors RFC](https://emberjs.github.io/rfcs/0465-record-data-errors.html)
+   *
+   * ```js
+   * let error = new Error(errorMessage);
+   *
+   * // these two properties combined
+   * // alert WarpDrive to this error being for
+   * // invalid properties on the record during
+   * // the request
+   * error.isAdapterError = true;
+   * error.code = 'InvalidError';
+   *
+   * // A JSON:API formatted array of errors
+   * // See https://jsonapi.org/format/#errors
+   * error.errors = [];
+   *
+   * throw error;
+   * ```
+   *
+   * @public
+   * @param {Store} store The store service that initiated the request being normalized
+   * @param {ModelSchema} schema An object with methods for accessing information about
+   *  the type, attributes and relationships of the primary type associated with the request.
+   * @param {Snapshot} snapshot
+   * @return {Promise} a promise resolving with resource data to feed to the associated serializer
+   */
+  createRecord(store: Store, schema: ModelSchema, snapshot: Snapshot): Promise<AdapterPayload>;
+  /**
+   * `adapter.updateRecord` takes a request to update a resource of a given `type` and should
+   * return a `Promise` which fulfills with the updated data for the resource.
+   *
+   * The response will be fed to the associated serializer's `normalizeResponse` method
+   *  with the `requestType` set to `updateRecord`, which should return a `JSON:API` document.
+   *
+   * The final result after normalization to `JSON:API` will be added to store via `store.push` where
+   * it will merge with any existing data for the record.
+   *
+   * ⚠️ If the adapter's response resolves to a false-y value, the associated `serializer.normalizeResponse`
+   * call will NOT be made. In this scenario you may need to do at least a minimum amount of response
+   * processing within the adapter.
+   *
+   * If the adapter rejects or throws an error the record will enter an error state and the attributes
+   * that had attempted to be saved will still be considered dirty.
+   *
+   * ### InvalidErrors
+   *
+   * When rejecting a `createRecord` request due to validation issues during save (typically a 422 status code),
+   * you may throw an `InvalidError`.
+   *
+   * Throwing an `InvalidError` makes per-attribute errors available for records to use in the UI as needed.
+   * Records can also use this information to mark themselves as being in an `invalid` state.
+   * For more reading [see the RecordData Errors RFC](https://emberjs.github.io/rfcs/0465-record-data-errors.html)
+   *
+   * ```js
+   * let error = new Error(errorMessage);
+   *
+   * // these two properties combined
+   * // alert WarpDrive to this error being for
+   * // invalid properties on the record during
+   * // the request
+   * error.isAdapterError = true;
+   * error.code = 'InvalidError';
+   *
+   * // A JSON:API formatted array of errors
+   * // See https://jsonapi.org/format/#errors
+   * error.errors = [];
+   *
+   * throw error;
+   * ```
+   *
+   * @public
+   * @param {Store} store The store service that initiated the request being normalized
+   * @param {ModelSchema} schema An object with methods for accessing information about
+   *  the type, attributes and relationships of the primary type associated with the request.
+   * @param {Snapshot} snapshot
+   */
+  updateRecord(store: Store, schema: ModelSchema, snapshot: Snapshot): Promise<AdapterPayload>;
+  /**
+   * `adapter.deleteRecord` takes a request to delete a resource of a given `type` and
+   * should return a `Promise` which resolves when that deletion is complete.
+   *
+   * Usually the response will be empty, but you may include additional updates in the
+   * response. The response will be fed to the associated serializer's `normalizeResponse` method
+   * with the `requestType` set to `deleteRecord`, which should return a `JSON:API` document.
+   *
+   * The final result after normalization to `JSON:API` will be added to store via `store.push` where
+   * it will merge with any existing data.
+   *
+   * ⚠️ If the adapter's response resolves to a false-y value, the associated `serializer.normalizeResponse`
+   * call will NOT be made. In this scenario you may need to do at least a minimum amount of response
+   * processing within the adapter.
+   *
+   * If the adapter rejects or errors the record will need to be saved again once the reason
+   * for the error is addressed in order to persist the deleted state.
+   *
+   * @public
+   * @param {Store} store The store service that initiated the request being normalized
+   * @param {ModelSchema} schema An object with methods for accessing information about
+   *  the type, attributes and relationships of the primary type associated with the request.
+   * @param {Snapshot} snapshot A Snapshot containing the record's current data
+   * @return
+   */
+  deleteRecord(store: Store, schema: ModelSchema, snapshot: Snapshot): Promise<AdapterPayload>;
+  /**
+   * `adapter.findBelongsTo` takes a request to fetch a related resource located at a
+   * `relatedLink` and should return a `Promise` which fulfills with data for a single
+   *  resource.
+   *
+   * ⚠️ This method is only called if the store previously received relationship information for a resource
+   * containing a [related link](https://jsonapi.org/format/#document-resource-object-related-resource-links).
+   *
+   * If the cache does not have a `link` for the relationship then `findRecord` will be used if a `type` and `id`
+   * for the related resource is known.
+   *
+   * The response will be fed to the associated serializer's `normalizeResponse` method
+   *  with the `requestType` set to `findBelongsTo`, which should return a `JSON:API` document.
+   *
+   * The final result after normalization to `JSON:API` will be added to store via `store.push` where
+   * it will merge with any existing data.
+   *
+   * ⚠️ If the adapter's response resolves to a false-y value, the associated `serializer.normalizeResponse`
+   * call will NOT be made. In this scenario you may need to do at least a minimum amount of response
+   * processing within the adapter.
+   *
+   * @public
+   * @optional
+   * @param {Store} store The store service that initiated the request being normalized
+   * @param {Snapshot} snapshot A Snapshot containing the parent record's current data
+   * @param {String} relatedLink The link at which the associated resource might be found
+   * @param {RelationshipSchema} relationship
+   * @return {Promise} a promise resolving with resource data to feed to the associated serializer
+   */
+  findBelongsTo?(store: Store, snapshot: Snapshot, relatedLink: string, relationship: LegacyRelationshipField): Promise<AdapterPayload>;
+  /**
+   * `adapter.findHasMany` takes a request to fetch a related resource collection located
+   *  at a `relatedLink` and should return a `Promise` which fulfills with data for that
+   *  collection.
+   *
+   * ⚠️ This method is only called if the store previously received relationship information for a resource
+   * containing a [related link](https://jsonapi.org/format/#document-resource-object-related-resource-links).
+   *
+   * If the cache does not have a `link` for the relationship but the `type` and `id` of
+   * related resources are known then `findRecord` will be used for each individual related
+   * resource.
+   *
+   * The response will be fed to the associated serializer's `normalizeResponse` method
+   *  with the `requestType` set to `findHasMany`, which should return a `JSON:API` document.
+   *
+   * The final result after normalization to `JSON:API` will be added to store via `store.push` where
+   * it will merge with any existing data.
+   *
+   * ⚠️ If the adapter's response resolves to a false-y value, the associated `serializer.normalizeResponse`
+   * call will NOT be made. In this scenario you may need to do at least a minimum amount of response
+   * processing within the adapter.
+   *
+   * @public
+   * @optional
+   * @param {Store} store The store service that initiated the request being normalized
+   * @param {Snapshot} snapshot A Snapshot containing the parent record's current data
+   * @param {String} relatedLink The link at which the associated resource collection might be found
+   * @param {RelationshipSchema} relationship
+   * @return {Promise} a promise resolving with resource data to feed to the associated serializer
+   */
+  findHasMany?(store: Store, snapshot: Snapshot, relatedLink: string, relationship: LegacyRelationshipField): Promise<AdapterPayload>;
+  /**
+   * ⚠️ This Method is only called if `coalesceFindRequests` is `true`. The array passed to it is determined
+   * by the adapter's `groupRecordsForFindMany` method, and will be called once per group returned.
+   *
+   * `adapter.findMany` takes a request to fetch a collection of resources and should return a
+   * `Promise` which fulfills with data for that collection.
+   *
+   * The response will be fed to the associated serializer's `normalizeResponse` method
+   *  with the `requestType` set to `findMany`, which should return a `JSON:API` document.
+   *
+   * The final result after normalization to `JSON:API` will be added to store via `store.push` where
+   * it will merge with any existing data.
+   *
+   * ⚠️ If the adapter's response resolves to a false-y value, the associated `serializer.normalizeResponse`
+   * call will NOT be made. In this scenario you may need to do at least a minimum amount of response
+   * processing within the adapter.
+   *
+   * See also `groupRecordsForFindMany` and `coalesceFindRequests`
+   *
+   * @public
+   * @optional
+   * @param {Store} store The store service that initiated the request being normalized
+   * @param {ModelSchema} schema An object with methods for accessing information about
+   *  the type, attributes and relationships of the primary type associated with the request.
+   * @param {Array<string>} ids An array of the ids of the resources to fetch
+   * @param {Array<Snapshot>} snapshots An array of snapshots of the available data for the resources to fetch
+   * @return {Promise} a promise resolving with resource data to feed to the associated serializer
+   */
+  findMany?(store: Store, schema: ModelSchema, ids: string[], snapshots: Snapshot[]): Promise<AdapterPayload>;
+  /**
+   * This method provides the ability to generate an ID to assign to a new record whenever `store.createRecord`
+   * is called if no `id` was provided.
+   *
+   * Alternatively you can pass an id into the call to `store.createRecord` directly.
+   *
+   * ```js
+   * let id = generateNewId(type);
+   * let newRecord = store.createRecord(type, { id });
+   * ```
+   *
+   * @public
+   * @optional
+   * @param {Store} store The store service that initiated the request being normalized
+   * @param {String} type The type (or modelName) of record being created
+   * @param properties the properties passed as the second arg to `store.createRecord`
+   * @return {String} a string ID that should be unique (no other models of `type` in the cache should have this `id`)
+   */
+  generateIdForRecord?(store: Store, type: string, properties: unknown): string;
+  /**
+   * If your adapter implements `findMany`, setting this to `true` will cause `findRecord`
+   * requests triggered within the same `runloop` to be coalesced into one or more calls
+   * to `adapter.findMany`. The number of calls made and the records contained in each call
+   * can be tuned by your adapter's `groupRecordsForHasMany` method.
+   *
+   * Implementing coalescing using this flag and the associated methods does not always offer
+   * the right level of correctness, timing control or granularity. If your application would
+   * be better suited coalescing across multiple types, coalescing for longer than a single runloop,
+   * or with a more custom request structure, coalescing within your application adapter may prove
+   * more effective.
+   *
+   * @property coalesceFindRequests [OPTIONAL]
+   * @public
+   * @optional
+   * @type {Boolean} true if the requests to find individual records should be coalesced, false otherwise
+   */
+  coalesceFindRequests?: boolean;
+  /**
+   * ⚠️ This Method is only called if `coalesceFindRequests` is `true`.
+   *
+   * This method allows for you to split pending requests for records into multiple `findMany`
+   * requests. It receives an array of snapshots where each snapshot represents a unique record
+   * requested via `store.findRecord` during the most recent `runloop` that was not found in the
+   * cache or needs to be reloaded. It should return an array of groups.
+   *
+   * A group is an array of snapshots meant to be fetched together by a single `findMany` request.
+   *
+   * By default if this method is not implemented WarpDrive will call `findMany` once with all
+   * requested records as a single group when `coalesceFindRequests` is `true`.
+   *
+   * See also `findMany` and `coalesceFindRequests`
+   *
+   * @public
+   * @optional
+   * @param {Store} store The store service that initiated the request being normalized
+   * @param {Array<Snapshot>} snapshots An array of snapshots
+   * @return {Array<Array<Snapshot>>} An array of Snapshot arrays
+   */
+  groupRecordsForFindMany?(store: Store, snapshots: Snapshot[]): Group[];
+  /**
+   * When a record is already available in the store and is requested again via `store.findRecord`,
+   * and `reload` is not specified as an option in the request, this method is called to determine
+   * whether the record should be reloaded prior to returning the result.
+   *
+   * If `reload` is specified as an option in the request (`true` or `false`) this method will not
+   * be called.
+   *
+   * ```js
+   * store.findRecord('user', '1', { reload: false })
+   * ```
+   *
+   * The default behavior if this method is not implemented and the option is not specified is to
+   * not reload, the same as a return of `false`.
+   *
+   * See also the documentation for `shouldBackgroundReloadRecord` which defaults to `true`.
+   *
+   * @public
+   * @optional
+   * @param {Store} store The store service that initiated the request being normalized
+   * @param {Snapshot} snapshot A Snapshot containing the record's current data
+   * @return {Boolean} true if the record should be reloaded immediately, false otherwise
+   */
+  shouldReloadRecord?(store: Store, snapshot: Snapshot): boolean;
+  /**
+   * When `store.findAll(<type>)` is called without a `reload` option, the adapter
+   * is presented the opportunity to trigger a new request for records of that type.
+   *
+   * If `reload` is specified as an option in the request (`true` or `false`) this method will not
+   * be called.
+   *
+   * ```js
+   * store.findAll('user', { reload: false })
+   * ```
+   *
+   * The default behavior if this method is not implemented and the option is not specified is to
+   * not reload, the same as a return of `false`.
+   *
+   * Note: the Promise returned by `store.findAll` resolves to the same LiveArray instance
+   * returned by `store.peekAll` for that type, and will include all records in the store for
+   * the given type, including any previously existing records not returned by the reload request.
+   *
+   * @public
+   * @optional
+   * @param {Store} store The store service that initiated the request being normalized
+   * @param {SnapshotRecordArray} snapshotArray
+   * @return {Boolean} true if the a new request for all records of the type in SnapshotRecordArray should be made immediately, false otherwise
+   */
+  shouldReloadAll?(store: Store, snapshotArray: SnapshotRecordArray): boolean;
+  /**
+   * When a record is already available in the store and is requested again via `store.findRecord`,
+   * and the record does not need to be reloaded prior to return, this method provides the ability
+   * to specify whether a refresh of the data for the reload should be scheduled to occur in the background.
+   *
+   * Users may explicitly declare a record should/should not be background reloaded by passing
+   * `backgroundReload: true` or `backgroundReload: false` as an option to the request respectively.
+   *
+   * ```js
+   * store.findRecord('user', '1', { backgroundReload: false })
+   * ```
+   *
+   * If the `backgroundReload` option is not present, this method will be called to determine whether
+   * a backgroundReload should be performed.
+   *
+   * The default behavior if this method is not implemented and the option was not specified is to
+   * background reload, the same as a return of `true`.
+   *
+   * @public
+   * @optional
+   * @param {Store} store The store service that initiated the request being normalized
+   * @param {Snapshot} snapshot A Snapshot containing the record's current data
+   * @return {Boolean} true if the record should be reloaded in the background, false otherwise
+   */
+  shouldBackgroundReloadRecord?(store: Store, snapshot: Snapshot): boolean;
+  /**
+   * When `store.findAll(<type>)` is called and a `reload` is not initiated, the adapter
+   * is presented the opportunity to trigger a new non-blocking (background) request for
+   * records of that type
+   *
+   * Users may explicitly declare that this background request should/should not occur by passing
+   * `backgroundReload: true` or `backgroundReload: false` as an option to the request respectively.
+   *
+   * ```js
+   * store.findAll('user', { backgroundReload: false })
+   * ```
+   *
+   * The default behavior if this method is not implemented and the option is not specified is to
+   * perform a reload, the same as a return of `true`.
+   *
+   * @public
+   * @optional
+   * @param {Store} store The store service that initiated the request being normalized
+   * @param {SnapshotRecordArray} snapshotArray
+   * @return {Boolean} true if the a new request for all records of the type in SnapshotRecordArray should be made in the background, false otherwise
+   */
+  shouldBackgroundReloadAll?(store: Store, snapshotArray: SnapshotRecordArray): boolean;
+  /**
+   * In some situations the adapter may need to perform cleanup when destroyed,
+   * that cleanup can be done in `destroy`.
+   *
+   * If not implemented, the store does not inform the adapter of destruction.
+   *
+   * @public
+   * @optional
+   */
+  destroy?(): void;
+}
+//#endregion
+//#region src/compat/legacy-network-handler/minimum-serializer-interface.d.ts
+/**
+ * Options accepted by {@link MinimumSerializerInterface.serialize | serialize}
+ * and related legacy serializer methods.
+ */
+type SerializerOptions = {
+  /**
+   * whether the resource's id should be included in the serialized output
+   */
+  includeId?: boolean;
+};
+/**
+* :::danger
+⚠️ **This is LEGACY documentation** for a feature that is no longer encouraged to be used.
+If starting a new app or thinking of implementing a new adapter, consider writing a
+{@link Handler} instead to be used with the {@link RequestManager}
+:::
+
+The following documentation describes the methods an application
+serializer should implement with descriptions around when an
+application might expect these methods to be called.
+
+Methods that are not required are marked as **optional**.
+
+@public
+*/
+interface MinimumSerializerInterface {
+  /**
+   * This method is responsible for normalizing the value resolved from the promise returned
+   * by an Adapter request into the format expected by the `Store`.
+   *
+   * The output should be a [JSON:API Document](https://jsonapi.org/format/#document-structure)
+   * with the following additional restrictions:
+   *
+   * - `type` should be formatted in the `singular` `dasherized` `lowercase` form
+   * - `members` (the property names of attributes and relationships) should be formatted
+   *    to match their definition in the corresponding `Model` definition. Typically this
+   *    will be `camelCase`.
+   * - [`lid`](https://github.com/emberjs/rfcs/blob/main/text/0403-ember-data-identifiers.md) is
+   *    a valid optional sibling to `id` and `type` in both [Resources](https://jsonapi.org/format/#document-resource-objects)
+   *    and [Resource Identifier Objects](https://jsonapi.org/format/#document-resource-identifier-objects)
+   *
+   * @public
+   * @param store The store service that initiated the request being normalized
+   * @param schema An object with methods for accessing information about
+   *  the type, attributes and relationships of the primary type associated with the request.
+   * @param rawPayload The raw JSON response data returned from an API request.
+   *  This correlates to the value the promise returned by the adapter method that performed
+   *  the request resolved to.
+   * @param id For a findRecord request, this is the id initially provided
+   *  in the call to store.findRecord. Else this value is null.
+   * @param requestType The type of request the Adapter had been asked to perform.
+   *
+   * @return a document following the structure of a [{json:api} Document](https://jsonapi.org/format/#document-structure).
+   */
+  normalizeResponse(store: Store, schema: ModelSchema, rawPayload: AdapterPayload, id: string | null, requestType: "findRecord" | "queryRecord" | "findAll" | "findBelongsTo" | "findHasMany" | "findMany" | "query" | "createRecord" | "deleteRecord" | "updateRecord"): JsonApiDocument;
+  /**
+   * This method is responsible for serializing an individual record
+   * via a {@link Snapshot} into the format expected by the API.
+   *
+   * This method is called by `snapshot.serialize()`.
+   *
+   * When using `Model`, this method is called by `record.serialize()`.
+   *
+   * When using `JSONAPIAdapter` or `RESTAdapter` this method is called
+   * by `updateRecord` and `createRecord` if `Serializer.serializeIntoHash`
+   * is not implemented.
+   *
+   * @public
+   * @param snapshot A Snapshot for the record to serialize
+   */
+  serialize(snapshot: Snapshot, options?: SerializerOptions): ObjectValue;
+  /**
+   * This method is intended to normalize data into a [JSON:API Document](https://jsonapi.org/format/#document-structure)
+   * with a data member containing a single [Resource](https://jsonapi.org/format/#document-resource-objects).
+   *
+   * - `type` should be formatted in the singular, dasherized and lowercase form
+   * - `members` (the property names of attributes and relationships) should be formatted
+   *    to match their definition in the corresponding `Model` definition. Typically this
+   *    will be `camelCase`.
+   * - [`lid`](https://github.com/emberjs/rfcs/blob/main/text/0403-ember-data-identifiers.md) is
+   *    a valid optional sibling to `id` and `type` in both [Resources](https://jsonapi.org/format/#document-resource-objects)
+   *    and [Resource Identifier Objects](https://jsonapi.org/format/#document-resource-identifier-objects)
+   *
+   * This method is called by the `Store` when `store.normalize(modelName, payload)` is
+   * called. It is recommended to use `store.serializerFor(modelName).normalizeResponse`
+   * over `store.normalize`.
+   *
+   * This method may be called when also using the `RESTSerializer`
+   * when `serializer.pushPayload` is called by `store.pushPayload`.
+   * However, it is recommended to use `store.push` over `store.pushPayload` after normalizing
+   * the payload directly.
+   *
+   * Example:
+   * ```js
+   * function pushPayload(store, modelName, rawPayload) {
+   *   const ModelClass = store.modelFor(modelName);
+   *   const serializer = store.serializerFor(modelName);
+   *   const jsonApiPayload = serializer.normalizeResponse(store, ModelClass, rawPayload, null, 'query');
+   *
+   *   return store.push(jsonApiPayload);
+   * }
+   * ```
+   *
+   * This method may be called when also using the `JSONAPISerializer`
+   * when normalizing included records. If mixing serializer usage in this way
+   * we recommend implementing this method, but caution that it may lead
+   * to unexpected mixing of formats.
+   *
+   * This method may also be called when normalizing embedded relationships when
+   * using the `EmbeddedRecordsMixin`. If using this mixin in a serializer in
+   * your application we recommend implementing this method, but caution that
+   * it may lead to unexpected mixing of formats.
+   *
+   * @public
+   * @optional
+   * @param schema An object with methods for accessing information about
+   *  the type, attributes and relationships of the primary type associated with the request.
+   * @param rawPayload Some raw JSON data to be normalized into a JSON:API Resource.
+   * @param prop When called by the EmbeddedRecordsMixin this param will be the
+   *  property at which the object provided as rawPayload was found.
+   * @return A JSON:API Document containing a single JSON:API Resource as its primary data.
+   */
+  normalize?(schema: ModelSchema, rawPayload: ObjectValue, prop?: string): SingleResourceDocument;
+  /**
+   * When using `JSONAPIAdapter` or `RESTAdapter` this method is called
+   * by `adapter.updateRecord` and `adapter.createRecord` if `serializer.serializeIntoHash`
+   * is implemented. If this method is not implemented, `serializer.serialize`
+   * will be called in this case.
+   *
+   * You can use this method to customize the root keys serialized into the payload.
+   * The hash property should be modified by reference.
+   *
+   * For instance, your API may expect resources to be keyed by underscored type in the payload:
+   *
+   * ```js
+   * {
+   *   _user: {
+   *     type: 'user',
+   *     id: '1'
+   *   }
+   * }
+   * ```
+   *
+   * Which when using these adapters can be achieved by implementing this method similar
+   * to the following:
+   *
+   * ```js
+   * serializeIntoHash(hash, ModelClass, snapshot, options) {
+   *   hash[`_${snapshot.modelName}`] = this.serialize(snapshot, options).data;
+   * }
+   * ```
+   *
+   * @public
+   * @optional
+   * @param hash A top most object of the request payload onto
+   *  which to append the serialized record
+   * @param schema An object with methods for accessing information about
+   *  the type, attributes and relationships of the primary type associated with the request.
+   * @param snapshot A Snapshot for the record to serialize
+   */
+  serializeIntoHash?(hash: object, schema: ModelSchema, snapshot: Snapshot, options?: SerializerOptions): void;
+  /**
+   * This method allows for normalization of data when `store.pushPayload` is called
+   * and should be implemented if you want to use that method.
+   *
+   * The method is responsible for pushing new data to the store using `store.push`
+   * once any necessary normalization has occurred, and no data in the store will be
+   * updated unless it does so.
+   *
+   * The normalized form pushed to the store should be a [JSON:API Document](https://jsonapi.org/format/#document-structure)
+   * with the following additional restrictions:
+   *
+   * - `type` should be formatted in the singular, dasherized and lowercase form
+   * - `members` (the property names of attributes and relationships) should be formatted
+   *    to match their definition in the corresponding `Model` definition. Typically this
+   *    will be `camelCase`.
+   * - [`lid`](https://github.com/emberjs/rfcs/blob/main/text/0403-ember-data-identifiers.md) is
+   *    a valid optional sibling to `id` and `type` in both [Resources](https://jsonapi.org/format/#document-resource-objects)
+   *    and [Resource Identifier Objects](https://jsonapi.org/format/#document-resource-identifier-objects)
+   *
+   * If you need better control over normalization or want access to the records being added or updated
+   * in the store, we recommended using `store.push` over `store.pushPayload` after normalizing
+   * the payload directly. This can even take advantage of an existing serializer for the format
+   * the data is in, for example:
+   *
+   * ```js
+   * function pushPayload(store, modelName, rawPayload) {
+   *   const ModelClass = store.modelFor(modelName);
+   *   const serializer = store.serializerFor(modelName);
+   *   const jsonApiPayload = serializer.normalizeResponse(store, ModelClass, rawPayload, null, 'query');
+   *
+   *   return store.push(jsonApiPayload);
+   * }
+   * ```
+   *
+   * @public
+   * @optional
+   * @param store The store service that initiated the request being normalized
+   * @param rawPayload The raw JSON response data returned from an API request.
+   *  This JSON should be in the API format expected by the serializer.
+   */
+  pushPayload?(store: Store, rawPayload: ObjectValue): void;
+  /**
+   * In some situations the serializer may need to perform cleanup when destroyed,
+   * that cleanup can be done in `destroy`.
+   *
+   * If not implemented, the store does not inform the serializer of destruction.
+   *
+   * @public
+   * @optional
+   */
+  destroy?(): void;
+}
+//#endregion
+//#region src/compat/legacy-network-handler/snapshot.d.ts
+type RecordId = string | null;
+/**
+Snapshot is not directly instantiable.
+Instances are provided to a consuming application's
+adapters and serializers for certain requests.
+
+Snapshots are only available when using `@ember-data/legacy-compat`
+for legacy compatibility with adapters and serializers.
+
+For serialization of records in modern paradigms, request data from
+the cache or off the record directly.
+
+@hideconstructor
+@public
+*/
+declare class Snapshot<R = unknown> {
+  /** @internal */
+  private __attributes;
+  /** @internal */
+  private _belongsToRelationships;
+  /** @internal */
+  private _belongsToIds;
+  /** @internal */
+  private _hasManyRelationships;
+  /** @internal */
+  private _hasManyIds;
+  /** @internal */
+  private _changedAttributes;
+  /** @internal */
+  private _store;
+  /**
+	The unique ResourceKey associated with this Snapshot.
+	
+	@public
+	*/
+  identifier: ResourceKey$1<R extends TypedRecordInstance ? TypeFromInstance<R> : string>;
+  /**
+	The ResourceType of the underlying record for this Snapshot, as a string.
+	
+	@public
+	*/
+  modelName: R extends TypedRecordInstance ? TypeFromInstance<R> : string;
+  /**
+	The id of the snapshot's underlying record
+	
+	Example
+	
+	```js
+	// store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });
+	postSnapshot.id; // => '1'
+	```
+	
+	@public
+	*/
+  id: string | null;
+  /**
+	If `include` was passed to the options for the request, the value
+	would be available here.
+	
+	@public
+	*/
+  include?: string | string[];
+  /**
+	The adapterOptions passed to the request which generated this Snapshot, if any
+	
+	@public
+	*/
+  adapterOptions?: Record<string, unknown>;
+  constructor(options: FindRecordOptions, identifier: ResourceKey$1<R extends TypedRecordInstance ? TypeFromInstance<R> : string>, store: Store);
+  /**
+	The underlying record for this snapshot. Can be used to access methods and
+	properties defined on the record.
+	
+	```js
+	const someValue = snapshot.record.someProp;
+	```
+	
+	@property record
+	@public
+	*/
+  get record(): R | null;
+  /** @internal */
+  private get _attributes();
+  get isNew(): boolean;
+  /**
+	Returns the value of an attribute.
+	
+	Example
+	
+	```javascript
+	// store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });
+	postSnapshot.attr('author'); // => 'Tomster'
+	postSnapshot.attr('title'); // => 'Ember.js rocks'
+	```
+	
+	Note: Values are loaded eagerly and cached when the snapshot is created.
+	
+	@return The attribute value or undefined
+	@public
+	*/
+  attr(keyName: keyof R & string): unknown;
+  /**
+	Returns all attributes and their corresponding values.
+	
+	::: warning ⚠️ WARNING
+	Attributes are SHALLOW copied from the cache.
+	Because they are NOT deep copied from the cache, mutating
+	any object or array fields will cause unintended side-effects
+	and bugs.
+	:::
+	
+	Example
+	
+	```js
+	// store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });
+	postSnapshot.attributes(); // => { author: 'Tomster', title: 'Ember.js rocks' }
+	```
+	
+	@return All attributes of the current snapshot
+	@public
+	*/
+  attributes(): Record<keyof R & string, unknown>;
+  /**
+	Returns all changed attributes and their old and new values.
+	
+	Example
+	
+	```js
+	// store.push('post', { id: 1, author: 'Tomster', title: 'Ember.js rocks' });
+	postModel.set('title', 'Ember.js rocks!');
+	postSnapshot.changedAttributes(); // => { title: ['Ember.js rocks', 'Ember.js rocks!'] }
+	```
+	
+	@return All changed attributes of the current snapshot
+	@public
+	*/
+  changedAttributes(): ChangedAttributesHash;
+  /**
+	Returns the current value of a belongsTo relationship.
+	
+	`belongsTo` takes an optional hash of options as a second parameter,
+	currently supported options are:
+	
+	- `id`: set to `true` if you only want the ID of the related record to be
+	returned.
+	
+	Example
+	
+	```js
+	// store.push('post', { id: 1, title: 'Hello World' });
+	// store.createRecord('comment', { body: 'Lorem ipsum', post: post });
+	commentSnapshot.belongsTo('post'); // => Snapshot
+	commentSnapshot.belongsTo('post', { id: true }); // => '1'
+	
+	// store.push('comment', { id: 1, body: 'Lorem ipsum' });
+	commentSnapshot.belongsTo('post'); // => undefined
+	```
+	
+	Calling `belongsTo` will return a new Snapshot as long as there's any known
+	data for the relationship available, such as an ID. If the relationship is
+	known but unset, `belongsTo` will return `null`. If the contents of the
+	relationship is unknown `belongsTo` will return `undefined`.
+	
+	Note: Relationships are loaded lazily and cached upon first access.
+	
+	@public
+	@return A snapshot or ID of a known relationship or null if the
+	relationship is known but unset. undefined will be returned if the
+	contents of the relationship are unknown.
+	*/
+  belongsTo(keyName: string, options?: {
+    id?: boolean;
+  }): Snapshot | RecordId | undefined;
+  /**
+	Returns the current value of a hasMany relationship.
+	
+	`hasMany` takes an optional hash of options as a second parameter,
+	currently supported options are:
+	
+	- `ids`: set to `true` if you only want the IDs of the related records to be
+	returned.
+	
+	Example
+	
+	```javascript
+	// store.push('post', { id: 1, title: 'Hello World', comments: [2, 3] });
+	postSnapshot.hasMany('comments'); // => [Snapshot, Snapshot]
+	postSnapshot.hasMany('comments', { ids: true }); // => ['2', '3']
+	
+	// store.push('post', { id: 1, title: 'Hello World' });
+	postSnapshot.hasMany('comments'); // => undefined
+	```
+	
+	Note: Relationships are loaded lazily and cached upon first access.
+	
+	@public
+	@return An array of snapshots or IDs of a known
+	relationship or an empty array if the relationship is known but unset.
+	undefined will be returned if the contents of the relationship is unknown.
+	*/
+  hasMany(keyName: string, options?: {
+    ids?: boolean;
+  }): RecordId[] | Snapshot[] | undefined;
+  /**
+	Iterates through all the attributes of the model, calling the passed
+	function on each attribute.
+	
+	Example
+	
+	```javascript
+	snapshot.eachAttribute(function(name, meta) {
+	// ...
+	});
+	```
+	
+	@param callback the callback to execute
+	@param binding the optional value to which the callback's `this` should be bound
+	@public
+	*/
+  eachAttribute(callback: (key: string, meta: LegacyAttributeField) => void, binding?: unknown): void;
+  /**
+	Iterates through all the relationships of the model, calling the passed
+	function on each relationship.
+	
+	Example
+	
+	```javascript
+	snapshot.eachRelationship(function(name, relationship) {
+	// ...
+	});
+	```
+	
+	@param callback the callback to execute
+	@param binding the optional value to which the callback's `this` should be bound
+	@public
+	*/
+  eachRelationship(callback: (key: string, meta: LegacyRelationshipField) => void, binding?: unknown): void;
+  /**
+	Serializes the snapshot using the serializer for the model.
+	
+	Example
+	
+	```js [app/adapters/application.js]
+	import Adapter from '@ember-data/adapter';
+	
+	export default Adapter.extend({
+	createRecord(store, type, snapshot) {
+	let data = snapshot.serialize({ includeId: true });
+	let url = `/${type.modelName}`;
+	
+	return fetch(url, {
+	method: 'POST',
+	body: data,
+	}).then((response) => response.json())
+	}
+	});
+	```
+	
+	@return an object whose values are primitive JSON values only
+	@public
+	*/
+  serialize(options?: SerializerOptions): unknown;
+}
+//#endregion
+//#region src/compat/legacy-network-handler/snapshot-record-array.d.ts
+/**
+SnapshotRecordArray is not directly instantiable.
+Instances are provided to consuming application's
+adapters for certain `findAll` requests.
+
+@hideconstructor
+@public
+*/
+declare class SnapshotRecordArray {
+  /**
+   * An array of snapshots
+   *
+   * @internal
+   */
+  private _snapshots;
+  /** @internal */
+  private _type;
+  /**
+   * The ResourceType of the underlying records for the {@link Snapshot | Snapshots} in the array
+   */
+  modelName: string;
+  /** @internal */
+  private __store;
+  /**
+	*  A hash of adapter options passed into the store method for this request.
+	
+	Example
+	
+	```js [app/adapters/post.js]
+	import MyCustomAdapter from './custom-adapter';
+	
+	export default class PostAdapter extends MyCustomAdapter {
+	findAll(store, type, sinceToken, snapshotRecordArray) {
+	if (snapshotRecordArray.adapterOptions.subscribe) {
+	// ...
+	}
+	// ...
+	}
+	}
+	```
+	*/
+  adapterOptions?: Record<string, unknown>;
+  /**
+	* The relationships to include for this request.
+	
+	Example
+	
+	```js [app/adapters/application.js]
+	import Adapter from '@ember-data/adapter';
+	
+	export default class ApplicationAdapter extends Adapter {
+	findAll(store, type, snapshotRecordArray) {
+	let url = `/${type.modelName}?include=${encodeURIComponent(snapshotRecordArray.include)}`;
+	
+	return fetch(url).then((response) => response.json())
+	}
+	}
+	```
+	*/
+  include?: string | string[];
+  /**
+	SnapshotRecordArray is not directly instantiable.
+	Instances are provided to consuming application's
+	adapters and serializers for certain requests.
+	
+	@private
+	@constructor
+	@param {Store} store
+	@param {String} type
+	@param options
+	*/
+  constructor(store: Store, type: string, options?: FindAllOptions);
+  /**
+	An array of records
+	
+	@internal
+	*/
+  get _recordArray(): LegacyLiveArray;
+  /**
+	Number of records in the array
+	
+	Example
+	
+	```js [app/adapters/post.js]
+	import JSONAPIAdapter from '@ember-data/adapter/json-api';
+	
+	export default class PostAdapter extends JSONAPIAdapter {
+	shouldReloadAll(store, snapshotRecordArray) {
+	return !snapshotRecordArray.length;
+	}
+	});
+	```
+	*/
+  get length(): number;
+  /**
+	Get snapshots of the underlying record array
+	
+	Example
+	
+	```js [app/adapters/post.js]
+	import JSONAPIAdapter from '@ember-data/adapter/json-api';
+	
+	export default class PostAdapter extends JSONAPIAdapter {
+	shouldReloadAll(store, snapshotArray) {
+	let snapshots = snapshotArray.snapshots();
+	
+	return snapshots.any(function(ticketSnapshot) {
+	let timeDiff = moment().diff(ticketSnapshot.attr('lastAccessedAt'), 'minutes');
+	if (timeDiff > 20) {
+	return true;
+	} else {
+	return false;
+	}
+	});
+	}
+	}
+	```
+	
+	@public
+	@return Array of snapshots
+	*/
+  snapshots(): Snapshot[];
+}
+//#endregion
+//#region src/compat/legacy-network-handler/fetch-manager.d.ts
+type Deferred<T> = ReturnType<typeof createDeferred<T>>;
+declare const SaveOp: "___(unique) Symbol(SaveOp)";
+type FetchMutationOptions = FindRecordOptions & {
+  [SaveOp]: "createRecord" | "deleteRecord" | "updateRecord";
+};
+interface PendingFetchItem {
+  identifier: PersistedResourceKey;
+  queryRequest: Request;
+  resolver: Deferred<any>;
+  options: FindRecordOptions;
+  trace?: unknown;
+  promise: Promise<PersistedResourceKey>;
+}
+/**
+ * @private
+ */
+declare class FetchManager {
+  /**
+   * @internal
+   */
+  isDestroyed: boolean;
+  /** @internal */
+  private requestCache;
+  /**
+   * @internal
+   */
+  _pendingFetch: Map<string, Map<PersistedResourceKey, PendingFetchItem[]>>;
+  /** @internal */
+  private _store;
+  constructor(store: Store);
+  createSnapshot<T>(identifier: ResourceKey$1<TypeFromInstance<T>>, options?: FindRecordOptions): Snapshot<T>;
+  createSnapshot(identifier: ResourceKey$1, options?: FindRecordOptions): Snapshot;
+  /**
+	This method is called by `record.save`, and gets passed a
+	resolver for the promise that `record.save` returns.
+	
+	It schedules saving to happen at the end of the run loop.
+	
+	@private
+	*/
+  scheduleSave(identifier: ResourceKey$1, options: FetchMutationOptions): Promise<null | SingleResourceDocument>;
+  scheduleFetch(identifier: PersistedResourceKey, options: FindRecordOptions, request: ImmutableRequestInfo): Promise<PersistedResourceKey>;
+  getPendingFetch(identifier: PersistedResourceKey, options: FindRecordOptions): Promise<PersistedResourceKey> | undefined;
+  flushAllPendingFetches(): void;
+  fetchDataIfNeededForIdentifier(identifier: PersistedResourceKey, options: FindRecordOptions | undefined, request: ImmutableRequestInfo): Promise<PersistedResourceKey>;
+  destroy(): void;
+}
+//#endregion
+//#region src/compat/-private.d.ts
+declare function upgradeStore(store: Store): asserts store is CompatStore;
+//#endregion
+//#region src/compat/legacy-network-handler/legacy-network-handler.d.ts
+/**
+ * A {@link Handler} that fulfills legacy `findRecord`/`findAll`/`query`/
+ * `queryRecord`/`findBelongsTo`/`findHasMany`/`createRecord`/`updateRecord`/
+ * `deleteRecord` requests using the store's configured {@link MinimumAdapterInterface | adapter}
+ * and {@link MinimumSerializerInterface | serializer}, passing any other
+ * request through to the next handler unchanged.
+ */
+declare const LegacyNetworkHandler: Handler;
+//#endregion
+//#region src/compat.d.ts
+/**
+ * Extends the signature of {@link Store} with additional
+ * methods available when using the legacy network layer.
+ *
+ * @public
+ * @noInheritDoc
+ * @legacy
+ */
+interface LegacyStoreCompat extends Store {
+  /**
+   * @private
+   */
+  _fetchManager: FetchManager;
+  /**
+   * Returns the adapter instance for the given model type, instantiating
+   * it (and caching the instance) if necessary. See {@link adapterFor}.
+   */
+  adapterFor(this: Store, modelName: string): MinimumAdapterInterface;
+  /**
+   * Same as the single-argument overload, but returns `undefined` instead
+   * of throwing/asserting when `_allowMissing` is `true` and no adapter
+   * is found.
+   */
+  adapterFor(this: Store, modelName: string, _allowMissing: true): MinimumAdapterInterface | undefined;
+  /**
+   * Returns the serializer instance for the given model type, instantiating
+   * it (and caching the instance) if necessary. See {@link serializerFor}.
+   */
+  serializerFor<K extends string>(modelName: K, _allowMissing?: boolean): MinimumSerializerInterface | null;
+  /**
+   * Normalizes a payload for the given model type using its serializer.
+   * See {@link normalize}.
+   */
+  normalize(modelName: string, payload: ObjectValue): ObjectValue;
+  /**
+   * Pushes a payload into the store using the appropriate serializer to
+   * normalize it first. See {@link pushPayload}.
+   */
+  pushPayload(modelName: string, payload: ObjectValue): void;
+  /**
+   * Serializes a record using its serializer. See {@link serializeRecord}.
+   */
+  serializeRecord(record: unknown, options?: SerializerOptions): unknown;
+  /**
+   * @private
+   */
+  _adapterCache: Record<string, MinimumAdapterInterface & {
+    store: Store;
+  }>;
+  /**
+   * @private
+   */
+  _serializerCache: Record<string, MinimumSerializerInterface & {
+    store: Store;
+  }>;
+}
+/**
+ * @deprecated - use {@link LegacyStoreCompat} instead
+ */
+type CompatStore = LegacyStoreCompat;
+/**
+Returns an instance of the adapter for a given type. For
+example, `adapterFor('person')` will return an instance of
+the adapter located at `app/adapters/person.js`
+
+If no `person` adapter is found, this method will look
+for an `application` adapter (the default adapter for
+your entire application).
+
+@public
+@param modelName
+*/
+declare function adapterFor(this: Store, modelName: string): MinimumAdapterInterface;
+declare function adapterFor(this: Store, modelName: string, _allowMissing: true): MinimumAdapterInterface | undefined;
+/**
+Returns an instance of the serializer for a given type. For
+example, `serializerFor('person')` will return an instance of
+`App.PersonSerializer`.
+
+If no `App.PersonSerializer` is found, this method will look
+for an `App.ApplicationSerializer` (the default serializer for
+your entire application).
+
+If a serializer cannot be found on the adapter, it will fall back
+to an instance of `JSONSerializer`.
+
+@public
+@param modelName the record to serialize
+*/
+declare function serializerFor(this: Store, modelName: string): MinimumSerializerInterface | null;
+/**
+`normalize` converts a json payload into the normalized form expected by
+{@link Store.push | push} using the serializer specified by `modelName`
+
+:::warning
+Generally it would be better to invoke the serializer yourself directly,
+or write a more specialized normalization utility.
+:::
+
+Example
+
+```js
+socket.on('message', function(message) {
+let modelName = message.model;
+let data = message.data;
+store.push(store.normalize(modelName, data));
+});
+```
+
+@legacy
+@public
+@param modelName The name of the model type for this payload
+@return The normalized payload
+*/
+declare function normalize(this: Store, modelName: string, payload: ObjectValue): SingleResourceDocument;
+/**
+Push some raw data into the store.
+
+This method can be used both to push in brand new
+records, as well as to update existing records. You
+can push in more than one type of object at once.
+All objects should be in the format expected by the
+serializer.
+
+```js [app/serializers/application.js]
+import RESTSerializer from '@warp-drive/legacy/serializer/rest';
+
+export default class ApplicationSerializer extends RESTSerializer;
+```
+
+```js
+let pushData = {
+posts: [
+{ id: 1, postTitle: "Great post", commentIds: [2] }
+],
+comments: [
+{ id: 2, commentBody: "Insightful comment" }
+]
+}
+
+store.pushPayload(pushData);
+```
+
+By default, the data will be deserialized using a default
+serializer (the application serializer if it exists).
+
+Alternatively, `pushPayload` will accept a model type which
+will determine which serializer will process the payload.
+
+```js [app/serializers/application.js]
+import RESTSerializer from '@warp-drive/legacy/serializer/rest';
+
+export default class ApplicationSerializer extends RESTSerializer;
+```
+
+```js [app/serializers/post.js]
+import JSONSerializer from '@warp-drive/legacy/serializer/json';
+
+export default JSONSerializer;
+```
+
+```js
+store.pushPayload(pushData); // Will use the application serializer
+store.pushPayload('post', pushData); // Will use the post serializer
+```
+
+@public
+@param modelName Optionally, a model type used to determine which serializer will be used
+@param inputPayload
+*/
+declare function pushPayload(this: Store, modelName: string, inputPayload: ObjectValue): void;
+/**
+ * Serializes a record using the store's legacy network layer, as with
+ * {@link LegacyStoreCompat.serializeRecord | store.serializeRecord}.
+ */
+declare function serializeRecord(this: Store, record: unknown, options?: SerializerOptions): unknown;
+/**
+ * Destroys any adapters/serializers the legacy network layer has created
+ * for this store, invoked when the store itself is destroyed.
+ */
+declare function cleanup(this: Store): void;
+//#endregion
+export { AdapterPayload as _, normalize as a, serializerFor as c, FetchManager as d, SaveOp as f, SerializerOptions as g, MinimumSerializerInterface as h, cleanup as i, LegacyNetworkHandler as l, Snapshot as m, LegacyStoreCompat as n, pushPayload as o, SnapshotRecordArray as p, adapterFor as r, serializeRecord as s, CompatStore as t, upgradeStore as u, MinimumAdapterInterface as v };
+//# sourceMappingURL=compat-BbNNmTM-.d.ts.map