@ember-data/model 5.4.0-alpha.32 → 5.4.0-alpha.33

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

@@ -1,195 +1,197 @@
-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;
+declare module '@ember-data/model/-private/many-array' {
+  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 '@ember-data/model/-private/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;
   }
-  ```
-
-  ```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
+  /**
+    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
       */
-    isLoaded: boolean;
-    /**
-      `true` if the relationship is polymorphic, `false` otherwise.
-  
-      @property {Boolean} isPolymorphic
-      @private
+      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
       */
-    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
+      /**
+        Create a child record within the owner
+    
+        @method createRecord
+        @public
+        @param {Object} hash
+        @return {Model} record
       */
-    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
+      createRecord(hash: CreateRecordProperties<T>): T;
+      destroy(): void;
+  }
+  //# sourceMappingURL=many-array.d.ts.map
+}

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

@@ -1,4 +1,6 @@
-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
+declare module '@ember-data/model/-private/model-for-mixin' {
+  import type Store from '@ember-data/store';
+  import { type ModelFactory } from '@ember-data/model/-private/model';
+  export default function modelForMixin(store: Store, normalizedModelName: string): ModelFactory | undefined;
+  //# sourceMappingURL=model-for-mixin.d.ts.map
+}

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

@@ -1,32 +1,34 @@
-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
+declare module '@ember-data/model/-private/model-methods' {
+  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 '@ember-data/model/-private/errors';
+  import type RecordState from '@ember-data/model/-private/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
+}