@ember-data/model 5.4.0-alpha.4 → 5.4.0-alpha.43

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

@@ -0,0 +1,515 @@
+declare module '@ember-data/model/-private/references/has-many' {
+  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 '@ember-data/model/-private/belongs-to';
+  import type ManyArray from '@ember-data/model/-private/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<import("@warp-drive/core-types/spec/raw").ExistingResourceIdentifierObject<string> | import("@warp-drive/core-types/spec/raw").NewResourceIdentifierObject<string>>;
+      /**
+       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<ManyArray<Related>>;
+  }
+  export 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,27 @@
+declare module '@ember-data/model/-private/schema-provider' {
+  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 '@ember-data/model/-private/model';
+  export 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 function buildSchema(store: Store): ModelSchemaProvider;
+  export 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,11 @@
+declare module '@ember-data/model/-private/util' {
+  export type DecoratorPropertyDescriptor = (PropertyDescriptor & {
+      initializer?: () => unknown;
+  }) | undefined;
+  export 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 function computedMacroWithOptionalParams(fn: DataDecorator | DataDecoratorFactory): (...maybeDesc: unknown[]) => DecoratorPropertyDescriptor | DataDecorator;
+  export 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,12 @@
+declare module '@ember-data/model/-private' {
+  export { attr } from '@ember-data/model/-private/attr';
+  export { belongsTo } from '@ember-data/model/-private/belongs-to';
+  export { hasMany } from '@ember-data/model/-private/has-many';
+  export { Model } from '@ember-data/model/-private/model';
+  export { default as Errors } from '@ember-data/model/-private/errors';
+  export { default as ManyArray } from '@ember-data/model/-private/many-array';
+  export { PromiseBelongsTo } from '@ember-data/model/-private/promise-belongs-to';
+  export { default as PromiseManyArray } from '@ember-data/model/-private/promise-many-array';
+  export { lookupLegacySupport, LEGACY_SUPPORT } from '@ember-data/model/-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,5 @@
+declare module '@ember-data/model/hooks' {
+  export { instantiateRecord, teardownRecord, modelFor } from '@ember-data/model/-private/hooks';
+  export { buildSchema } from '@ember-data/model/-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,75 @@
+/// <reference path="./migration-support.d.ts" />
+/// <reference path="./hooks.d.ts" />
+/// <reference path="./-private.d.ts" />
+/// <reference path="./-private/record-state.d.ts" />
+/// <reference path="./-private/model.d.ts" />
+/// <reference path="./-private/model-methods.d.ts" />
+/// <reference path="./-private/promise-many-array.d.ts" />
+/// <reference path="./-private/util.d.ts" />
+/// <reference path="./-private/has-many.d.ts" />
+/// <reference path="./-private/belongs-to.d.ts" />
+/// <reference path="./-private/attr.type-test.d.ts" />
+/// <reference path="./-private/legacy-relationships-support.d.ts" />
+/// <reference path="./-private/many-array.d.ts" />
+/// <reference path="./-private/attr.d.ts" />
+/// <reference path="./-private/promise-belongs-to.d.ts" />
+/// <reference path="./-private/hooks.d.ts" />
+/// <reference path="./-private/notify-changes.d.ts" />
+/// <reference path="./-private/schema-provider.d.ts" />
+/// <reference path="./-private/has-many.type-test.d.ts" />
+/// <reference path="./-private/belongs-to.type-test.d.ts" />
+/// <reference path="./-private/model.type-test.d.ts" />
+/// <reference path="./-private/model-for-mixin.d.ts" />
+/// <reference path="./-private/promise-proxy-base.d.ts" />
+/// <reference path="./-private/errors.d.ts" />
+/// <reference path="./-private/debug/assert-polymorphic-type.d.ts" />
+/// <reference path="./-private/references/has-many.d.ts" />
+/// <reference path="./-private/references/belongs-to.d.ts" />
+declare module '@ember-data/model' {
+  /**
+   * 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 '@ember-data/model/-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 '@ember-data/model/-private/hooks';
+  export { ModelSchemaProvider } from '@ember-data/model/-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"}