@ember-data/model 4.12.8 → 4.13.0-alpha.1

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

@@ -0,0 +1,303 @@
+declare module '@ember-data/model/-private/errors' {
+  import { type NativeArray } from '@ember/array';
+  import ArrayProxy from '@ember/array/proxy';
+  import type RecordState from '@ember-data/model/-private/record-state';
+  type ValidationError = {
+      attribute: string;
+      message: string;
+  };
+  /**
+    @module @ember-data/model
+  */
+  interface ArrayProxyWithCustomOverrides<T> extends Omit<ArrayProxy<T>, 'clear' | 'content'> {
+      content: NativeArray<T>;
+      clear(): void;
+      _has(name: string): boolean;
+  }
+  const ArrayProxyWithCustomOverrides: new <T>() => ArrayProxyWithCustomOverrides<T>;
+  /**
+    Holds validation errors for a given record, organized by attribute names.
+  
+    This class is not directly instantiable.
+  
+    Every `Model` has an `errors` property that is an instance of
+    `Errors`. This can be used to display validation error
+    messages returned from the server when a `record.save()` rejects.
+  
+    For Example, if you had a `User` model that looked like this:
+  
+    ```app/models/user.js
+    import Model, { attr } from '@ember-data/model';
+  
+    export default class UserModel extends Model {
+      @attr('string') username;
+      @attr('string') email;
+    }
+    ```
+    And you attempted to save a record that did not validate on the backend:
+  
+    ```javascript
+    let user = store.createRecord('user', {
+      username: 'tomster',
+      email: 'invalidEmail'
+    });
+    user.save();
+    ```
+  
+    Your backend would be expected to return an error response that described
+    the problem, so that error messages can be generated on the app.
+  
+    API responses will be translated into instances of `Errors` differently,
+    depending on the specific combination of adapter and serializer used. You
+    may want to check the documentation or the source code of the libraries
+    that you are using, to know how they expect errors to be communicated.
+  
+    Errors can be displayed to the user by accessing their property name
+    to get an array of all the error objects for that property. Each
+    error object is a JavaScript object with two keys:
+  
+    - `message` A string containing the error message from the backend
+    - `attribute` The name of the property associated with this error message
+  
+    ```handlebars
+    <label>Username: <Input @value={{@model.username}} /> </label>
+    {{#each @model.errors.username as |error|}}
+      <div class="error">
+        {{error.message}}
+      </div>
+    {{/each}}
+  
+    <label>Email: <Input @value={{@model.email}} /> </label>
+    {{#each @model.errors.email as |error|}}
+      <div class="error">
+        {{error.message}}
+      </div>
+    {{/each}}
+    ```
+  
+    You can also access the special `messages` property on the error
+    object to get an array of all the error strings.
+  
+    ```handlebars
+    {{#each @model.errors.messages as |message|}}
+      <div class="error">
+        {{message}}
+      </div>
+    {{/each}}
+    ```
+  
+    @class Errors
+    @public
+    @extends Ember.ArrayProxy
+   */
+  export class Errors extends ArrayProxyWithCustomOverrides<ValidationError> {
+      __record: {
+          currentState: RecordState;
+      };
+      /**
+        @property errorsByAttributeName
+        @type {MapWithDefault}
+        @private
+      */
+      get errorsByAttributeName(): Map<string, NativeArray<ValidationError>>;
+      /**
+        Returns errors for a given attribute
+    
+        ```javascript
+        let user = store.createRecord('user', {
+          username: 'tomster',
+          email: 'invalidEmail'
+        });
+        user.save().catch(function(){
+          user.errors.errorsFor('email'); // returns:
+          // [{attribute: "email", message: "Doesn't look like a valid email."}]
+        });
+        ```
+    
+        @method errorsFor
+        @public
+        @param {String} attribute
+        @return {Array}
+      */
+      errorsFor(attribute: string): NativeArray<ValidationError>;
+      /**
+        An array containing all of the error messages for this
+        record. This is useful for displaying all errors to the user.
+    
+        ```handlebars
+        {{#each @model.errors.messages as |message|}}
+          <div class="error">
+            {{message}}
+          </div>
+        {{/each}}
+        ```
+    
+        @property messages
+        @public
+        @type {Array}
+      */
+      messages: string[];
+      /**
+        @property content
+        @type {Array}
+        @private
+      */
+      get content(): NativeArray<ValidationError>;
+      /**
+        @method unknownProperty
+        @private
+      */
+      unknownProperty(attribute: string): NativeArray<ValidationError> | undefined;
+      /**
+        Total number of errors.
+    
+        @property length
+        @type {Number}
+        @public
+        @readOnly
+      */
+      /**
+        `true` if we have no errors.
+    
+        @property isEmpty
+        @type {Boolean}
+        @public
+        @readOnly
+      */
+      isEmpty: boolean;
+      /**
+       Manually adds errors to the record. This will trigger the `becameInvalid` event/ lifecycle method on
+        the record and transition the record into an `invalid` state.
+    
+       Example
+       ```javascript
+        let errors = user.errors;
+    
+        // add multiple errors
+        errors.add('password', [
+          'Must be at least 12 characters',
+          'Must contain at least one symbol',
+          'Cannot contain your name'
+        ]);
+    
+        errors.errorsFor('password');
+        // =>
+        // [
+        //   { attribute: 'password', message: 'Must be at least 12 characters' },
+        //   { attribute: 'password', message: 'Must contain at least one symbol' },
+        //   { attribute: 'password', message: 'Cannot contain your name' },
+        // ]
+    
+        // add a single error
+        errors.add('username', 'This field is required');
+    
+        errors.errorsFor('username');
+        // =>
+        // [
+        //   { attribute: 'username', message: 'This field is required' },
+        // ]
+       ```
+        @method add
+        @public
+        @param {string} attribute - the property name of an attribute or relationship
+        @param {string[]|string} messages - an error message or array of error messages for the attribute
+       */
+      add(attribute: string, messages: string[] | string): void;
+      /**
+        @method _findOrCreateMessages
+        @private
+      */
+      _findOrCreateMessages(attribute: string, messages: string | string[]): ValidationError[];
+      /**
+       Manually removes all errors for a given member from the record.
+         This will transition the record into a `valid` state, and
+        triggers the `becameValid` event and lifecycle method.
+    
+       Example:
+    
+       ```javascript
+        let errors = user.errors;
+        errors.add('phone', ['error-1', 'error-2']);
+    
+        errors.errorsFor('phone');
+        // =>
+        // [
+        //   { attribute: 'phone', message: 'error-1' },
+        //   { attribute: 'phone', message: 'error-2' },
+        // ]
+    
+        errors.remove('phone');
+    
+        errors.errorsFor('phone');
+        // => undefined
+       ```
+       @method remove
+        @public
+       @param {string} member - the property name of an attribute or relationship
+       */
+      remove(attribute: string): void;
+      /**
+       Manually clears all errors for the record.
+         This will transition the record into a `valid` state, and
+         will trigger the `becameValid` event and lifecycle method.
+    
+      Example:
+    
+       ```javascript
+       let errors = user.errors;
+       errors.add('username', ['error-a']);
+       errors.add('phone', ['error-1', 'error-2']);
+    
+       errors.errorsFor('username');
+       // =>
+       // [
+       //   { attribute: 'username', message: 'error-a' },
+       // ]
+    
+       errors.errorsFor('phone');
+       // =>
+       // [
+       //   { attribute: 'phone', message: 'error-1' },
+       //   { attribute: 'phone', message: 'error-2' },
+       // ]
+    
+       errors.clear();
+    
+       errors.errorsFor('username');
+       // => undefined
+    
+       errors.errorsFor('phone');
+       // => undefined
+    
+       errors.messages
+       // => []
+       ```
+       @method clear
+       @public
+       */
+      clear(): void;
+      /**
+        Checks if there are error messages for the given attribute.
+    
+        ```app/controllers/user/edit.js
+        export default class UserEditController extends Controller {
+          @action
+          save(user) {
+            if (user.errors.has('email')) {
+              return alert('Please update your email before attempting to save.');
+            }
+            user.save();
+          }
+        }
+        ```
+    
+        @method has
+        @public
+        @param {String} attribute
+        @return {Boolean} true if there some errors on given attribute
+      */
+      has(attribute: string): boolean;
+  }
+  export {};
+}
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/-private/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAK,KAAK,WAAW,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,UAAU,MAAM,oBAAoB,CAAC;AAI5C,OAAO,KAAK,WAAW,MAAM,gBAAgB,CAAC;AAE9C,KAAK,eAAe,GAAG;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AACF;;EAEE;AACF,UAAU,6BAA6B,CAAC,CAAC,CAAE,SAAQ,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAIzF,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC;IACxB,KAAK,IAAI,IAAI,CAAC;IACd,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;CAC7B;AAKD,QAAA,MAAM,6BAA6B,EAA4B,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC,CAAC,CAAC;AAE7G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AACH,qBAAa,MAAO,SAAQ,6BAA6B,CAAC,eAAe,CAAC;IAChE,QAAQ,EAAE;QAAE,YAAY,EAAE,WAAW,CAAA;KAAE,CAAC;IAChD;;;;MAIE;IACF,IACI,qBAAqB,IAAI,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,eAAe,CAAC,CAAC,CAErE;IAED;;;;;;;;;;;;;;;;;;MAkBE;IACF,SAAS,CAAC,SAAS,EAAE,MAAM,GAAG,WAAW,CAAC,eAAe,CAAC;IAmB1D;;;;;;;;;;;;;;;MAeE;IAEM,QAAQ,EAAE,MAAM,EAAE,CAAC;IAE3B;;;;MAIE;IACF,IACI,OAAO,IAAI,WAAW,CAAC,eAAe,CAAC,CAE1C;IAED;;;MAGE;IACF,eAAe,CAAC,SAAS,EAAE,MAAM;IAQjC;;;;;;;MAOE;IAEF;;;;;;;MAOE;IAEM,OAAO,EAAE,OAAO,CAAC;IAEzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACH,GAAG,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,IAAI;IAUzD;;;MAGE;IACF,qBAAqB,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,eAAe,EAAE;IAqBxF;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,MAAM,CAAC,SAAS,EAAE,MAAM;IAwBxB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,KAAK,IAAI,IAAI;IAqBb;;;;;;;;;;;;;;;;;;;MAmBE;IACF,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;CAGhC"}

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

@@ -0,0 +1,169 @@
+declare module '@ember-data/model/-private/has-many' {
+  import type { TypeFromInstance } from '@warp-drive/core-types/record';
+  import type { NoNull, RelationshipDecorator, RelationshipOptions } from '@ember-data/model/-private/belongs-to';
+  /**
+    `hasMany` is used to define Many-To-One and Many-To-Many, and Many-To-None
+    relationships on a [Model](/ember-data/release/classes/Model).
+  
+    `hasMany` takes a configuration hash as a second parameter, currently
+    supported options are:
+  
+    - `async`: (*required*) A boolean value used to whether this is a sync (false) or async (true) relationship.
+    - `inverse`: (*required*)  A string used to identify the inverse property on a related model, or `null`.
+    - `polymorphic`: (*optional*) A boolean value to mark the relationship as polymorphic
+    - `as`: (*optional*) A string used to the abstract type "this" record satisfies for polymorphism.
+  
+    ### Examples
+  
+    To a **many-to-one** (or one-to-many) relationship, use
+    `belongsTo` in combination with `hasMany`:
+  
+    ```js
+    // app/models/post.js
+    import Model, { hasMany } from '@ember-data/model';
+  
+    export default class Post extends Model {
+      @hasMany('comment', { async: false, inverse: 'post' }) comments;
+    }
+  
+  
+    // app/models/comment.js
+    import Model, { belongsTo } from '@ember-data/model';
+  
+    export default class Comment extends Model {
+      @belongsTo('post', { async: false, inverse: 'comments' }) post;
+    }
+    ```
+  
+    To a **many-to-many** relationship with managed inverses, use `hasMany` for both sides:
+  
+    ```js
+    // app/models/post.js
+    import Model, { hasMany } from '@ember-data/model';
+  
+    export default class Post extends Model {
+      @hasMany('tag', { async: true, inverse: 'posts' }) tags;
+    }
+  
+    // app/models/tag.js
+    import Model, { hasMany } from '@ember-data/model';
+  
+    export default class Tag extends Model {
+      @hasMany('post', { async: true, inverse: 'tags' }) posts;
+    }
+    ```
+  
+    To a **many-to-many** relationship without managed inverses, use `hasMany` for both sides
+    with `null` as the inverse:
+  
+    ```js
+    // app/models/post.js
+    import Model, { hasMany } from '@ember-data/model';
+  
+    export default class Post extends Model {
+      @hasMany('tag', { async: true, inverse: null }) tags;
+    }
+  
+    // app/models/tag.js
+    import Model, { hasMany } from '@ember-data/model';
+  
+    export default class Tag extends Model {
+      @hasMany('post', { async: true, inverse: null }) posts;
+    }
+    ```
+  
+    To a many-to-none relationship between two models, use
+    `hasMany` with inverse set to `null` on just one side::
+  
+    ```js
+    // app/models/post.js
+    import Model, { hasMany } from '@ember-data/model';
+  
+    export default class Post extends Model {
+      @hasMany('category', { async: true, inverse: null }) categories;
+    }
+    ```
+  
+    #### Sync vs Async Relationships
+  
+    EmberData fulfills relationships using resource data available in
+    the cache.
+  
+    Sync relationships point directly to the known related resources.
+  
+    When a relationship is declared as async, if any of the known related
+    resources have not been loaded, they will be fetched. The property
+    on the record when accessed provides a promise that resolves once
+    all resources are loaded.
+  
+    Async relationships may take advantage of links. On access, if the related
+    link has not been loaded, or if any known resources are not available in
+    the cache, the fresh state will be fetched using the link.
+  
+    In contrast to async relationship, accessing a sync relationship
+    will error on access when any of the known related resources have
+    not been loaded.
+  
+    If you are using `links` with sync relationships, you have to use
+    the HasMany reference API to fetch or refresh related resources
+    that aren't loaded. For instance, for a `comments` relationship:
+  
+    ```js
+    post.hasMany('comments').reload();
+    ```
+  
+    #### Polymorphic Relationships
+  
+    To a polymorphic relationship, use `hasMany` with the `polymorphic`
+    option set to `true`:
+  
+    ```js
+    // app/models/comment.js
+    import Model, { belongsTo } from '@ember-data/model';
+  
+    export default class Comment extends Model {
+      @belongsTo('commentable', { async: false, inverse: 'comments', polymorphic: true }) parent;
+    }
+    ```
+  
+    `'commentable'` here is referred to as the "abstract type" for the polymorphic
+    relationship.
+  
+    Polymorphic relationships with `inverse: null` will accept any type of record as their content.
+    Polymorphic relationships with `inverse` set to a string will only accept records with a matching
+    inverse relationships declaring itself as satisfying the abstract type.
+  
+    Below, 'as' is used to the that 'post' record satisfies the abstract type 'commentable'
+    for this relationship.
+  
+    ```js
+    // app/models/post.js
+    import Model, { hasMany } from '@ember-data/model';
+  
+    export default class Post extends Model {
+      @hasMany('comment', { async: false, inverse: 'parent', as: 'commentable' }) comments;
+    }
+    ```
+  
+    Note: every Model that declares an inverse to a polymorphic relationship must
+    itself exactly the same. This is because polymorphism is based on structural
+    traits.
+  
+    Polymorphic to polymorphic relationships are supported. Both sides of the relationship
+    must be declared as polymorphic, and the `as` option must be used to the abstract
+    type each record satisfies on both sides.
+  
+    @method hasMany
+    @public
+    @static
+    @for @ember-data/model
+    @param {string} type (optional) the name of the related resource
+    @param {object} options (optional) a hash of options
+    @return {PropertyDescriptor} relationship
+  */
+  export function hasMany(): never;
+  export function hasMany(type: string): never;
+  export function hasMany<T>(type: TypeFromInstance<NoNull<T>>, options: RelationshipOptions<T, boolean>): RelationshipDecorator<T>;
+  export function hasMany(type: string, options: RelationshipOptions<unknown, boolean>): RelationshipDecorator<unknown>;
+}
+//# sourceMappingURL=has-many.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"has-many.d.ts","sourceRoot":"","sources":["../../src/-private/has-many.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAGtE,OAAO,KAAK,EAAE,MAAM,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAiJvF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+JE;AACF,wBAAgB,OAAO,IAAI,KAAK,CAAC;AACjC,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC;AAC7C,wBAAgB,OAAO,CAAC,CAAC,EACvB,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EACjC,OAAO,EAAE,mBAAmB,CAAC,CAAC,EAAE,OAAO,CAAC,GACvC,qBAAqB,CAAC,CAAC,CAAC,CAAC;AAK5B,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,qBAAqB,CAAC,OAAO,CAAC,CAAC"}

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

@@ -0,0 +1,4 @@
+declare module '@ember-data/model/-private/has-many.type-test' {
+  export {};
+}
+//# sourceMappingURL=has-many.type-test.d.ts.map

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

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

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

@@ -0,0 +1,13 @@
+declare module '@ember-data/model/-private/hooks' {
+  import { type Store } from '@ember-data/store/-private';
+  import type { StableRecordIdentifier } from '@warp-drive/core-types';
+  import type { TypeFromInstance } from '@warp-drive/core-types/record';
+  import type { Model } from '@ember-data/model/-private/model';
+  export function instantiateRecord(this: Store, identifier: StableRecordIdentifier, createRecordArgs: {
+      [key: string]: unknown;
+  }): Model;
+  export function teardownRecord(record: Model): void;
+  export function modelFor<T>(type: TypeFromInstance<T>): typeof Model | void;
+  export function modelFor(type: string): typeof Model | void;
+}
+//# sourceMappingURL=hooks.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/-private/hooks.ts"],"names":[],"mappings":"AAEA,OAAO,EAAoC,KAAK,KAAK,EAAY,MAAM,4BAA4B,CAAC;AAEpG,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAErE,OAAO,KAAK,EAAE,gBAAgB,EAA4B,MAAM,+BAA+B,CAAC;AAEhG,OAAO,KAAK,EAAE,KAAK,EAAc,MAAM,SAAS,CAAC;AAMjD,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,KAAK,EACX,UAAU,EAAE,sBAAsB,EAClC,gBAAgB,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,GAC3C,KAAK,CAwBP;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,KAAK,GAAG,IAAI,CAMlD;AAED,wBAAgB,QAAQ,CAAC,CAAC,EAAE,IAAI,EAAE,gBAAgB,CAAC,CAAC,CAAC,GAAG,OAAO,KAAK,GAAG,IAAI,CAAC;AAC5E,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,KAAK,GAAG,IAAI,CAAC"}

package/unstable-preview-types/-private/legacy-relationships-support.d.ts

@@ -0,0 +1,60 @@
+declare module '@ember-data/model/-private/legacy-relationships-support' {
+  import type { CollectionEdge, Graph, ResourceEdge, UpgradedMeta } from '@ember-data/graph/-private';
+  import type Store from '@ember-data/store';
+  import type { LiveArray } from '@ember-data/store/-private';
+  import type { BaseFinderOptions } from '@ember-data/store/types';
+  import type { StableRecordIdentifier } from '@warp-drive/core-types';
+  import type { Cache } from '@warp-drive/core-types/cache';
+  import type { CollectionRelationship } from '@warp-drive/core-types/cache/relationship';
+  import type { LocalRelationshipOperation } from '@warp-drive/core-types/graph';
+  import type { OpaqueRecordInstance, TypeFromInstanceOrString } from '@warp-drive/core-types/record';
+  import type { CollectionResourceRelationship, InnerRelationshipDocument, SingleResourceRelationship } from '@warp-drive/core-types/spec/json-api-raw';
+  import { RelatedCollection as ManyArray } from '@ember-data/model/-private/many-array';
+  import type { MinimalLegacyRecord } from '@ember-data/model/-private/model-methods';
+  import type { BelongsToProxyCreateArgs } from '@ember-data/model/-private/promise-belongs-to';
+  import { PromiseBelongsTo } from '@ember-data/model/-private/promise-belongs-to';
+  import type { HasManyProxyCreateArgs } from '@ember-data/model/-private/promise-many-array';
+  import { PromiseManyArray } from '@ember-data/model/-private/promise-many-array';
+  import BelongsToReference from '@ember-data/model/-private/references/belongs-to';
+  import HasManyReference from '@ember-data/model/-private/references/has-many';
+  export const LEGACY_SUPPORT: Map<StableRecordIdentifier | MinimalLegacyRecord, LegacySupport>;
+  export function lookupLegacySupport(record: MinimalLegacyRecord): LegacySupport;
+  export class LegacySupport {
+      record: MinimalLegacyRecord;
+      store: Store;
+      graph: Graph;
+      cache: Cache;
+      references: Record<string, BelongsToReference | HasManyReference>;
+      identifier: StableRecordIdentifier;
+      _manyArrayCache: Record<string, ManyArray>;
+      _relationshipPromisesCache: Record<string, Promise<ManyArray | OpaqueRecordInstance>>;
+      _relationshipProxyCache: Record<string, PromiseManyArray | PromiseBelongsTo | undefined>;
+      _pending: Record<string, Promise<StableRecordIdentifier | null> | undefined>;
+      isDestroying: boolean;
+      isDestroyed: boolean;
+      constructor(record: MinimalLegacyRecord);
+      _syncArray(array: LiveArray): void;
+      mutate(mutation: LocalRelationshipOperation): void;
+      _findBelongsTo(key: string, resource: SingleResourceRelationship, relationship: ResourceEdge, options?: BaseFinderOptions): Promise<OpaqueRecordInstance | null>;
+      reloadBelongsTo(key: string, options?: BaseFinderOptions): Promise<OpaqueRecordInstance | null>;
+      getBelongsTo(key: string, options?: BaseFinderOptions): PromiseBelongsTo | OpaqueRecordInstance | null;
+      setDirtyBelongsTo(key: string, value: OpaqueRecordInstance | null): void;
+      _getCurrentState<T>(identifier: StableRecordIdentifier, field: string): [StableRecordIdentifier<TypeFromInstanceOrString<T>>[], CollectionRelationship];
+      getManyArray<T>(key: string, definition?: UpgradedMeta): ManyArray<T>;
+      fetchAsyncHasMany(key: string, relationship: CollectionEdge, manyArray: ManyArray, options?: BaseFinderOptions): Promise<ManyArray>;
+      reloadHasMany<T>(key: string, options?: BaseFinderOptions): Promise<ManyArray<T>> | PromiseManyArray<T>;
+      getHasMany(key: string, options?: BaseFinderOptions): PromiseManyArray | ManyArray;
+      _updatePromiseProxyFor(kind: 'hasMany', key: string, args: HasManyProxyCreateArgs): PromiseManyArray;
+      _updatePromiseProxyFor(kind: 'belongsTo', key: string, args: BelongsToProxyCreateArgs): PromiseBelongsTo;
+      _updatePromiseProxyFor(kind: 'belongsTo', key: string, args: {
+          promise: Promise<OpaqueRecordInstance | null>;
+      }): PromiseBelongsTo;
+      referenceFor(kind: 'belongsTo', name: string): BelongsToReference;
+      referenceFor(kind: 'hasMany', name: string): HasManyReference;
+      _findHasManyByJsonApiResource(resource: CollectionResourceRelationship, parentIdentifier: StableRecordIdentifier, relationship: CollectionEdge, options?: BaseFinderOptions): Promise<void | unknown[]> | void;
+      _findBelongsToByJsonApiResource(resource: SingleResourceRelationship, parentIdentifier: StableRecordIdentifier, relationship: ResourceEdge, options?: BaseFinderOptions): Promise<StableRecordIdentifier | null>;
+      destroy(): void;
+  }
+  export function areAllInverseRecordsLoaded(store: Store, resource: InnerRelationshipDocument): boolean;
+}
+//# sourceMappingURL=legacy-relationships-support.d.ts.map

package/unstable-preview-types/-private/legacy-relationships-support.d.ts.map

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