@ember-data/store 5.4.0-beta.2 → 5.4.0-beta.20

package/unstable-preview-types/-types/q/schema-service.d.ts

@@ -0,0 +1,366 @@
+declare module '@ember-data/store/-types/q/schema-service' {
+  /**
+    @module @ember-data/store
+  */
+  import type { StableRecordIdentifier } from '@warp-drive/core-types';
+  import type { RecordIdentifier } from '@warp-drive/core-types/identifier';
+  import type { ObjectValue } from '@warp-drive/core-types/json/raw';
+  import type { Derivation, HashFn, Transformation } from '@warp-drive/core-types/schema/concepts';
+  import type { ArrayField, DerivedField, FieldSchema, GenericField, HashField, LegacyAttributeField, LegacyRelationshipField, ObjectField, Schema } from '@warp-drive/core-types/schema/fields';
+  export type AttributesSchema = Record<string, LegacyAttributeField>;
+  export type RelationshipsSchema = Record<string, LegacyRelationshipField>;
+  /**
+   * The SchemaService provides the ability to query for information about the structure
+   * of any resource type.
+   *
+   * Applications can provide any implementation of the SchemaService they please so long
+   * as it conforms to this interface.
+   *
+   * The design of the service means that schema information could be lazily populated,
+   * derived-on-demand, or progressively enhanced during the course of an application's runtime.
+   * The primary requirement is merely that any information the service needs to correctly
+   * respond to an inquest is available by the time it is asked.
+   *
+   * The `@ember-data/model` package provides an implementation of this service which
+   * makes use of your model classes as the source of information to respond to queries
+   * about resource schema. While this is useful, this may not be ideal for your application.
+   * For instance, Schema information could be sideloaded or pre-flighted for API calls,
+   * resulting in no need to bundle and ship potentially large and expensive JSON
+   * or large Javascript based Models to pull information from.
+   *
+   * To register a custom schema implementation, implement the store's `createSchemaService`
+   * hook to return an instance of your service.
+   *
+   * ```ts
+   * import Store from '@ember-data/store';
+   * import CustomSchemas from './custom-schemas';
+   *
+   * export default class extends Store {
+   *   createSchemaService() {
+   *     return new CustomSchemas();
+   *   }
+   * }
+   * ```
+   *
+   * At runtime, both the `Store` and the `CacheCapabilitiesManager` provide
+   * access to this service via the `schema` property.
+   *
+   * ```ts
+   * export default class extends Component {
+   *  @service store;
+   *
+   *  get fields() {
+   *    return this.store
+   *      .schema
+   *      .fields(this.args.dataType);
+   *  }
+   * }
+   * ```
+   *
+   * @class <Interface> SchemaService
+   * @public
+   */
+  export interface SchemaService {
+      /**
+       * DEPRECATED - use `hasResource` instead
+       *
+       * Queries whether the SchemaService recognizes `type` as a resource type
+       *
+       * @method doesTypeExist
+       * @public
+       * @deprecated
+       * @param {string} type
+       * @return {boolean}
+       */
+      doesTypeExist?(type: string): boolean;
+      /**
+       * Queries whether the SchemaService recognizes `type` as a resource type
+       *
+       * @method hasResource
+       * @public
+       * @param {StableRecordIdentifier|{ type: string }} resource
+       * @return {boolean}
+       */
+      hasResource(resource: {
+          type: string;
+      } | StableRecordIdentifier): boolean;
+      /**
+       * Queries whether the SchemaService recognizes `type` as a resource trait
+       *
+       * @method hasTrait
+       * @public
+       * @param {string} type
+       * @return {boolean}
+       */
+      hasTrait(type: string): boolean;
+      /**
+       * Queries whether the given resource has the given trait
+       *
+       * @method resourceHasTrait
+       * @public
+       * @param {StableRecordIdentifier|{ type: string }} resource
+       * @param {string} trait
+       * @return {boolean}
+       */
+      resourceHasTrait(resource: {
+          type: string;
+      } | StableRecordIdentifier, trait: string): boolean;
+      /**
+       * Queries for the fields of a given resource type or resource identity.
+       *
+       * Should error if the resource type is not recognized.
+       *
+       * @method fields
+       * @public
+       * @param {StableRecordIdentifier|{ type: string }} resource
+       * @return {Map<string, FieldSchema>}
+       */
+      fields(resource: {
+          type: string;
+      } | StableRecordIdentifier): Map<string, FieldSchema>;
+      /**
+       * Returns the transformation registered with the name provided
+       * by `field.type`. Validates that the field is a valid transformable.
+       *
+       * @method transformation
+       * @public
+       * @param {TransformableField|{ type: string }} field
+       * @return {Transformation}
+       */
+      transformation(field: GenericField | ObjectField | ArrayField | {
+          type: string;
+      }): Transformation;
+      /**
+       * Returns the hash function registered with the name provided
+       * by `field.type`. Validates that the field is a valid HashField.
+       *
+       * @method hashFn
+       * @public
+       * @param {HashField|{ type: string }} field
+       * @return {HashFn}
+       */
+      hashFn(field: HashField | {
+          type: string;
+      }): HashFn;
+      /**
+       * Returns the derivation registered with the name provided
+       * by `field.type`. Validates that the field is a valid DerivedField.
+       *
+       * @method derivation
+       * @public
+       * @param {DerivedField|{ type: string }} field
+       * @return {Derivation}
+       */
+      derivation(field: DerivedField | {
+          type: string;
+      }): Derivation;
+      /**
+       * Returns the schema for the provided resource type.
+       *
+       * @method resource
+       * @public
+       * @param {StableRecordIdentifier|{ type: string }} resource
+       * @return {ResourceSchema}
+       */
+      resource(resource: {
+          type: string;
+      } | StableRecordIdentifier): Schema;
+      /**
+       * Enables registration of multiple ResourceSchemas at once.
+       *
+       * This can be useful for either pre-loading schema information
+       * or for registering schema information delivered by API calls
+       * or other sources just-in-time.
+       *
+       * @method registerResources
+       * @public
+       * @param schemas
+       */
+      registerResources(schemas: Schema[]): void;
+      /**
+       * Enables registration of a single ResourceSchema.
+       *
+       * This can be useful for either pre-loading schema information
+       * or for registering schema information delivered by API calls
+       * or other sources just-in-time.
+       *
+       * @method registerResource
+       * @public
+       * @param {ResourceSchema} schema
+       */
+      registerResource(schema: Schema): void;
+      /**
+       * Enables registration of a transformation.
+       *
+       * The transformation can later be retrieved by the name
+       * attached to it's `[Type]` property.
+       *
+       * @method registerTransformations
+       * @public
+       * @param {Transformation} transform
+       */
+      registerTransformation(transform: Transformation): void;
+      /**
+       * Enables registration of a derivation.
+       *
+       * The derivation can later be retrieved by the name
+       * attached to it's `[Type]` property.
+       *
+       * @method registerDerivations
+       * @public
+       * @param {Derivation} derivation
+       */
+      registerDerivation<R, T, FM extends ObjectValue | null>(derivation: Derivation<R, T, FM>): void;
+      /**
+       * Enables registration of a hashing function
+       *
+       * The hashing function can later be retrieved by the name
+       * attached to it's `[Type]` property.
+       *
+       * @method registerHashFn
+       * @public
+       * @param {HashFn} hashfn
+       */
+      registerHashFn(hashFn: HashFn): void;
+      /**
+       * DEPRECATED - use `fields` instead
+       *
+       * Returns definitions for all properties of the specified resource
+       * that are considered "attributes". Generally these are properties
+       * that are not related to book-keeping state on the client and do
+       * not represent a linkage to another resource.
+       *
+       * The return value should be a dictionary of key:value pairs
+       * where the `key` is the attribute or property's name and `value`
+       * is an object with at least the property `name` which should also
+       * match `key`.
+       *
+       * Optionally, this object may also specify `type`, which should
+       * be a string reference to a `transform`, and `options` which
+       * should be dictionary in which any key:value pairs are permissable.
+       *
+       * For instance, when using `@ember-data/model`, the following attribute
+       * definition:
+       *
+       * ```ts
+       * class extends Model {
+       *   @attr('string', { defaultValue: 'hello' }) greeting;
+       *   @attr('date') birthday;
+       *   @attr firstName;
+       * }
+       * ```
+       *
+       * Would be returned as:
+       *
+       * ```js
+       * {
+       *   greeting: { name: 'greeting', type: 'string', options: { defaultValue: 'hello' } },
+       *   birthday: { name: 'birthday', type: 'date' },
+       *   firstName: { name: 'firstName' }
+       * }
+       * ```
+       *
+       * @method attributesDefinitionFor
+       * @public
+       * @deprecated
+       * @param {RecordIdentifier|{ type: string }} identifier
+       * @return {AttributesSchema}
+       */
+      attributesDefinitionFor?(identifier: RecordIdentifier | {
+          type: string;
+      }): AttributesSchema;
+      /**
+       * DEPRECATED - use `fields` instead
+       *
+       * Returns definitions for all properties of the specified resource
+       * that are considered "relationships". Generally these are properties
+       * that represent a linkage to another resource.
+       *
+       * The return value should be a dictionary of key:value pairs
+       * where the `key` is the relationship or property's name and `value`
+       * is an object with at least the following properties:
+       *
+       * - `name` which should also match the `key` used in the dictionary.
+       * - `kind` which should be either `belongsTo` or `hasMany`
+       * - `type` which should be the related resource's string "type"
+       * - `options` which should be a dictionary allowing any key but with
+       *    at least the below keys present.
+       *
+       * - `options.async` a boolean representing whether data for this relationship is
+       *      typically loaded on-demand.
+       * - `options.inverse` a string or null representing the field name / key of the
+       *       corresponding relationship on the inverse resource.
+       *
+       * Additionally the following options properties are optional. See [Polymorphic Relationships](https://rfcs.emberjs.com/id/0793-polymporphic-relations-without-inheritance)
+       *
+       * - `options.polymorphic` a boolean representing whether multiple resource types
+       *    can be used to satisfy this relationship.
+       * - `options.as` a string representing the abstract type that the concrete side of
+       *    a relationship must specify when fulfilling a polymorphic inverse.
+       *
+       * For example, the following Model using @ember-data/model would generate this relationships
+       * definition by default:
+       *
+       * ```js
+       * class User extends Model {
+       *   @belongsTo('user', { async: false, inverse: null }) bestFriend;
+       *   @hasMany('user', { async: true, inverse: 'friends' }) friends;
+       *   @hasMany('pet', { async: false, polymorphic: true, inverse: 'owner' }) pets;
+       * }
+       * ```
+       *
+       * Which would be returned as
+       *
+       * ```js
+       * {
+       *   bestFriend: {
+       *     name: 'bestFriend',
+       *     kind: 'belongsTo',
+       *     type: 'user',
+       *     options: {
+       *       async: false,
+       *       inverse: null
+       *     }
+       *   },
+       *   friends: {
+       *     name: 'friends',
+       *     kind: 'hasMany',
+       *     type: 'user',
+       *     options: {
+       *       async: true,
+       *       inverse: 'friends'
+       *     }
+       *   },
+       *   pets: {
+       *     name: 'pets',
+       *     kind: 'hasMany',
+       *     type: 'pet',
+       *     options: {
+       *       async: false,
+       *       polymorphic: true,
+       *       inverse: 'owner'
+       *     }
+       *   },
+       * }
+       * ```
+       *
+       * @method relationshipsDefinitionFor
+       * @public
+       * @deprecated
+       * @param {RecordIdentifier|{ type: string }} identifier
+       * @return {RelationshipsSchema}
+       */
+      relationshipsDefinitionFor?(identifier: RecordIdentifier | {
+          type: string;
+      }): RelationshipsSchema;
+      /**
+       * Returns all known resource types
+       *
+       * @method resourceTypes
+       * @public
+       * @return {string[]}
+       */
+      resourceTypes(): Readonly<string[]>;
+  }
+}
+//# sourceMappingURL=schema-service.d.ts.map

package/unstable-preview-types/-types/q/schema-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-service.d.ts","sourceRoot":"","sources":["../../../src/-types/q/schema-service.ts"],"names":[],"mappings":"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"}

package/unstable-preview-types/-types/q/store.d.ts

@@ -0,0 +1,38 @@
+declare module '@ember-data/store/-types/q/store' {
+  import type { Value } from '@warp-drive/core-types/json/raw';
+  import type { Includes, TypedRecordInstance } from '@warp-drive/core-types/record';
+  export interface BaseFinderOptions<T = unknown> {
+      reload?: boolean;
+      backgroundReload?: boolean;
+      include?: T extends TypedRecordInstance ? Includes<T>[] : string | string[];
+      adapterOptions?: Record<string, unknown>;
+  }
+  export interface FindRecordOptions<T = unknown> extends BaseFinderOptions<T> {
+      /**
+       * Data to preload into the store before the request is made.
+       * This feature is *highly* discouraged and has no corresponding
+       * feature when using builders and handlers.
+       *
+       * Excepting relationships: the data should be in the form of a
+       * JSON object where the keys are fields on the record and the value
+       * is the raw value to be added to the cache.
+       *
+       * Relationships can either be provided as string IDs from which
+       * an identifier will be built base upon the relationship's expected
+       * resource type, or be record instances from which the identifier
+       * will be extracted.
+       *
+       * @typedoc
+       */
+      preload?: Record<string, Value>;
+  }
+  export type QueryOptions = {
+      [K in string | 'adapterOptions']?: K extends 'adapterOptions' ? Record<string, unknown> : unknown;
+  };
+  export type FindAllOptions<T = unknown> = BaseFinderOptions<T>;
+  export type LegacyResourceQuery<T = unknown> = {
+      include?: T extends TypedRecordInstance ? Includes<T>[] : string | string[];
+      [key: string]: Value | undefined;
+  };
+}
+//# sourceMappingURL=store.d.ts.map

package/unstable-preview-types/-types/q/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../src/-types/q/store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iCAAiC,CAAC;AAC7D,OAAO,KAAK,EAAE,QAAQ,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAEnF,MAAM,WAAW,iBAAiB,CAAC,CAAC,GAAG,OAAO;IAC5C,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,OAAO,CAAC,EAAE,CAAC,SAAS,mBAAmB,GAAG,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC;IAC5E,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC1C;AACD,MAAM,WAAW,iBAAiB,CAAC,CAAC,GAAG,OAAO,CAAE,SAAQ,iBAAiB,CAAC,CAAC,CAAC;IAC1E;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;CACjC;AAED,MAAM,MAAM,YAAY,GAAG;KACxB,CAAC,IAAI,MAAM,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,SAAS,gBAAgB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO;CAClG,CAAC;AAEF,MAAM,MAAM,cAAc,CAAC,CAAC,GAAG,OAAO,IAAI,iBAAiB,CAAC,CAAC,CAAC,CAAC;AAC/D,MAAM,MAAM,mBAAmB,CAAC,CAAC,GAAG,OAAO,IAAI;IAC7C,OAAO,CAAC,EAAE,CAAC,SAAS,mBAAmB,GAAG,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC;IAC5E,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAAC;CAClC,CAAC"}

package/unstable-preview-types/index.d.ts

@@ -0,0 +1,223 @@
+/// <reference path="./types.d.ts" />
+/// <reference path="./-private.d.ts" />
+/// <reference path="./-private/store-service.d.ts" />
+/// <reference path="./-private/document.d.ts" />
+/// <reference path="./-private/store-service.type-test.d.ts" />
+/// <reference path="./-private/network/request-cache.d.ts" />
+/// <reference path="./-private/cache-handler/handler.d.ts" />
+/// <reference path="./-private/cache-handler/types.d.ts" />
+/// <reference path="./-private/cache-handler/utils.d.ts" />
+/// <reference path="./-private/record-arrays/many-array.d.ts" />
+/// <reference path="./-private/record-arrays/native-proxy-type-fix.d.ts" />
+/// <reference path="./-private/record-arrays/identifier-array.d.ts" />
+/// <reference path="./-private/utils/uuid-polyfill.d.ts" />
+/// <reference path="./-private/utils/normalize-model-name.d.ts" />
+/// <reference path="./-private/utils/coerce-id.d.ts" />
+/// <reference path="./-private/utils/is-non-empty-string.d.ts" />
+/// <reference path="./-private/utils/construct-resource.d.ts" />
+/// <reference path="./-private/legacy-model-support/record-reference.d.ts" />
+/// <reference path="./-private/legacy-model-support/shim-model-class.d.ts" />
+/// <reference path="./-private/managers/cache-manager.d.ts" />
+/// <reference path="./-private/managers/record-array-manager.d.ts" />
+/// <reference path="./-private/managers/notification-manager.d.ts" />
+/// <reference path="./-private/managers/cache-capabilities-manager.d.ts" />
+/// <reference path="./-private/caches/identifier-cache.d.ts" />
+/// <reference path="./-private/caches/instance-cache.d.ts" />
+/// <reference path="./-private/caches/cache-utils.d.ts" />
+/// <reference path="./-private/caches/resource-utils.d.ts" />
+/// <reference path="./-private/debug/utils.d.ts" />
+/// <reference path="./-types/overview.d.ts" />
+/// <reference path="./-types/q/store.d.ts" />
+/// <reference path="./-types/q/identifier.d.ts" />
+/// <reference path="./-types/q/record-instance.d.ts" />
+/// <reference path="./-types/q/ds-model.d.ts" />
+/// <reference path="./-types/q/promise-proxies.d.ts" />
+/// <reference path="./-types/q/record-data-json-api.d.ts" />
+/// <reference path="./-types/q/schema-service.d.ts" />
+/// <reference path="./-types/q/cache-capabilities-manager.d.ts" />
+declare module '@ember-data/store' {
+  /**
+   * <p align="center">
+   *   <img
+   *     class="project-logo"
+   *     src="https://raw.githubusercontent.com/emberjs/data/4612c9354e4c54d53327ec2cf21955075ce21294/ember-data-logo-light.svg#gh-light-mode-only"
+   *     alt="EmberData Store"
+   *     width="240px"
+   *     title="EmberData Store"
+   *     />
+   * </p>
+   *
+   * This package provides [*Ember***Data**](https://github.com/emberjs/data/)'s `Store` class.
+   *
+   * A [Store](https://api.emberjs.com/ember-data/release/classes/Store) coordinates interaction between your application, a [Cache](https://api.emberjs.com/ember-data/release/classes/%3CInterface%3E%20Cache),
+   * and sources of data (such as your API or a local persistence layer) accessed via a [RequestManager](https://github.com/emberjs/data/tree/main/packages/request).
+   *
+   * Optionally, a Store can be configured to hydrate the response data into rich presentation classes.
+   *
+   * ## Installation
+   *
+   * If you have installed `ember-data` then you already have this package installed.
+   * Otherwise you can install it using your javascript package manager of choice.
+   * For instance with [pnpm](https://pnpm.io/)
+   *
+   * ```
+   * pnpm add @ember-data/store
+   * ```
+   *
+   * After installing you will want to configure your first `Store`. Read more below
+   * for how to create and configure stores for your application.
+   *
+   *
+   * ## 🔨 Creating A Store
+   *
+   * To use a `Store` we will need to do few things: add a [Cache](https://api.emberjs.com/ember-data/release/classes/%3CInterface%3E%20Cache)
+   * to store data **in-memory**, add a [Handler](https://api.emberjs.com/ember-data/release/classes/%3CInterface%3E%20Cache) to fetch data from a source,
+   * and implement `instantiateRecord` to tell the store how to display the data for individual resources.
+   *
+   * > **Note**
+   * > If you are using the package `ember-data` then a JSON:API cache, RequestManager, LegacyNetworkHandler,
+   * > and `instantiateRecord` are configured for you by default.
+   *
+   * ### Configuring A Cache
+   *
+   * To start, let's install a [JSON:API](https://jsonapi.org/) cache. If your app uses `GraphQL` or `REST` other
+   * caches may better fit your data. You can author your own cache by creating one that
+   * conforms to the [spec](https://api.emberjs.com/ember-data/release/classes/%3CInterface%3E%20Cache).
+   *
+   * The package `@ember-data/json-api` provides a [JSON:API](https://jsonapi.org/) cache we can use.
+   * After installing it, we can configure the store to use this cache.
+   *
+   * ```js
+   * import Store from '@ember-data/store';
+   * import Cache from '@ember-data/json-api';
+   *
+   * class extends Store {
+   *   createCache(storeWrapper) {
+   *     return new Cache(storeWrapper);
+   *   }
+   * }
+   * ```
+   *
+   * Now that we have a `cache` let's setup something to handle fetching
+   * and saving data via our API.
+   *
+   * > **Note**
+   * > The `ember-data` package automatically includes and configures
+   * > the `@ember-data/json-api` cache for you.
+   *
+   * ### Handling Requests
+   *
+   * When *Ember***Data** needs to fetch or save data it will pass that request to your application's `RequestManager` for fulfillment. How this fulfillment occurs (in-memory, device storage, via single or multiple API requests, etc.) is then up to the registered request handlers.
+   *
+   * To start, let's install the `RequestManager` from `@ember-data/request` and the basic `Fetch` handler from ``@ember-data/request/fetch`.
+   *
+   * > **Note**
+   * > If your app uses `GraphQL`, `REST` or different conventions for `JSON:API` than your cache expects, other handlers may better fit your data. You can author your own handler by creating one that conforms to the [handler interface](https://github.com/emberjs/data/tree/main/packages/request#handling-requests).
+   *
+   * ```ts
+   * import Store from '@ember-data/store';
+   * import RequestManager from '@ember-data/request';
+   * import Fetch from '@ember-data/request/fetch';
+   *
+   * export default class extends Store {
+   *   requestManager = new RequestManager()
+   *    .use([Fetch]);
+   * }
+   * ```
+   *
+   * **Using RequestManager as a Service**
+   *
+   * Alternatively if you have configured the `RequestManager` to be a service you may re-use it.
+   *
+   * *app/services/request.js*
+   * ```ts
+   * import RequestManager from '@ember-data/request';
+   * import Fetch from '@ember-data/request/fetch';
+   *
+   * export default class extends RequestManager {
+   *   constructor(createArgs) {
+   *     super(createArgs);
+   *     this.use([Fetch]);
+   *   }
+   * }
+   * ```
+   *
+   * *app/services/store.js*
+   * ```ts
+   * import Store from '@ember-data/store';
+   * import { service } from '@ember/service';
+   *
+   * export default class extends Store {
+   *   @service('request') requestManager
+   * }
+   * ```
+   *
+   *
+   * ### Presenting Data from the Cache
+   *
+   * Now that we have a source and a cache for our data, we need to configure how
+   * the Store delivers that data back to our application. We do this via the hook
+   * [instantiateRecord](https://api.emberjs.com/ember-data/release/classes/Store/methods/instantiateRecord%20(hook)?anchor=instantiateRecord%20(hook)),
+   * which allows us to transform the data for a resource before handing it to the application.
+   *
+   * A naive way to present the data would be to return it as JSON. Typically instead
+   * this hook will be used to add reactivity and make each unique resource a singleton,
+   * ensuring that if the cache updates our presented data will reflect the new state.
+   *
+   * Below is an example of using the hooks `instantiateRecord` and a `teardownRecord`
+   * to provide minimal read-only reactive state for simple resources.
+   *
+   * ```ts
+   * import Store, { recordIdentifierFor } from '@ember-data/store';
+   * import { TrackedObject } from 'tracked-built-ins';
+   *
+   * class extends Store {
+   *   instantiateRecord(identifier) {
+   *     const { cache, notifications } = this;
+   *
+   *     // create a TrackedObject with our attributes, id and type
+   *     const record = new TrackedObject(Object.assign({}, cache.peek(identifier)));
+   *     record.type = identifier.type;
+   *     record.id = identifier.id;
+   *
+   *     notifications.subscribe(identifier, (_, change) => {
+   *       if (change === 'attributes') {
+   *         Object.assign(record, cache.peek(identifier));
+   *       }
+   *     });
+   *
+   *     return record;
+   *   }
+   * }
+   * ```
+   *
+   * Because `instantiateRecord` is opaque to the nature of the record, an implementation
+   * can be anything from a fairly simple object to a robust proxy that intelligently links
+   * together associated records through relationships.
+   *
+   * This also enables creating a record that separates `edit` flows from `create` flows
+   * entirely. A record class might choose to implement a `checkout`method that gives access
+   * to an editable instance while the primary record continues to be read-only and reflect
+   * only persisted (non-mutated) state.
+   *
+   * Typically you will choose an existing record implementation such as `@ember-data/model`
+   * for your application.
+   *
+   * Because of the boundaries around instantiation and the cache, record implementations
+   * should be capable of interop both with each other and with any `Cache`. Due to this,
+   * if needed an application can utilize multiple record implementations and multiple cache
+   * implementations either to support enhanced features for only a subset of records or to
+   * be able to incrementally migrate from one record/cache to another record or cache.
+   *
+   * > **Note**
+   * > The `ember-data` package automatically includes the `@ember-data/model`
+   * > package and configures it for you.
+   *
+   * @module @ember-data/store
+   * @main @ember-data/store
+   */
+  export { Store as default, type StoreRequestContext, CacheHandler, type Document, type CachePolicy, type StoreRequestInput, recordIdentifierFor, storeFor, } from '@ember-data/store/-private';
+  export type { DocumentCacheOperation, CacheOperation, NotificationType, } from '@ember-data/store/-private/managers/notification-manager';
+  export { setIdentifierGenerationMethod, setIdentifierUpdateMethod, setIdentifierForgetMethod, setIdentifierResetMethod, setKeyInfoForResource, } from '@ember-data/store/-private/caches/identifier-cache';
+}
+//# sourceMappingURL=index.d.ts.map

package/unstable-preview-types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmLG;AAEH,OAAO,EACL,KAAK,IAAI,OAAO,EAChB,KAAK,mBAAmB,EACxB,YAAY,EACZ,KAAK,QAAQ,EACb,KAAK,WAAW,EAChB,KAAK,iBAAiB,EACtB,mBAAmB,EACnB,QAAQ,GACT,MAAM,YAAY,CAAC;AAEpB,YAAY,EACV,sBAAsB,EACtB,cAAc,EACd,gBAAgB,GACjB,MAAM,0CAA0C,CAAC;AAElD,OAAO,EACL,6BAA6B,EAC7B,yBAAyB,EACzB,yBAAyB,EACzB,wBAAwB,EACxB,qBAAqB,GACtB,MAAM,oCAAoC,CAAC"}

package/unstable-preview-types/types.d.ts

@@ -0,0 +1,7 @@
+declare module '@ember-data/store/types' {
+  export type { CacheCapabilitiesManager } from '@ember-data/store/-types/q/cache-capabilities-manager';
+  export type { ModelSchema } from '@ember-data/store/-types/q/ds-model';
+  export type { SchemaService } from '@ember-data/store/-types/q/schema-service';
+  export type { BaseFinderOptions, FindRecordOptions, LegacyResourceQuery, QueryOptions, FindAllOptions, } from '@ember-data/store/-types/q/store';
+}
+//# sourceMappingURL=types.d.ts.map

package/unstable-preview-types/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAC;AACtF,YAAY,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvD,YAAY,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC/D,YAAY,EACV,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACnB,YAAY,EACZ,cAAc,GACf,MAAM,kBAAkB,CAAC"}

package/addon/-private.js

@@ -1 +0,0 @@
-export { A as ARRAY_SIGNAL, f as AdapterPopulatedRecordArray, C as CacheHandler, I as IdentifierArray, M as MUTATE, I as RecordArray, R as RecordArrayManager, g as SOURCE, S as Store, l as StoreMap, _ as _clearCaches, o as _deprecatingNormalize, e as coerceId, h as fastPush, i as isStableIdentifier, n as notifyArray, p as peekCache, r as recordIdentifierFor, j as removeRecordDataFor, m as setCacheFor, c as setIdentifierForgetMethod, a as setIdentifierGenerationMethod, d as setIdentifierResetMethod, b as setIdentifierUpdateMethod, k as setRecordIdentifier, s as storeFor } from "./cache-handler-XLbbNJdo";