@ember-data/model 5.4.0-alpha.3 → 5.4.0-alpha.31

package/unstable-preview-types/-private/references/has-many.d.ts

@@ -0,0 +1,513 @@
+import type { CollectionEdge } from '@ember-data/graph/-private/edges/collection';
+import type { Graph } from '@ember-data/graph/-private/graph';
+import type Store from '@ember-data/store';
+import type { BaseFinderOptions } from '@ember-data/store/-types/q/store';
+import type { StableRecordIdentifier } from '@warp-drive/core-types';
+import type { TypeFromInstanceOrString } from '@warp-drive/core-types/record';
+import type { CollectionResourceDocument, CollectionResourceRelationship, ExistingResourceObject, LinkObject, Meta, PaginationLinks } from '@warp-drive/core-types/spec/raw';
+import type { IsUnknown } from '../belongs-to';
+import type ManyArray from '../many-array';
+/**
+  @module @ember-data/model
+*/
+interface ResourceIdentifier {
+    links?: {
+        related?: string | LinkObject;
+    };
+    meta?: Meta;
+}
+type ArrayItemType<T> = T extends (infer U)[] ? U : never;
+/**
+ A `HasManyReference` is a low-level API that allows access
+ and manipulation of a hasMany relationship.
+
+ It is especially useful when you're dealing with `async` relationships
+ from `@ember-data/model` as it allows synchronous access to
+ the relationship data if loaded, as well as APIs for loading, reloading
+ the data or accessing available information without triggering a load.
+
+ It may also be useful when using `sync` relationships with `@ember-data/model`
+ that need to be loaded/reloaded with more precise timing than marking the
+ relationship as `async` and relying on autofetch would have allowed.
+
+ However,keep in mind that marking a relationship as `async: false` will introduce
+ bugs into your application if the data is not always guaranteed to be available
+ by the time the relationship is accessed. Ergo, it is recommended when using this
+ approach to utilize `links` for unloaded relationship state instead of identifiers.
+
+ Reference APIs are entangled with the relationship's underlying state,
+ thus any getters or cached properties that utilize these will properly
+ invalidate if the relationship state changes.
+
+ References are "stable", meaning that multiple calls to retrieve the reference
+  for a given relationship will always return the same HasManyReference.
+
+ @class HasManyReference
+ @public
+ */
+export default class HasManyReference<T = unknown, K extends string = IsUnknown<T> extends true ? string : keyof T & string, Related = K extends keyof T ? ArrayItemType<Awaited<T[K]>> : unknown> {
+    graph: Graph;
+    store: Store;
+    hasManyRelationship: CollectionEdge;
+    /**
+     * The field name on the parent record for this has-many relationship.
+     *
+     * @property {String} key
+     * @public
+     */
+    key: K;
+    /**
+     * The type of resource this relationship will contain.
+     *
+     * @property {String} type
+     * @public
+     */
+    type: TypeFromInstanceOrString<Related>;
+    ___token: object;
+    ___identifier: StableRecordIdentifier<TypeFromInstanceOrString<T>>;
+    ___relatedTokenMap: Map<StableRecordIdentifier, object>;
+    _ref: number;
+    constructor(store: Store, graph: Graph, parentIdentifier: StableRecordIdentifier<TypeFromInstanceOrString<T>>, hasManyRelationship: CollectionEdge, key: K);
+    /**
+     * This method should never be called by user code.
+     *
+     * @internal
+     */
+    destroy(): void;
+    /**
+     * An array of identifiers for the records that this reference refers to.
+     *
+     * @property {StableRecordIdentifier[]} identifiers
+     * @public
+     */
+    get identifiers(): StableRecordIdentifier<TypeFromInstanceOrString<Related>>[];
+    _resource(): CollectionResourceRelationship;
+    /**
+     This returns a string that represents how the reference will be
+     looked up when it is loaded. If the relationship has a link it will
+     use the "link" otherwise it defaults to "id".
+  
+     Example
+  
+     ```app/models/post.js
+     import Model, { hasMany } from '@ember-data/model';
+  
+     export default class PostModel extends Model {
+       @hasMany('comment', { async: true, inverse: null }) comments;
+     }
+     ```
+  
+     ```javascript
+     let post = store.push({
+       data: {
+         type: 'post',
+         id: 1,
+         relationships: {
+           comments: {
+             data: [{ type: 'comment', id: 1 }]
+           }
+         }
+       }
+     });
+  
+     let commentsRef = post.hasMany('comments');
+  
+     // get the identifier of the reference
+     if (commentsRef.remoteType() === "ids") {
+       let ids = commentsRef.ids();
+     } else if (commentsRef.remoteType() === "link") {
+       let link = commentsRef.link();
+     }
+     ```
+  
+     @method remoteType
+     @public
+     @return {String} The name of the remote type. This should either be `link` or `ids`
+     */
+    remoteType(): 'link' | 'ids';
+    /**
+     `ids()` returns an array of the record IDs in this relationship.
+  
+     Example
+  
+     ```app/models/post.js
+     import Model, { hasMany } from '@ember-data/model';
+  
+     export default class PostModel extends Model {
+       @hasMany('comment', { async: true, inverse: null }) comments;
+     }
+     ```
+  
+     ```javascript
+     let post = store.push({
+       data: {
+         type: 'post',
+         id: 1,
+         relationships: {
+           comments: {
+             data: [{ type: 'comment', id: 1 }]
+           }
+         }
+       }
+     });
+  
+     let commentsRef = post.hasMany('comments');
+  
+     commentsRef.ids(); // ['1']
+     ```
+  
+     @method ids
+      @public
+     @return {Array} The ids in this has-many relationship
+     */
+    ids(): Array<string | null>;
+    /**
+     The link Ember Data will use to fetch or reload this belongs-to
+     relationship. By default it uses only the "related" resource linkage.
+  
+     Example
+  
+     ```javascript
+     // models/blog.js
+     import Model, { belongsTo } from '@ember-data/model';
+     export default Model.extend({
+        user: belongsTo('user', { async: true, inverse: null })
+      });
+  
+     let blog = store.push({
+        data: {
+          type: 'blog',
+          id: 1,
+          relationships: {
+            user: {
+              links: {
+                related: '/articles/1/author'
+              }
+            }
+          }
+        }
+      });
+     let userRef = blog.belongsTo('user');
+  
+     // get the identifier of the reference
+     if (userRef.remoteType() === "link") {
+        let link = userRef.link();
+      }
+     ```
+  
+     @method link
+     @public
+     @return {String} The link Ember Data will use to fetch or reload this belongs-to relationship.
+     */
+    link(): string | null;
+    /**
+     * any links that have been received for this relationship
+     *
+     * @method links
+     * @public
+     * @return
+     */
+    links(): PaginationLinks | null;
+    /**
+     The meta data for the has-many relationship.
+  
+     Example
+  
+     ```javascript
+     // models/blog.js
+     import Model, { hasMany } from '@ember-data/model';
+     export default Model.extend({
+        users: hasMany('user', { async: true, inverse: null })
+      });
+  
+     let blog = store.push({
+        data: {
+          type: 'blog',
+          id: 1,
+          relationships: {
+            users: {
+              links: {
+                related: {
+                  href: '/articles/1/authors'
+                },
+              },
+              meta: {
+                lastUpdated: 1458014400000
+              }
+            }
+          }
+        }
+      });
+  
+     let usersRef = blog.hasMany('user');
+  
+     usersRef.meta() // { lastUpdated: 1458014400000 }
+     ```
+  
+    @method meta
+    @public
+    @return {Object|null} The meta information for the belongs-to relationship.
+    */
+    meta(): Meta | null;
+    /**
+     `push` can be used to update the data in the relationship and EmberData
+     will treat the new data as the canonical value of this relationship on
+     the backend. An empty array will signify the canonical value should be
+     empty.
+  
+     Example model
+  
+     ```app/models/post.js
+     import Model, { hasMany } from '@ember-data/model';
+  
+     export default class PostModel extends Model {
+       @hasMany('comment', { async: true, inverse: null }) comments;
+     }
+     ```
+  
+     Setup some initial state, note we haven't loaded the comments yet:
+  
+     ```js
+     const post = store.push({
+       data: {
+         type: 'post',
+         id: '1',
+         relationships: {
+           comments: {
+             data: [{ type: 'comment', id: '1' }]
+           }
+         }
+       }
+     });
+  
+     const commentsRef = post.hasMany('comments');
+     commentsRef.ids(); // ['1']
+     ```
+  
+     Update the state using `push`, note we can do this even without
+     having loaded these comments yet by providing resource identifiers.
+  
+     Both full resources and resource identifiers are supported.
+  
+     ```js
+     await commentsRef.push({
+      data: [
+       { type: 'comment', id: '2' },
+       { type: 'comment', id: '3' },
+      ]
+     });
+  
+     commentsRef.ids(); // ['2', '3']
+     ```
+  
+     For convenience, you can also pass in an array of resources or resource identifiers
+     without wrapping them in the `data` property:
+  
+     ```js
+     await commentsRef.push([
+       { type: 'comment', id: '4' },
+       { type: 'comment', id: '5' },
+     ]);
+  
+     commentsRef.ids(); // ['4', '5']
+     ```
+  
+     When using the `data` property, you may also include other resource data via included,
+     as well as provide new links and meta to the relationship.
+  
+     ```js
+     await commentsRef.push({
+       links: {
+         related: '/posts/1/comments'
+       },
+       meta: {
+         total: 2
+       },
+       data: [
+         { type: 'comment', id: '4' },
+         { type: 'comment', id: '5' },
+       ],
+       included: [
+         { type: 'other-thing', id: '1', attributes: { foo: 'bar' },
+       ]
+     });
+     ```
+  
+     By default, the store will attempt to fetch any unloaded records before resolving
+     the returned promise with the ManyArray.
+  
+     Alternatively, pass `true` as the second argument to avoid fetching unloaded records
+     and instead the promise will resolve with void without attempting to fetch. This is
+     particularly useful if you want to update the state of the relationship without
+     forcing the load of all of the associated records.
+  
+     @method push
+     @public
+     @param {Array|Object} doc a JSONAPI document object describing the new value of this relationship.
+     @param {Boolean} [skipFetch] if `true`, do not attempt to fetch unloaded records
+     @return {Promise<ManyArray | void>}
+    */
+    push(doc: ExistingResourceObject[] | CollectionResourceDocument, skipFetch?: boolean): Promise<ManyArray<Related> | void>;
+    _isLoaded(): boolean | undefined;
+    /**
+     `value()` synchronously returns the current value of the has-many
+     relationship. Unlike `record.relationshipName`, calling
+     `value()` on a reference does not trigger a fetch if the async
+     relationship is not yet loaded. If the relationship is not loaded
+     it will always return `null`.
+  
+     Example
+  
+     ```app/models/post.js
+     import Model, { hasMany } from '@ember-data/model';
+  
+     export default class PostModel extends Model {
+       @hasMany('comment', { async: true, inverse: null }) comments;
+     }
+     ```
+  
+     ```javascript
+     let post = store.push({
+       data: {
+         type: 'post',
+         id: 1,
+         relationships: {
+           comments: {
+             data: [{ type: 'comment', id: 1 }]
+           }
+         }
+       }
+     });
+  
+     let commentsRef = post.hasMany('comments');
+  
+     post.comments.then(function(comments) {
+       commentsRef.value() === comments
+     })
+     ```
+  
+     @method value
+      @public
+     @return {ManyArray}
+     */
+    value(): ManyArray<Related> | null;
+    /**
+     Loads the relationship if it is not already loaded.  If the
+     relationship is already loaded this method does not trigger a new
+     load. This causes a request to the specified
+     relationship link or reloads all items currently in the relationship.
+  
+     Example
+  
+     ```app/models/post.js
+     import Model, { hasMany } from '@ember-data/model';
+  
+     export default class PostModel extends Model {
+       @hasMany('comment', { async: true, inverse: null }) comments;
+     }
+     ```
+  
+     ```javascript
+     let post = store.push({
+       data: {
+         type: 'post',
+         id: 1,
+         relationships: {
+           comments: {
+             data: [{ type: 'comment', id: 1 }]
+           }
+         }
+       }
+     });
+  
+     let commentsRef = post.hasMany('comments');
+  
+     commentsRef.load().then(function(comments) {
+       //...
+     });
+     ```
+  
+     You may also pass in an options object whose properties will be
+     fed forward. This enables you to pass `adapterOptions` into the
+     request given to the adapter via the reference.
+  
+     Example
+  
+     ```javascript
+     commentsRef.load({ adapterOptions: { isPrivate: true } })
+       .then(function(comments) {
+         //...
+       });
+     ```
+  
+     ```app/adapters/comment.js
+     export default ApplicationAdapter.extend({
+       findMany(store, type, id, snapshots) {
+         // In the adapter you will have access to adapterOptions.
+         let adapterOptions = snapshots[0].adapterOptions;
+       }
+     });
+     ```
+  
+     @method load
+     @public
+     @param {Object} options the options to pass in.
+     @return {Promise} a promise that resolves with the ManyArray in
+     this has-many relationship.
+     */
+    load(options?: BaseFinderOptions): Promise<ManyArray<Related>>;
+    /**
+     Reloads this has-many relationship. This causes a request to the specified
+     relationship link or reloads all items currently in the relationship.
+  
+     Example
+  
+     ```app/models/post.js
+     import Model, { hasMany } from '@ember-data/model';
+  
+     export default class PostModel extends Model {
+       @hasMany('comment', { async: true, inverse: null }) comments;
+     }
+     ```
+  
+     ```javascript
+     let post = store.push({
+       data: {
+         type: 'post',
+         id: 1,
+         relationships: {
+           comments: {
+             data: [{ type: 'comment', id: 1 }]
+           }
+         }
+       }
+     });
+  
+     let commentsRef = post.hasMany('comments');
+  
+     commentsRef.reload().then(function(comments) {
+       //...
+     });
+     ```
+  
+     You may also pass in an options object whose properties will be
+     fed forward. This enables you to pass `adapterOptions` into the
+     request given to the adapter via the reference. A full example
+     can be found in the `load` method.
+  
+     Example
+  
+     ```javascript
+     commentsRef.reload({ adapterOptions: { isPrivate: true } })
+     ```
+  
+     @method reload
+      @public
+     @param {Object} options the options to pass in.
+     @return {Promise} a promise that resolves with the ManyArray in this has-many relationship.
+     */
+    reload(options?: BaseFinderOptions): Promise<unknown> | import("../promise-many-array").default<unknown>;
+}
+export declare function isMaybeResource(object: ExistingResourceObject | ResourceIdentifier): object is ExistingResourceObject;
+export {};
+//# sourceMappingURL=has-many.d.ts.map

package/unstable-preview-types/-private/references/has-many.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-many.d.ts","sourceRoot":"","sources":["../../../src/-private/references/has-many.ts"],"names":[],"mappings":"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"}

package/unstable-preview-types/-private/schema-provider.d.ts

@@ -0,0 +1,25 @@
+import type Store from '@ember-data/store';
+import type { FieldSchema } from '@ember-data/store/-types/q/schema-service';
+import type { RecordIdentifier } from '@warp-drive/core-types/identifier';
+import type { AttributesSchema, RelationshipsSchema } from '@warp-drive/core-types/schema';
+import type { ModelFactory, ModelStore } from './model';
+export declare class ModelSchemaProvider {
+    store: ModelStore;
+    _relationshipsDefCache: Record<string, RelationshipsSchema>;
+    _attributesDefCache: Record<string, AttributesSchema>;
+    _fieldsDefCache: Record<string, Map<string, FieldSchema>>;
+    constructor(store: ModelStore);
+    fields(identifier: RecordIdentifier | {
+        type: string;
+    }): Map<string, FieldSchema>;
+    attributesDefinitionFor(identifier: RecordIdentifier | {
+        type: string;
+    }): AttributesSchema;
+    relationshipsDefinitionFor(identifier: RecordIdentifier | {
+        type: string;
+    }): RelationshipsSchema;
+    doesTypeExist(modelName: string): boolean;
+}
+export declare function buildSchema(store: Store): ModelSchemaProvider;
+export declare function getModelFactory(store: ModelStore, type: string): ModelFactory | null;
+//# sourceMappingURL=schema-provider.d.ts.map

package/unstable-preview-types/-private/schema-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-provider.d.ts","sourceRoot":"","sources":["../../src/-private/schema-provider.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,mBAAmB,CAAC;AAC3C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2CAA2C,CAAC;AAC7E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mCAAmC,CAAC;AAC1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAE3F,OAAO,KAAK,EAAuB,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAI7E,qBAAa,mBAAmB;IACtB,KAAK,EAAE,UAAU,CAAC;IAClB,sBAAsB,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IAC5D,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IACtD,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;gBAEtD,KAAK,EAAE,UAAU;IAO7B,MAAM,CAAC,UAAU,EAAE,gBAAgB,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC;IAwBjF,uBAAuB,CAAC,UAAU,EAAE,gBAAgB,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,gBAAgB;IAmB1F,0BAA0B,CAAC,UAAU,EAAE,gBAAgB,GAAG;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,GAAG,mBAAmB;IAehG,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;CAM1C;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,KAAK,uBAEvC;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAkCpF"}

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

@@ -0,0 +1,9 @@
+export type DecoratorPropertyDescriptor = (PropertyDescriptor & {
+    initializer?: () => unknown;
+}) | undefined;
+export declare function isElementDescriptor(args: unknown[]): args is [object, string, DecoratorPropertyDescriptor];
+export type DataDecorator = (target: object, key: string, desc?: DecoratorPropertyDescriptor) => DecoratorPropertyDescriptor;
+export type DataDecoratorFactory = (...args: unknown[]) => DataDecorator;
+export declare function computedMacroWithOptionalParams(fn: DataDecorator | DataDecoratorFactory): (...maybeDesc: unknown[]) => DecoratorPropertyDescriptor | DataDecorator;
+export declare function normalizeModelName(type: string): string;
+//# sourceMappingURL=util.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/-private/util.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,2BAA2B,GAAG,CAAC,kBAAkB,GAAG;IAAE,WAAW,CAAC,EAAE,MAAM,OAAO,CAAA;CAAE,CAAC,GAAG,SAAS,CAAC;AAE7G,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,2BAA2B,CAAC,CAkB1G;AAED,MAAM,MAAM,aAAa,GAAG,CAC1B,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,2BAA2B,KAC/B,2BAA2B,CAAC;AACjC,MAAM,MAAM,oBAAoB,GAAG,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,aAAa,CAAC;AAEzE,wBAAgB,+BAA+B,CAAC,EAAE,EAAE,aAAa,GAAG,oBAAoB,kBAChE,OAAO,EAAE,iDAIhC;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAsBvD"}

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

@@ -0,0 +1,10 @@
+export { attr } from './-private/attr';
+export { belongsTo } from './-private/belongs-to';
+export { hasMany } from './-private/has-many';
+export { Model } from './-private/model';
+export { default as Errors } from './-private/errors';
+export { default as ManyArray } from './-private/many-array';
+export { PromiseBelongsTo } from './-private/promise-belongs-to';
+export { default as PromiseManyArray } from './-private/promise-many-array';
+export { lookupLegacySupport, LEGACY_SUPPORT } from './-private/legacy-relationships-support';
+//# sourceMappingURL=-private.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"-private.d.ts","sourceRoot":"","sources":["../src/-private.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEtD,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAG5E,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,yCAAyC,CAAC"}

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

@@ -0,0 +1,3 @@
+export { instantiateRecord, teardownRecord, modelFor } from './-private/hooks';
+export { buildSchema } from './-private/schema-provider';
+//# sourceMappingURL=hooks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC/E,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC"}

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

@@ -0,0 +1,46 @@
+/**
+ * This package provides a Presentation Model for resource data in an EmberData Cache.
+ *
+ * Models are defined as classes extending from `import Model from '@ember-data/model';` and the
+ * attributes and relationships on these classes are parsed at runtime to supply static "schema"
+ * to EmberData's SchemaService.
+ *
+ * Resource data for individual resources fetched from your API is presented to the UI via instances
+ * of the `Model`s you define. An instantiated `Model` is referred to as a `record`.
+
+  When we refer to the `ModelClass` as opposed to a `Model` or `Record` we are referring
+  specifically to the class definition and the static schema methods present on it.
+
+  When we refer to a `record` we refer to a specific class instance presenting
+  the resource data for a given `type` and `id`.
+
+  ### Defining a Model
+
+  ```app/models/person.js
+  import Model, { attr, belongsTo, hasMany } from '@ember-data/model';
+
+  export default class PersonModel extends Model {
+    @attr name;
+
+    @belongsTo('pet', { inverse: 'owners', async: false }) dog;
+
+    @hasMany('person', { inverse: 'friends', async: true }) friends;
+  }
+  ```
+
+  ### modelName convention
+
+  By convention, the name of a given model (its `type`) matches the name
+  of the file in the `app/models` folder and should be lowercase, singular
+  and dasherized.
+
+  @module @ember-data/model
+  @main @ember-data/model
+ */
+export { Model as default, attr, belongsTo, hasMany } from './-private';
+export type { PromiseBelongsTo as AsyncBelongsTo } from './-private/promise-belongs-to';
+export type { default as AsyncHasMany } from './-private/promise-many-array';
+export type { default as ManyArray } from './-private/many-array';
+export { instantiateRecord, teardownRecord, modelFor } from './-private/hooks';
+export { ModelSchemaProvider } from './-private/schema-provider';
+//# 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,OAAO,EAAE,KAAK,IAAI,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAExE,YAAY,EAAE,gBAAgB,IAAI,cAAc,EAAE,MAAM,+BAA+B,CAAC;AACxF,YAAY,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAC7E,YAAY,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClE,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC/E,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC"}

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

@@ -0,0 +1,9 @@
+import type { FieldSchema } from '@ember-data/store/-types/q/schema-service';
+type Derivation<R, T> = (record: R, options: Record<string, unknown> | null, prop: string) => T;
+type SchemaService = {
+    registerDerivation(name: string, derivation: Derivation<unknown, unknown>): void;
+};
+export declare function withFields(fields: FieldSchema[]): FieldSchema[];
+export declare function registerDerivations(schema: SchemaService): void;
+export {};
+//# sourceMappingURL=migration-support.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"migration-support.d.ts","sourceRoot":"","sources":["../src/migration-support.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2CAA2C,CAAC;AAmB7E,KAAK,UAAU,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,EAAE,IAAI,EAAE,MAAM,KAAK,CAAC,CAAC;AAChG,KAAK,aAAa,GAAG;IACnB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,UAAU,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CAClF,CAAC;AAqGF,wBAAgB,UAAU,CAAC,MAAM,EAAE,WAAW,EAAE,iBAgC/C;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,aAAa,QAExD"}