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

package/dist/adapter-CARrK3-8.d.ts

@@ -0,0 +1,784 @@
+import { _ as AdapterPayload, g as SerializerOptions, m as Snapshot, p as SnapshotRecordArray, v as MinimumAdapterInterface } from "./compat-BbNNmTM-.js";
+import { Store } from "@warp-drive/core";
+import EmberObject from "@ember/object";
+import Mixin from "@ember/object/mixin";
+import { ModelSchema } from "@warp-drive/core/types";
+//#region src/adapter/-private/build-url-mixin.d.ts
+/**
+ * The methods provided by the `BuildURLMixin` mixin (see the exported
+ * `BuildURLMixin` {@link Mixin} below).
+ *
+ * See also {@link MixtBuildURLMixin}, the interface used to type `this`
+ * within these methods.
+ */
+interface BuildURLMixin {
+  /**
+   * Builds a URL for a given type and optional ID.
+   *
+   * By default, it pluralizes the type's name (for example, 'post'
+   * becomes 'posts' and 'person' becomes 'people'). To override the
+   * pluralization see {@link BuildURLMixin.pathForType | pathForType}.
+   *
+   * If an ID is specified, it adds the ID to the path generated
+   * for the type, separated by a `/`.
+   *
+   * This overload builds the URL for a `store.findRecord(type, id)` call.
+   *
+   * @public
+   */
+  buildURL(this: MixtBuildURLMixin, modelName: string, id: string, snapshot: Snapshot, requestType: "findRecord"): string;
+  /**
+   * Builds the URL for a `store.findAll(type)` call.
+   *
+   * @public
+   */
+  buildURL(this: MixtBuildURLMixin, modelName: string, id: null, snapshot: SnapshotRecordArray, requestType: "findAll"): string;
+  /**
+   * Builds the URL for a `store.query(type, query)` call.
+   *
+   * @public
+   */
+  buildURL(this: MixtBuildURLMixin, modelName: string, id: null, snapshot: null, requestType: "query", query: Record<string, unknown>): string;
+  /**
+   * Builds the URL for a `store.queryRecord(type, query)` call.
+   *
+   * @public
+   */
+  buildURL(this: MixtBuildURLMixin, modelName: string, id: null, snapshot: null, requestType: "queryRecord", query: Record<string, unknown>): string;
+  /**
+   * Builds the URL for coalescing multiple `store.findRecord(type, id)`
+   * records into 1 request when the adapter's `coalesceFindRequests`
+   * property is `true`. The `id` and `snapshot` parameters will be
+   * arrays of ids and snapshots.
+   *
+   * @public
+   */
+  buildURL(this: MixtBuildURLMixin, modelName: string, id: string[], snapshot: Snapshot[], requestType: "findMany"): string;
+  /**
+   * Builds the URL for fetching an async `hasMany` relationship when a
+   * URL is not provided by the server.
+   *
+   * @public
+   */
+  buildURL(this: MixtBuildURLMixin, modelName: string, id: string, snapshot: Snapshot, requestType: "findHasMany"): string;
+  /**
+   * Builds the URL for fetching an async `belongsTo` relationship when a
+   * URL is not provided by the server.
+   *
+   * @public
+   */
+  buildURL(this: MixtBuildURLMixin, modelName: string, id: string, snapshot: Snapshot, requestType: "findBelongsTo"): string;
+  /**
+   * Builds the URL for a `record.save()` call when the record was
+   * created locally using `store.createRecord()`.
+   *
+   * @public
+   */
+  buildURL(this: MixtBuildURLMixin, modelName: string, id: string | null, snapshot: Snapshot, requestType: "createRecord"): string;
+  /**
+   * Builds the URL for a `record.save()` call when the record has been
+   * updated locally.
+   *
+   * @public
+   */
+  buildURL(this: MixtBuildURLMixin, modelName: string, id: string, snapshot: Snapshot, requestType: "updateRecord"): string;
+  /**
+   * Builds the URL for a `record.save()` call when the record has been
+   * deleted locally.
+   *
+   * @public
+   */
+  buildURL(this: MixtBuildURLMixin, modelName: string, id: string, snapshot: Snapshot, requestType: "deleteRecord"): string;
+  /**
+   * Builds a URL for a given type and ID without a specific request type.
+   *
+   * @public
+   */
+  buildURL(this: MixtBuildURLMixin, modelName: string, id: string, snapshot: Snapshot): string;
+  /**
+   * @private
+   */
+  _buildURL(this: MixtBuildURLMixin, modelName: string | null | undefined, id?: string | null): string;
+  /**
+   * Builds a URL for a `store.findRecord(type, id)` call.
+   *
+   * @public
+   */
+  urlForFindRecord(this: MixtBuildURLMixin, id: string, modelName: string, snapshot: Snapshot): string;
+  /**
+   * Builds a URL for a `store.findAll(type)` call.
+   *
+   * @public
+   */
+  urlForFindAll(this: MixtBuildURLMixin, modelName: string, snapshots: SnapshotRecordArray): string;
+  /**
+   * Builds a URL for a `store.queryRecord(type, query)` call.
+   *
+   * @public
+   */
+  urlForQueryRecord(this: MixtBuildURLMixin, query: Record<string, unknown>, modelName: string): string;
+  /**
+   * Builds a URL for a `store.query(type, query)` call.
+   *
+   * @public
+   */
+  urlForQuery(this: MixtBuildURLMixin, query: Record<string, unknown>, modelName: string): string;
+  /**
+   * Builds a URL for coalescing multiple `store.findRecord(type, id)`
+   * records into 1 request when the adapter's `coalesceFindRequests`
+   * property is `true`.
+   *
+   * @public
+   */
+  urlForFindMany(this: MixtBuildURLMixin, ids: string[], modelName: string, snapshots: Snapshot[]): string;
+  /**
+   * Builds a URL for fetching an async `hasMany` relationship when a
+   * URL is not provided by the server.
+   *
+   * @public
+   */
+  urlForFindHasMany(this: MixtBuildURLMixin, id: string, modelName: string, snapshot: Snapshot): string;
+  /**
+   * Builds a URL for fetching an async `belongsTo` relationship when a
+   * URL is not provided by the server.
+   *
+   * @public
+   */
+  urlForFindBelongsTo(this: MixtBuildURLMixin, id: string, modelName: string, snapshot: Snapshot): string;
+  /**
+   * Builds a URL for a `record.save()` call when the record was created
+   * locally using `store.createRecord()`.
+   *
+   * @public
+   */
+  urlForCreateRecord(this: MixtBuildURLMixin, modelName: string, snapshot: Snapshot): string;
+  /**
+   * Builds a URL for a `record.save()` call when the record has been
+   * updated locally.
+   *
+   * @public
+   */
+  urlForUpdateRecord(this: MixtBuildURLMixin, id: string, modelName: string, snapshot: Snapshot): string;
+  /**
+   * Builds a URL for a `record.save()` call when the record has been
+   * deleted locally.
+   *
+   * @public
+   */
+  urlForDeleteRecord(this: MixtBuildURLMixin, id: string, modelName: string, snapshot: Snapshot): string;
+  /**
+   * @private
+   */
+  urlPrefix(this: MixtBuildURLMixin, path?: string | null, parentURL?: string): string;
+  /**
+   * Determines the pathname for a given type.
+   *
+   * By default, it pluralizes the type's name (for example, 'post'
+   * becomes 'posts' and 'person' becomes 'people').
+   *
+   * @public
+   */
+  pathForType(this: MixtBuildURLMixin, modelName: string): string;
+}
+interface MixtBuildURLMixin extends BuildURLMixin {
+  host: string | null;
+  namespace: string | null;
+}
+/**
+ * The `Mixin` implementation of {@link BuildURLMixin}, ready to be applied
+ * to an `EmberObject` subclass such as an `Adapter`.
+ *
+ * @public
+ */
+declare const BuildURLMixin: Mixin;
+//#endregion
+//#region src/adapter.d.ts
+/**
+An adapter is an object that receives requests from a store and
+translates them into the appropriate action to take against your
+persistence layer. The persistence layer is usually an HTTP API but
+may be anything, such as the browser's local storage. Typically the
+adapter is not invoked directly instead its functionality is accessed
+through the `store`.
+
+> ⚠️ CAUTION you likely want the docs for {@link MinimumAdapterInterface}
+> as extending this abstract class is unnecessary.
+
+### Creating an Adapter
+
+Create a new subclass of `Adapter` in the `app/adapters` folder:
+
+```js [app/adapters/application.js]
+import { Adapter } from '@warp-drive/legacy/adapter';
+
+export default class extends Adapter {
+// ...your code here
+}
+```
+
+Model-specific adapters can be created by putting your adapter
+class in an `app/adapters/` + `model-name` + `.js` file of the application.
+
+```js [app/adapters/post.js]
+import { Adapter } from '@warp-drive/legacy/adapter';
+
+export default class extends Adapter {
+// ...Post-specific adapter code goes here
+}
+```
+
+`Adapter` is an abstract base class that you should override in your
+application to customize it for your backend. The minimum set of methods
+that you should implement is:
+
+* `findRecord()`
+* `createRecord()`
+* `updateRecord()`
+* `deleteRecord()`
+* `findAll()`
+* `query()`
+
+To improve the network performance of your application, you can optimize
+your adapter by overriding these lower-level methods:
+
+* `findMany()`
+
+
+For an example of the implementation, see `RESTAdapter`, the
+included REST adapter.
+
+@public
+*/
+declare class Adapter extends EmberObject implements MinimumAdapterInterface {
+  /**
+   * The Store service instance that owns this Adapter.
+   */
+  store: Store;
+  /**
+   * @private
+   */
+  _coalesceFindRequests: boolean;
+  /**
+	The `findRecord()` method is invoked when the store is asked for a record that
+	has not previously been loaded. In response to `findRecord()` being called, you
+	should query your persistence layer for a record with the given ID. The `findRecord`
+	method should return a promise that will resolve to a JavaScript object that will be
+	normalized by the serializer.
+	
+	Here is an example of the `findRecord` implementation:
+	
+	```js [app/adapters/application.js]
+	import { Adapter } from '@warp-drive/legacy/adapter';
+	import RSVP from 'RSVP';
+	import $ from 'jquery';
+	
+	export default class ApplicationAdapter extends Adapter {
+	findRecord(store, type, id, snapshot) {
+	return new RSVP.Promise(function(resolve, reject) {
+	$.getJSON(`/${type.modelName}/${id}`).then(function(data) {
+	resolve(data);
+	}, function(jqXHR) {
+	reject(jqXHR);
+	});
+	});
+	}
+	}
+	```
+	
+	@public
+	*/
+  findRecord(store: Store, type: ModelSchema, id: string, snapshot: Snapshot): Promise<AdapterPayload>;
+  /**
+	The `findAll()` method is used to retrieve all records for a given type.
+	
+	Example
+	
+	```js [app/adapters/application.js]
+	import { Adapter } from '@warp-drive/legacy/adapter';
+	import RSVP from 'RSVP';
+	import $ from 'jquery';
+	
+	export default class ApplicationAdapter extends Adapter {
+	findAll(store, type) {
+	return new RSVP.Promise(function(resolve, reject) {
+	$.getJSON(`/${type.modelName}`).then(function(data) {
+	resolve(data);
+	}, function(jqXHR) {
+	reject(jqXHR);
+	});
+	});
+	}
+	}
+	```
+	
+	@param neverSet a value is never provided to this argument
+	@public
+	*/
+  findAll(store: Store, type: ModelSchema, neverSet: null, snapshotRecordArray: SnapshotRecordArray): Promise<AdapterPayload>;
+  /**
+	This method is called when you call `query` on the store.
+	
+	Example
+	
+	```js [app/adapters/application.js]
+	import { Adapter } from '@warp-drive/legacy/adapter';
+	import RSVP from 'RSVP';
+	import $ from 'jquery';
+	
+	export default class ApplicationAdapter extends Adapter {
+	query(store, type, query) {
+	return new RSVP.Promise(function(resolve, reject) {
+	$.getJSON(`/${type.modelName}`, query).then(function(data) {
+	resolve(data);
+	}, function(jqXHR) {
+	reject(jqXHR);
+	});
+	});
+	}
+	}
+	```
+	
+	@public
+	*/
+  query(store: Store, type: ModelSchema, query: Record<string, unknown>): Promise<AdapterPayload>;
+  /**
+	The `queryRecord()` method is invoked when the store is asked for a single
+	record through a query object.
+	
+	In response to `queryRecord()` being called, you should always fetch fresh
+	data. Once found, you can asynchronously call the store's `push()` method
+	to push the record into the store.
+	
+	Here is an example `queryRecord` implementation:
+	
+	Example
+	
+	```js [app/adapters/application.js]
+	import  { Adapter, BuildURLMixin } from '@warp-drive/legacy/adapter';
+	
+	export default class ApplicationAdapter extends Adapter.extend(BuildURLMixin) {
+	queryRecord(store, type, query) {
+	return fetch(`/${type.modelName}`, { body: JSON.stringify(query) })
+	.then((response) => response.json());
+	}
+	}
+	```
+	
+	@public
+	*/
+  queryRecord(store: Store, type: ModelSchema, query: Record<string, unknown>, adapterOptions: object): Promise<AdapterPayload>;
+  /**
+	If the globally unique IDs for your records should be generated on the client,
+	implement the `generateIdForRecord()` method. This method will be invoked
+	each time you create a new record, and the value returned from it will be
+	assigned to the record's `primaryKey`.
+	
+	Most traditional REST-like HTTP APIs will not use this method. Instead, the ID
+	of the record will be set by the server, and your adapter will update the store
+	with the new ID when it calls `didCreateRecord()`. Only implement this method if
+	you intend to generate record IDs on the client-side.
+	
+	The `generateIdForRecord()` method will be invoked with the requesting store as
+	the first parameter and the newly created record as the second parameter:
+	
+	```javascript
+	import { Adapter } from '@warp-drive/legacy/adapter';
+	import { v4 } from 'uuid';
+	
+	export default class ApplicationAdapter extends Adapter {
+	generateIdForRecord(store, type, inputProperties) {
+	return v4();
+	}
+	}
+	```
+	
+	@param {Store} store
+	@param {Model} type   the Model class of the record
+	@param {Object} inputProperties a hash of properties to set on the
+	newly created record.
+	@return {(String|Number)} id
+	@public
+	*/
+  /**
+	Proxies to the serializer's `serialize` method.
+	
+	Example
+	
+	```js [app/adapters/application.js]
+	import { Adapter } from '@warp-drive/legacy/adapter';
+	
+	export default class ApplicationAdapter extends Adapter {
+	createRecord(store, type, snapshot) {
+	let data = this.serialize(snapshot, { includeId: true });
+	let url = `/${type.modelName}`;
+	
+	// ...
+	}
+	}
+	```
+	
+	@public
+	*/
+  serialize(snapshot: Snapshot, options: SerializerOptions): Record<string, unknown>;
+  /**
+	Implement this method in a subclass to handle the creation of
+	new records.
+	
+	Serializes the record and sends it to the server.
+	
+	Example
+	
+	```js [app/adapters/application.js]
+	import { Adapter } from '@warp-drive/legacy/adapter';
+	import RSVP from 'RSVP';
+	import $ from 'jquery';
+	
+	export default class ApplicationAdapter extends Adapter {
+	createRecord(store, type, snapshot) {
+	let data = this.serialize(snapshot, { includeId: true });
+	
+	return new RSVP.Promise(function (resolve, reject) {
+	$.ajax({
+	type: 'POST',
+	url: `/${type.modelName}`,
+	dataType: 'json',
+	data: data
+	}).then(function (data) {
+	resolve(data);
+	}, function (jqXHR) {
+	jqXHR.then = null; // tame jQuery's ill mannered promises
+	reject(jqXHR);
+	});
+	});
+	}
+	}
+	```
+	
+	@public
+	*/
+  createRecord(store: Store, type: ModelSchema, snapshot: Snapshot): Promise<AdapterPayload>;
+  /**
+	Implement this method in a subclass to handle the updating of
+	a record.
+	
+	Serializes the record update and sends it to the server.
+	
+	The updateRecord method is expected to return a promise that will
+	resolve with the serialized record. This allows the backend to
+	inform the WarpDrive store the current state of this record after
+	the update. If it is not possible to return a serialized record
+	the updateRecord promise can also resolve with `undefined` and the
+	WarpDrive store will assume all of the updates were successfully
+	applied on the backend.
+	
+	Example
+	
+	```js [app/adapters/application.js]
+	import { Adapter } from '@warp-drive/legacy/adapter';
+	import RSVP from 'RSVP';
+	import $ from 'jquery';
+	
+	export default class ApplicationAdapter extends Adapter {
+	updateRecord(store, type, snapshot) {
+	let data = this.serialize(snapshot, { includeId: true });
+	let id = snapshot.id;
+	
+	return new RSVP.Promise(function(resolve, reject) {
+	$.ajax({
+	type: 'PUT',
+	url: `/${type.modelName}/${id}`,
+	dataType: 'json',
+	data: data
+	}).then(function(data) {
+	resolve(data);
+	}, function(jqXHR) {
+	jqXHR.then = null; // tame jQuery's ill mannered promises
+	reject(jqXHR);
+	});
+	});
+	}
+	}
+	```
+	
+	@param {Store} store
+	@param {Model} type   the Model class of the record
+	@param {Snapshot} snapshot
+	@return {Promise} promise
+	@public
+	*/
+  updateRecord(store: Store, type: ModelSchema, snapshot: Snapshot): Promise<AdapterPayload>;
+  /**
+	Implement this method in a subclass to handle the deletion of
+	a record.
+	
+	Sends a delete request for the record to the server.
+	
+	Example
+	
+	```js [app/adapters/application.js]
+	import { Adapter } from '@warp-drive/legacy/adapter';
+	import RSVP from 'RSVP';
+	import $ from 'jquery';
+	
+	export default class ApplicationAdapter extends Adapter {
+	deleteRecord(store, type, snapshot) {
+	let data = this.serialize(snapshot, { includeId: true });
+	let id = snapshot.id;
+	
+	return new RSVP.Promise(function(resolve, reject) {
+	$.ajax({
+	type: 'DELETE',
+	url: `/${type.modelName}/${id}`,
+	dataType: 'json',
+	data: data
+	}).then(function(data) {
+	resolve(data)
+	}, function(jqXHR) {
+	jqXHR.then = null; // tame jQuery's ill mannered promises
+	reject(jqXHR);
+	});
+	});
+	}
+	}
+	```
+	
+	@param {Store} store
+	@param {Model} type   the Model class of the record
+	@param {Snapshot} snapshot
+	@return {Promise} promise
+	@public
+	*/
+  deleteRecord(store: Store, type: ModelSchema, snapshot: Snapshot): Promise<AdapterPayload>;
+  /**
+	By default the store will try to coalesce all `findRecord` calls within the same runloop
+	into as few requests as possible by calling groupRecordsForFindMany and passing it into a findMany call.
+	You can opt out of this behaviour by either not implementing the findMany hook or by setting
+	coalesceFindRequests to false.
+	
+	@property coalesceFindRequests
+	@public
+	@type {Boolean}
+	*/
+  get coalesceFindRequests(): boolean;
+  set coalesceFindRequests(value: boolean);
+  /**
+	The store will call `findMany` instead of multiple `findRecord`
+	requests to find multiple records at once if coalesceFindRequests
+	is true.
+	
+	```js [app/adapters/application.js]
+	import { Adapter } from '@warp-drive/legacy/adapter';
+	import RSVP from 'RSVP';
+	import $ from 'jquery';
+	
+	export default class ApplicationAdapter extends Adapter {
+	findMany(store, type, ids, snapshots) {
+	return new RSVP.Promise(function(resolve, reject) {
+	$.ajax({
+	type: 'GET',
+	url: `/${type.modelName}/`,
+	dataType: 'json',
+	data: { filter: { id: ids.join(',') } }
+	}).then(function(data) {
+	resolve(data);
+	}, function(jqXHR) {
+	jqXHR.then = null; // tame jQuery's ill mannered promises
+	reject(jqXHR);
+	});
+	});
+	}
+	}
+	```
+	
+	@param {Store} store
+	@param {Model} type   the Model class of the records
+	@param {Array}    ids
+	@param {Array} snapshots
+	@return {Promise} promise
+	@public
+	*/
+  /**
+	Organize records into groups, each of which is to be passed to separate
+	calls to `findMany`.
+	
+	For example, if your API has nested URLs that depend on the parent, you will
+	want to group records by their parent.
+	
+	The default implementation returns the records as a single group.
+	
+	@public
+	@param {Store} store
+	@param {Array} snapshots
+	@return {Array}  an array of arrays of records, each of which is to be
+	loaded separately by `findMany`.
+	*/
+  groupRecordsForFindMany(store: Store, snapshots: Snapshot[]): Snapshot[][];
+  /**
+	This method is used by the store to determine if the store should
+	reload a record from the adapter when a record is requested by
+	`store.findRecord`.
+	
+	If this method returns `true`, the store will re-fetch a record from
+	the adapter. If this method returns `false`, the store will resolve
+	immediately using the cached record.
+	
+	For example, if you are building an events ticketing system, in which users
+	can only reserve tickets for 20 minutes at a time, and want to ensure that
+	in each route you have data that is no more than 20 minutes old you could
+	write:
+	
+	```javascript
+	shouldReloadRecord(store, ticketSnapshot) {
+	let lastAccessedAt = ticketSnapshot.attr('lastAccessedAt');
+	let timeDiff = moment().diff(lastAccessedAt, 'minutes');
+	
+	if (timeDiff > 20) {
+	return true;
+	} else {
+	return false;
+	}
+	}
+	```
+	
+	This method would ensure that whenever you do `store.findRecord('ticket',
+	id)` you will always get a ticket that is no more than 20 minutes old. In
+	case the cached version is more than 20 minutes old, `findRecord` will not
+	resolve until you fetched the latest version.
+	
+	By default this hook returns `false`, as most UIs should not block user
+	interactions while waiting on data update.
+	
+	Note that, with default settings, `shouldBackgroundReloadRecord` will always
+	re-fetch the records in the background even if `shouldReloadRecord` returns
+	`false`. You can override `shouldBackgroundReloadRecord` if this does not
+	suit your use case.
+	
+	@since 1.13.0
+	@param {Store} store
+	@param {Snapshot} snapshot
+	@return {Boolean}
+	@public
+	*/
+  shouldReloadRecord(store: Store, snapshot: Snapshot): boolean;
+  /**
+	This method is used by the store to determine if the store should
+	reload all records from the adapter when records are requested by
+	`store.findAll`.
+	
+	If this method returns `true`, the store will re-fetch all records from
+	the adapter. If this method returns `false`, the store will resolve
+	immediately using the cached records.
+	
+	For example, if you are building an events ticketing system, in which users
+	can only reserve tickets for 20 minutes at a time, and want to ensure that
+	in each route you have data that is no more than 20 minutes old you could
+	write:
+	
+	```javascript
+	shouldReloadAll(store, snapshotArray) {
+	let snapshots = snapshotArray.snapshots();
+	
+	return snapshots.any((ticketSnapshot) => {
+	let lastAccessedAt = ticketSnapshot.attr('lastAccessedAt');
+	let timeDiff = moment().diff(lastAccessedAt, 'minutes');
+	
+	if (timeDiff > 20) {
+	return true;
+	} else {
+	return false;
+	}
+	});
+	}
+	```
+	
+	This method would ensure that whenever you do `store.findAll('ticket')` you
+	will always get a list of tickets that are no more than 20 minutes old. In
+	case a cached version is more than 20 minutes old, `findAll` will not
+	resolve until you fetched the latest versions.
+	
+	By default, this method returns `true` if the passed `snapshotRecordArray`
+	is empty (meaning that there are no records locally available yet),
+	otherwise, it returns `false`.
+	
+	Note that, with default settings, `shouldBackgroundReloadAll` will always
+	re-fetch all the records in the background even if `shouldReloadAll` returns
+	`false`. You can override `shouldBackgroundReloadAll` if this does not suit
+	your use case.
+	
+	@since 1.13.0
+	@param {Store} store
+	@param {SnapshotRecordArray} snapshotRecordArray
+	@return {Boolean}
+	@public
+	*/
+  shouldReloadAll(store: Store, snapshotRecordArray: SnapshotRecordArray): boolean;
+  /**
+	This method is used by the store to determine if the store should
+	reload a record after the `store.findRecord` method resolves a
+	cached record.
+	
+	This method is *only* checked by the store when the store is
+	returning a cached record.
+	
+	If this method returns `true` the store will re-fetch a record from
+	the adapter.
+	
+	For example, if you do not want to fetch complex data over a mobile
+	connection, or if the network is down, you can implement
+	`shouldBackgroundReloadRecord` as follows:
+	
+	```javascript
+	shouldBackgroundReloadRecord(store, snapshot) {
+	let { downlink, effectiveType } = navigator.connection;
+	
+	return downlink > 0 && effectiveType === '4g';
+	}
+	```
+	
+	By default, this hook returns `true` so the data for the record is updated
+	in the background.
+	
+	@since 1.13.0
+	@param {Store} store
+	@param {Snapshot} snapshot
+	@return {Boolean}
+	@public
+	*/
+  shouldBackgroundReloadRecord(store: Store, snapshot: Snapshot): boolean;
+  /**
+	This method is used by the store to determine if the store should
+	reload a record array after the `store.findAll` method resolves
+	with a cached record array.
+	
+	This method is *only* checked by the store when the store is
+	returning a cached record array.
+	
+	If this method returns `true` the store will re-fetch all records
+	from the adapter.
+	
+	For example, if you do not want to fetch complex data over a mobile
+	connection, or if the network is down, you can implement
+	`shouldBackgroundReloadAll` as follows:
+	
+	```javascript
+	shouldBackgroundReloadAll(store, snapshotArray) {
+	let { downlink, effectiveType } = navigator.connection;
+	
+	return downlink > 0 && effectiveType === '4g';
+	}
+	```
+	
+	By default this method returns `true`, indicating that a background reload
+	should always be triggered.
+	
+	@since 1.13.0
+	@param {Store} store
+	@param {SnapshotRecordArray} snapshotRecordArray
+	@return {Boolean}
+	@public
+	*/
+  shouldBackgroundReloadAll(store: Store, snapshotRecordArray: SnapshotRecordArray): boolean;
+}
+//#endregion
+export { BuildURLMixin as n, MixtBuildURLMixin as r, Adapter as t };
+//# sourceMappingURL=adapter-CARrK3-8.d.ts.map