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

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

@@ -0,0 +1,195 @@
+import type Store from '@ember-data/store';
+import { MUTATE, RecordArray } from '@ember-data/store/-private';
+import type { CreateRecordProperties } from '@ember-data/store/-private/store-service';
+import type { Cache } from '@ember-data/store/-types/q/cache';
+import type { ModelSchema } from '@ember-data/store/-types/q/ds-model';
+import type { BaseFinderOptions } from '@ember-data/store/-types/q/store';
+import type { Signal } from '@ember-data/tracking/-private';
+import type { StableRecordIdentifier } from '@warp-drive/core-types';
+import type { TypedRecordInstance, TypeFromInstance } from '@warp-drive/core-types/record';
+import type { Links, PaginationLinks } from '@warp-drive/core-types/spec/raw';
+import type { LegacySupport } from './legacy-relationships-support';
+export interface ManyArrayCreateArgs {
+    identifiers: StableRecordIdentifier[];
+    type: string;
+    store: Store;
+    allowMutation: boolean;
+    manager: LegacySupport;
+    identifier: StableRecordIdentifier;
+    cache: Cache;
+    meta: Record<string, unknown> | null;
+    links: Links | PaginationLinks | null;
+    key: string;
+    isPolymorphic: boolean;
+    isAsync: boolean;
+    _inverseIsAsync: boolean;
+    isLoaded: boolean;
+}
+/**
+  A `ManyArray` is a `MutableArray` that represents the contents of a has-many
+  relationship.
+
+  The `ManyArray` is instantiated lazily the first time the relationship is
+  requested.
+
+  This class is not intended to be directly instantiated by consuming applications.
+
+  ### Inverses
+
+  Often, the relationships in Ember Data applications will have
+  an inverse. For example, imagine the following models are
+  defined:
+
+  ```app/models/post.js
+  import Model, { hasMany } from '@ember-data/model';
+
+  export default class PostModel extends Model {
+    @hasMany('comment') comments;
+  }
+  ```
+
+  ```app/models/comment.js
+  import Model, { belongsTo } from '@ember-data/model';
+
+  export default class CommentModel extends Model {
+    @belongsTo('post') post;
+  }
+  ```
+
+  If you created a new instance of `Post` and added
+  a `Comment` record to its `comments` has-many
+  relationship, you would expect the comment's `post`
+  property to be set to the post that contained
+  the has-many.
+
+  We call the record to which a relationship belongs-to the
+  relationship's _owner_.
+
+  @class ManyArray
+  @public
+*/
+export default class RelatedCollection<T = unknown> extends RecordArray<T> {
+    isAsync: boolean;
+    /**
+      The loading state of this array
+  
+      @property {Boolean} isLoaded
+      @public
+      */
+    isLoaded: boolean;
+    /**
+      `true` if the relationship is polymorphic, `false` otherwise.
+  
+      @property {Boolean} isPolymorphic
+      @private
+      */
+    isPolymorphic: boolean;
+    _inverseIsAsync: boolean;
+    /**
+      Metadata associated with the request for async hasMany relationships.
+  
+      Example
+  
+      Given that the server returns the following JSON payload when fetching a
+      hasMany relationship:
+  
+      ```js
+      {
+        "comments": [{
+          "id": 1,
+          "comment": "This is the first comment",
+        }, {
+      // ...
+        }],
+  
+        "meta": {
+          "page": 1,
+          "total": 5
+        }
+      }
+      ```
+  
+      You can then access the meta data via the `meta` property:
+  
+      ```js
+      let comments = await post.comments;
+      let meta = comments.meta;
+  
+      // meta.page => 1
+      // meta.total => 5
+      ```
+  
+      @property {Object | null} meta
+      @public
+      */
+    meta: Record<string, unknown> | null;
+    /**
+       * Retrieve the links for this relationship
+       *
+       @property {Object | null} links
+       @public
+       */
+    links: Links | PaginationLinks | null;
+    identifier: StableRecordIdentifier;
+    cache: Cache;
+    _manager: LegacySupport;
+    store: Store;
+    key: string;
+    type: ModelSchema;
+    modelName: T extends TypedRecordInstance ? TypeFromInstance<T> : string;
+    constructor(options: ManyArrayCreateArgs);
+    [MUTATE](target: StableRecordIdentifier[], receiver: typeof Proxy<StableRecordIdentifier[], T[]>, prop: string, args: unknown[], _SIGNAL: Signal): unknown;
+    notify(): void;
+    /**
+      Reloads all of the records in the manyArray. If the manyArray
+      holds a relationship that was originally fetched using a links url
+      Ember Data will revisit the original links url to repopulate the
+      relationship.
+  
+      If the manyArray holds the result of a `store.query()` reload will
+      re-run the original query.
+  
+      Example
+  
+      ```javascript
+      let user = store.peekRecord('user', '1')
+      await login(user);
+  
+      let permissions = await user.permissions;
+      await permissions.reload();
+      ```
+  
+      @method reload
+      @public
+    */
+    reload(options?: BaseFinderOptions): Promise<unknown> | import("./promise-many-array").default<unknown>;
+    /**
+      Saves all of the records in the `ManyArray`.
+  
+      Example
+  
+      ```javascript
+      let inbox = await store.findRecord('inbox', '1');
+      let messages = await inbox.messages;
+      messages.forEach((message) => {
+        message.isRead = true;
+      });
+      messages.save();
+      ```
+  
+      @method save
+      @public
+      @return {PromiseArray} promise
+    */
+    /**
+      Create a child record within the owner
+  
+      @method createRecord
+      @public
+      @param {Object} hash
+      @return {Model} record
+    */
+    createRecord(hash: CreateRecordProperties<T>): T;
+    destroy(): void;
+}
+//# sourceMappingURL=many-array.d.ts.map

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

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

package/unstable-preview-types/-private/model-for-mixin.d.ts

@@ -0,0 +1,4 @@
+import type Store from '@ember-data/store';
+import { type ModelFactory } from './model';
+export default function modelForMixin(store: Store, normalizedModelName: string): ModelFactory | undefined;
+//# sourceMappingURL=model-for-mixin.d.ts.map

package/unstable-preview-types/-private/model-for-mixin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-for-mixin.d.ts","sourceRoot":"","sources":["../../src/-private/model-for-mixin.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,MAAM,mBAAmB,CAAC;AAE3C,OAAO,EAAS,KAAK,YAAY,EAAE,MAAM,SAAS,CAAC;AAkBnD,MAAM,CAAC,OAAO,UAAU,aAAa,CAAC,KAAK,EAAE,KAAK,EAAE,mBAAmB,EAAE,MAAM,GAAG,YAAY,GAAG,SAAS,CAYzG"}

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

@@ -0,0 +1,32 @@
+import type { Snapshot } from '@ember-data/legacy-compat/-private';
+import type Store from '@ember-data/store';
+import type { ChangedAttributesHash } from '@warp-drive/core-types/cache';
+import { RecordStore } from '@warp-drive/core-types/symbols';
+import type Errors from './errors';
+import type RecordState from './record-state';
+export interface MinimalLegacyRecord {
+    errors: Errors;
+    ___recordState: RecordState;
+    currentState: RecordState;
+    isDestroyed: boolean;
+    isDestroying: boolean;
+    isReloading: boolean;
+    isValid: boolean;
+    [RecordStore]: Store;
+    deleteRecord(): void;
+    unloadRecord(): void;
+    save<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
+    destroyRecord<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
+}
+export declare function rollbackAttributes(this: MinimalLegacyRecord): void;
+export declare function unloadRecord(this: MinimalLegacyRecord): void;
+export declare function belongsTo(this: MinimalLegacyRecord, prop: string): import("./references/belongs-to").default<unknown, string, unknown> | import("./references/has-many").default<unknown, string, unknown>;
+export declare function hasMany(this: MinimalLegacyRecord, prop: string): import("./references/belongs-to").default<unknown, string, unknown> | import("./references/has-many").default<unknown, string, unknown>;
+export declare function reload<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
+export declare function changedAttributes<T extends MinimalLegacyRecord>(this: T): ChangedAttributesHash;
+export declare function serialize<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): unknown;
+export declare function deleteRecord<T extends MinimalLegacyRecord>(this: T): void;
+export declare function save<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
+export declare function destroyRecord<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<T>;
+export declare function createSnapshot<T extends MinimalLegacyRecord>(this: T): Snapshot<T>;
+//# sourceMappingURL=model-methods.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"model-methods.d.ts","sourceRoot":"","sources":["../../src/-private/model-methods.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAC;AAEnE,OAAO,KAAK,KAAK,MAAM,mBAAmB,CAAC;AAG3C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAC1E,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAE7D,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AAEnC,OAAO,KAAK,WAAW,MAAM,gBAAgB,CAAC;AAE9C,MAAM,WAAW,mBAAmB;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,WAAW,CAAC;IAC5B,YAAY,EAAE,WAAW,CAAC;IAC1B,WAAW,EAAE,OAAO,CAAC;IACrB,YAAY,EAAE,OAAO,CAAC;IACtB,WAAW,EAAE,OAAO,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC;IAErB,YAAY,IAAI,IAAI,CAAC;IACrB,YAAY,IAAI,IAAI,CAAC;IACrB,IAAI,CAAC,CAAC,SAAS,mBAAmB,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAC5F,aAAa,CAAC,CAAC,SAAS,mBAAmB,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CACtG;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,mBAAmB,QAY3D;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,mBAAmB,QAKrD;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,MAAM,2IAEhE;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,MAAM,2IAE9D;AAED,wBAAgB,MAAM,CAAC,CAAC,SAAS,mBAAmB,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAsBhH;AAED,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,mBAAmB,EAAE,IAAI,EAAE,CAAC,GAAG,qBAAqB,CAE/F;AAED,wBAAgB,SAAS,CAAC,CAAC,SAAS,mBAAmB,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAG5G;AAED,wBAAgB,YAAY,CAAC,CAAC,SAAS,mBAAmB,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,CAKzE;AAED,wBAAgB,IAAI,CAAC,CAAC,SAAS,mBAAmB,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAW1G;AAED,wBAAgB,aAAa,CAAC,CAAC,SAAS,mBAAmB,EAAE,IAAI,EAAE,CAAC,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAUnH;AAED,wBAAgB,cAAc,CAAC,CAAC,SAAS,mBAAmB,EAAE,IAAI,EAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,CAalF"}

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

@@ -0,0 +1,101 @@
+import type EmberObject from '@ember/object';
+
+import type { Errors } from './errors';
+import type Store from '@ember-data/store';
+
+import type { AttributeSchema, RelationshipSchema, RelationshipsSchema } from '@warp-drive/core-types/schema';
+import type { JsonApiError } from '@ember-data/store/-types/q/record-data-json-api';
+import type HasManyReference from './references/has-many';
+import type BelongsToReference from './references/belongs-to';
+import type { StableRecordIdentifier } from '@warp-drive/core-types';
+import type { LegacySupport } from './legacy-relationships-support';
+import type { Cache } from '@warp-drive/core-types/cache';
+import type RecordState from './record-state';
+
+export type ModelCreateArgs = {
+  _createProps: Record<string, unknown>;
+  // TODO @deprecate consider deprecating accessing record properties during init which the below is necessary for
+  _secretInit: {
+    identifier: StableRecordIdentifier;
+    cache: Cache;
+    store: Store;
+    cb: (record: Model, cache: Cache, identifier: StableRecordIdentifier, store: Store) => void;
+  };
+};
+
+class Model extends EmberObject {
+  store: Store;
+  errors: Errors;
+  currentState: RecordState;
+  adapterError?: Error;
+  toString(): string;
+  save(): Promise<this>;
+  hasMany<T extends keyof this & string>(key: T): HasManyReference<this, T>;
+  belongsTo<T extends keyof this & string>(key: T): BelongsToReference<this, T>;
+  eachRelationship<T extends Model, K extends keyof T & string>(
+    callback: (this: T, key: K, meta: RelationshipSchema) => void,
+    binding?: T
+  ): void;
+  eachAttribute<T extends Model, K extends keyof T & string>(
+    callback: (this: T, key: K, meta: AttributeSchema) => void,
+    binding?: T
+  ): void;
+  invalidErrorsChanged(errors: JsonApiError[]): void;
+  rollbackAttributes(): void;
+  changedAttributes(): Record<string, [unknown, unknown]>;
+  id: string;
+  isValid: boolean;
+  isSaving: boolean;
+  isNew: boolean;
+  isEmpty: boolean;
+  isDeleted: boolean;
+  hasDirtyAttributes: boolean;
+  isLoaded: boolean;
+  isLoading: boolean;
+  isReloading: boolean;
+  dirtyType: string;
+  deleteRecord(): void;
+  unloadRecord(): void;
+  serialize(): Record<string, unknown>;
+
+  static modelName: string;
+  static fields: Map<keyof this & string, 'attribute' | 'belongsTo' | 'hasMany'>;
+  static attributes: Map<keyof this & string, AttributeSchema>;
+  static relationshipsByName: Map<keyof this & string, RelationshipSchema>;
+  static eachAttribute<K extends keyof this & string>(
+    callback: (this: ModelSchema<this>, key: K, attribute: AttributeSchema) => void,
+    binding?: T
+  ): void;
+  static eachRelationship<K extends keyof this & string>(
+    callback: (this: ModelSchema<this>, key: K, relationship: RelationshipSchema) => void,
+    binding?: T
+  ): void;
+  static eachTransformedAttribute<K extends keyof this & string>(
+    callback: (this: ModelSchema<this>, key: K, type: string | null) => void,
+    binding?: T
+  ): void;
+
+  static toString(): string;
+  static isModel: true;
+  static relationshipsObject: RelationshipsSchema;
+  static extend(...mixins: unknown[]): typeof Model;
+  static create(createArgs: ModelCreateArgs): Model;
+  static __isMixin?: true;
+  static __mixin?: unknown;
+}
+
+interface Model {
+  constructor: typeof Model;
+}
+
+export { Model };
+
+export type StaticModel = typeof Model;
+
+export const LEGACY_SUPPORT: Map<StableRecordIdentifier | Model, LegacySupport>;
+
+export type ModelFactory = { class: StaticModel };
+export type FactoryCache = Record<string, ModelFactory>;
+// we put this on the store for interop because it's used by modelFor and
+// instantiateRecord as well.
+export type ModelStore = Store & { _modelFactoryCache: FactoryCache };

package/unstable-preview-types/-private/model.type-test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=model.type-test.d.ts.map

package/unstable-preview-types/-private/model.type-test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.type-test.d.ts","sourceRoot":"","sources":["../../src/-private/model.type-test.ts"],"names":[],"mappings":""}

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

@@ -0,0 +1,6 @@
+import type Store from '@ember-data/store';
+import type { NotificationType } from '@ember-data/store/-private/managers/notification-manager';
+import type { StableRecordIdentifier } from '@warp-drive/core-types';
+import type { Model } from './model';
+export default function notifyChanges(identifier: StableRecordIdentifier, value: NotificationType, key: string | undefined, record: Model, store: Store): void;
+//# sourceMappingURL=notify-changes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"notify-changes.d.ts","sourceRoot":"","sources":["../../src/-private/notify-changes.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,MAAM,mBAAmB,CAAC;AAC3C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0DAA0D,CAAC;AACjG,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAIrE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC,MAAM,CAAC,OAAO,UAAU,aAAa,CACnC,UAAU,EAAE,sBAAsB,EAClC,KAAK,EAAE,gBAAgB,EACvB,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,MAAM,EAAE,KAAK,EACb,KAAK,EAAE,KAAK,QAuBb"}

package/unstable-preview-types/-private/promise-belongs-to.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="ember-source/types" />
+/// <reference types="ember-source/types" />
+import type PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
+import type ObjectProxy from '@ember/object/proxy';
+import type Store from '@ember-data/store';
+import type { OpaqueRecordInstance } from '@ember-data/store/-types/q/record-instance';
+import type { TypeFromInstanceOrString } from '@warp-drive/core-types/record';
+import type { LegacySupport } from './legacy-relationships-support';
+export interface BelongsToProxyMeta<T = unknown> {
+    key: string;
+    store: Store;
+    legacySupport: LegacySupport;
+    modelName: TypeFromInstanceOrString<T>;
+}
+export interface BelongsToProxyCreateArgs<T = unknown> {
+    promise: Promise<T | null>;
+    content?: T | null;
+    _belongsToState: BelongsToProxyMeta<T>;
+}
+interface PromiseObjectType<T> extends PromiseProxyMixin<T | null>, ObjectProxy<T> {
+    new <PT>(...args: unknown[]): PromiseObjectType<PT>;
+}
+declare class PromiseObjectType<T> {
+}
+declare const Extended: PromiseObjectType<OpaqueRecordInstance>;
+/**
+ @module @ember-data/model
+ */
+/**
+  A PromiseBelongsTo is a PromiseObject that also proxies certain method calls
+  to the underlying belongsTo model.
+  Right now we proxy:
+    * `reload()`
+  @class PromiseBelongsTo
+  @extends PromiseObject
+  @private
+*/
+declare class PromiseBelongsTo<T = unknown> extends Extended<T> {
+    _belongsToState: BelongsToProxyMeta<T>;
+    get id(): string | null;
+    get meta(): void;
+    reload(options: Record<string, unknown>): Promise<this>;
+}
+export { PromiseBelongsTo };
+//# sourceMappingURL=promise-belongs-to.d.ts.map

package/unstable-preview-types/-private/promise-belongs-to.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise-belongs-to.d.ts","sourceRoot":"","sources":["../../src/-private/promise-belongs-to.ts"],"names":[],"mappings":";;AAEA,OAAO,KAAK,iBAAiB,MAAM,mCAAmC,CAAC;AACvE,OAAO,KAAK,WAAW,MAAM,qBAAqB,CAAC;AAEnD,OAAO,KAAK,KAAK,MAAM,mBAAmB,CAAC;AAC3C,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4CAA4C,CAAC;AAEvF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,+BAA+B,CAAC;AAE9E,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAIpE,MAAM,WAAW,kBAAkB,CAAC,CAAC,GAAG,OAAO;IAC7C,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,KAAK,CAAC;IACb,aAAa,EAAE,aAAa,CAAC;IAC7B,SAAS,EAAE,wBAAwB,CAAC,CAAC,CAAC,CAAC;CACxC;AACD,MAAM,WAAW,wBAAwB,CAAC,CAAC,GAAG,OAAO;IACnD,OAAO,EAAE,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAC3B,OAAO,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC;IACnB,eAAe,EAAE,kBAAkB,CAAC,CAAC,CAAC,CAAC;CACxC;AAED,UAAU,iBAAiB,CAAC,CAAC,CAAE,SAAQ,iBAAiB,CAAC,CAAC,GAAG,IAAI,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC;IAEhF,KAAK,EAAE,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,iBAAiB,CAAC,EAAE,CAAC,CAAC;CACrD;AAED,OAAO,OAAO,iBAAiB,CAAC,CAAC;CAAI;AAErC,QAAA,MAAM,QAAQ,EAAE,iBAAiB,CAAC,oBAAoB,CACe,CAAC;AAEtE;;GAEG;AAEH;;;;;;;;EAQE;AACF,cAAM,gBAAgB,CAAC,CAAC,GAAG,OAAO,CAAE,SAAQ,QAAQ,CAAC,CAAC,CAAC;IAC7C,eAAe,EAAE,kBAAkB,CAAC,CAAC,CAAC,CAAC;IAE/C,IACI,EAAE,kBAKL;IAKD,IACI,IAAI,SAWP;IAEK,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;CAM9D;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/unstable-preview-types/-private/promise-many-array.d.ts

@@ -0,0 +1,127 @@
+import type { BaseFinderOptions } from '@ember-data/store/-types/q/store';
+import type ManyArray from './many-array';
+export interface HasManyProxyCreateArgs<T = unknown> {
+    promise: Promise<ManyArray<T>>;
+    content?: ManyArray<T>;
+}
+/**
+ @module @ember-data/model
+ */
+/**
+  This class is returned as the result of accessing an async hasMany relationship
+  on an instance of a Model extending from `@ember-data/model`.
+
+  A PromiseManyArray is an iterable proxy that allows templates to consume related
+  ManyArrays and update once their contents are no longer pending.
+
+  In your JS code you should resolve the promise first.
+
+  ```js
+  const comments = await post.comments;
+  ```
+
+  @class PromiseManyArray
+  @public
+*/
+export default class PromiseManyArray<T = unknown> {
+    promise: Promise<ManyArray<T>> | null;
+    isDestroyed: boolean;
+    content: ManyArray<T> | null;
+    constructor(promise: Promise<ManyArray<T>>, content?: ManyArray<T>);
+    /**
+     * Retrieve the length of the content
+     * @property length
+     * @public
+     */
+    get length(): number;
+    /**
+     * Iterate the proxied content. Called by the glimmer iterator in #each
+     * We do not guarantee that forEach will always be available. This
+     * may eventually be made to use Symbol.Iterator once glimmer supports it.
+     *
+     * @method forEach
+     * @param cb
+     * @return
+     * @private
+     */
+    forEach(cb: (item: T, index: number, array: T[]) => void): void;
+    /**
+     * Reload the relationship
+     * @method reload
+     * @public
+     * @param options
+     * @return
+     */
+    reload(options: Omit<BaseFinderOptions, ''>): this;
+    /**
+     * Whether the loading promise is still pending
+     *
+     * @property {boolean} isPending
+     * @public
+     */
+    isPending: boolean;
+    /**
+     * Whether the loading promise rejected
+     *
+     * @property {boolean} isRejected
+     * @public
+     */
+    isRejected: boolean;
+    /**
+     * Whether the loading promise succeeded
+     *
+     * @property {boolean} isFulfilled
+     * @public
+     */
+    isFulfilled: boolean;
+    /**
+     * Whether the loading promise completed (resolved or rejected)
+     *
+     * @property {boolean} isSettled
+     * @public
+     */
+    isSettled: boolean;
+    /**
+     * chain this promise
+     *
+     * @method then
+     * @public
+     * @param success
+     * @param fail
+     * @return Promise
+     */
+    then(s: Parameters<Promise<ManyArray<T>>['then']>[0], f?: Parameters<Promise<ManyArray<T>>['then']>[1]): Promise<unknown>;
+    /**
+     * catch errors thrown by this promise
+     * @method catch
+     * @public
+     * @param callback
+     * @return Promise
+     */
+    catch(cb: Parameters<Promise<ManyArray<T>>['catch']>[0]): Promise<unknown>;
+    /**
+     * run cleanup after this promise completes
+     *
+     * @method finally
+     * @public
+     * @param callback
+     * @return Promise
+     */
+    finally(cb: Parameters<Promise<ManyArray<T>>['finally']>[0]): Promise<ManyArray<T>>;
+    destroy(): void;
+    /**
+     * Retrieve the links for this relationship
+     * @property links
+     * @public
+     */
+    get links(): import("@warp-drive/core-types/spec/raw").Links | null | undefined;
+    /**
+     * Retrieve the meta for this relationship
+     * @property meta
+     * @public
+     */
+    get meta(): Record<string, unknown> | null | undefined;
+    _update(promise: Promise<ManyArray<T>>, content?: ManyArray<T>): void;
+    static create<T>({ promise, content }: HasManyProxyCreateArgs<T>): PromiseManyArray<T>;
+}
+//# sourceMappingURL=promise-many-array.d.ts.map

package/unstable-preview-types/-private/promise-many-array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"promise-many-array.d.ts","sourceRoot":"","sources":["../../src/-private/promise-many-array.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAI1E,OAAO,KAAK,SAAS,MAAM,cAAc,CAAC;AAE1C,MAAM,WAAW,sBAAsB,CAAC,CAAC,GAAG,OAAO;IACjD,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/B,OAAO,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC;CACxB;AAED;;GAEG;AACH;;;;;;;;;;;;;;;EAeE;AACF,MAAM,CAAC,OAAO,OAAO,gBAAgB,CAAC,CAAC,GAAG,OAAO;IACvC,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IACtC,WAAW,EAAE,OAAO,CAAC;IACrB,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;gBAEzB,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC;IAKlE;;;;OAIG;IACH,IACI,MAAM,IAAI,MAAM,CAOnB;IAED;;;;;;;;;OASG;IACH,OAAO,CAAC,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,IAAI;IAMxD;;;;;;OAMG;IACH,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,iBAAiB,EAAE,EAAE,CAAC;IAQ3C;;;;;OAKG;IACK,SAAS,EAAE,OAAO,CAAC;IAC3B;;;;;OAKG;IACK,UAAU,EAAE,OAAO,CAAC;IAC5B;;;;;OAKG;IACK,WAAW,EAAE,OAAO,CAAC;IAC7B;;;;;OAKG;IACK,SAAS,EAAE,OAAO,CAAC;IAE3B;;;;;;;;OAQG;IACH,IAAI,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IAItG;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,EAAE,UAAU,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;IAIvD;;;;;;;OAOG;IACH,OAAO,CAAC,EAAE,EAAE,UAAU,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;IAM3D,OAAO;IAQP;;;;OAIG;IACH,IACI,KAAK,uEAER;IAED;;;;OAIG;IACH,IACI,IAAI,+CAEP;IAID,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC;IAQ9D,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,sBAAsB,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC;CAGvF"}

package/unstable-preview-types/-private/promise-proxy-base.d.ts

@@ -0,0 +1,32 @@
+import ObjectProxy from '@ember/object/proxy';
+
+export interface PromiseObject<T> extends Promise<T> {}
+export class PromiseObject<T> extends ObjectProxy<T> {
+  declare content?: T | null;
+
+  /*
+   * If the proxied promise is rejected this will contain the reason
+   * provided.
+   */
+  reason: string | Error;
+  /*
+   * Once the proxied promise has settled this will become `false`.
+   */
+  isPending: boolean;
+  /*
+   * Once the proxied promise has settled this will become `true`.
+   */
+  isSettled: boolean;
+  /*
+   * Will become `true` if the proxied promise is rejected.
+   */
+  isRejected: boolean;
+  /*
+   * Will become `true` if the proxied promise is fulfilled.
+   */
+  isFulfilled: boolean;
+  /*
+   * The promise whose fulfillment value is being proxied by this object.
+   */
+  promise: Promise<T>;
+}

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

@@ -0,0 +1,89 @@
+import type Store from '@ember-data/store';
+import type RequestStateService from '@ember-data/store/-private/network/request-cache';
+import type { RequestState } from '@ember-data/store/-private/network/request-cache';
+import type { Cache } from '@ember-data/store/-types/q/cache';
+import type { StableRecordIdentifier } from '@warp-drive/core-types';
+import type Errors from './errors';
+import type { MinimalLegacyRecord } from './model-methods';
+/**
+ * A decorator that caches a getter while
+ * providing the ability to bust that cache
+ * when we so choose in a way that notifies
+ * tracking systems.
+ *
+ * @internal
+ */
+export declare function tagged<T extends object, K extends keyof T & string>(_target: T, key: K, desc: PropertyDescriptor): PropertyDescriptor;
+export declare function notifySignal<T extends object, K extends keyof T & string>(obj: T, key: K): void;
+/**
+Historically EmberData managed a state machine
+for each record, the localState for which
+was reflected onto Model.
+
+This implements the flags and stateName for backwards compat
+with the state tree that used to be possible (listed below).
+
+stateName and dirtyType are candidates for deprecation.
+
+root
+  empty
+    deleted    // hidden from stateName
+    preloaded  // hidden from stateName
+
+  loading
+     empty     // hidden from stateName
+     preloaded // hidden from stateName
+
+  loaded
+    saved
+    updated
+      uncommitted
+      invalid
+      inFlight
+    created
+      uncommitted
+      invalid
+      inFlight
+
+  deleted
+    saved
+      new      // hidden from stateName
+    uncommitted
+    invalid
+    inFlight
+
+  @internal
+*/
+export default class RecordState {
+    store: Store;
+    identifier: StableRecordIdentifier;
+    record: MinimalLegacyRecord;
+    rs: RequestStateService;
+    pendingCount: number;
+    fulfilledCount: number;
+    rejectedCount: number;
+    cache: Cache;
+    _errorRequests: RequestState[];
+    _lastError: RequestState | null;
+    handler: object;
+    constructor(record: MinimalLegacyRecord);
+    destroy(): void;
+    notify(key: keyof this & string): void;
+    updateInvalidErrors(errors: Errors): void;
+    cleanErrorRequests(): void;
+    isSaving: boolean;
+    get isLoading(): boolean;
+    get isLoaded(): boolean;
+    get isSaved(): boolean;
+    get isEmpty(): boolean;
+    get isNew(): boolean;
+    get isDeleted(): boolean;
+    get isValid(): boolean;
+    get isDirty(): boolean;
+    get isError(): boolean;
+    get adapterError(): unknown;
+    get isPreloaded(): boolean;
+    get stateName(): "root.loading" | "root.empty" | "root.deleted.inFlight" | "root.deleted.saved" | "root.deleted.invalid" | "root.deleted.uncommitted" | "root.loaded.created.inFlight" | "root.loaded.created.invalid" | "root.loaded.created.uncommitted" | "root.loaded.updated.inFlight" | "root.loaded.updated.invalid" | "root.loaded.updated.uncommitted" | "root.loaded.saved";
+    get dirtyType(): "" | "deleted" | "created" | "updated";
+}
+//# sourceMappingURL=record-state.d.ts.map