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

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

@@ -1,168 +1,169 @@
-import type { TypeFromInstance } from '@warp-drive/core-types/record';
-import type { NoNull, RelationshipDecorator, RelationshipOptions } from './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 declare 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 declare the abstract type "this" record satisfies for polymorphism.
-
-  ### Examples
-
-  To declare 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 declare 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 declare 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 declare 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 declare 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 declare 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
-  declare 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 declare 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 declare function hasMany(): never;
-export declare function hasMany(type: string): never;
-export declare function hasMany<T>(type: TypeFromInstance<NoNull<T>>, options: RelationshipOptions<T, false>): RelationshipDecorator<T>;
-export declare function hasMany<K extends Promise<unknown>, T extends Awaited<K> = Awaited<K>>(type: TypeFromInstance<NoNull<T>>, options: RelationshipOptions<T, true>): RelationshipDecorator<K>;
-export declare function hasMany(type: string, options: RelationshipOptions<unknown, boolean>): RelationshipDecorator<unknown>;
+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 declare 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 declare the abstract type "this" record satisfies for polymorphism.
+  
+    ### Examples
+  
+    To declare 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 declare 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 declare 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 declare 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 declare 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 declare 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
+    declare 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 declare 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 declare function hasMany(): never;
+  export declare function hasMany(type: string): never;
+  export declare function hasMany<T>(type: TypeFromInstance<NoNull<T>>, options: RelationshipOptions<T, boolean>): RelationshipDecorator<T>;
+  export declare 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

@@ -1 +1 @@
-{"version":3,"file":"has-many.d.ts","sourceRoot":"","sources":["../../src/-private/has-many.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAGtE,OAAO,KAAK,EAAE,MAAM,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAkFvF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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,KAAK,CAAC,GACrC,qBAAqB,CAAC,CAAC,CAAC,CAAC;AAC5B,wBAAgB,OAAO,CAAC,CAAC,SAAS,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,SAAS,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EACnF,IAAI,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EACjC,OAAO,EAAE,mBAAmB,CAAC,CAAC,EAAE,IAAI,CAAC,GACpC,qBAAqB,CAAC,CAAC,CAAC,CAAC;AAC5B,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,mBAAmB,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,qBAAqB,CAAC,OAAO,CAAC,CAAC"}
+{"version":3,"file":"has-many.d.ts","sourceRoot":"","sources":["../../src/-private/has-many.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAGtE,OAAO,KAAK,EAAE,MAAM,EAAE,qBAAqB,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAkFvF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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

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

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

@@ -1,11 +1,13 @@
-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 './model';
-export declare function instantiateRecord(this: Store, identifier: StableRecordIdentifier, createRecordArgs: {
-    [key: string]: unknown;
-}): Model;
-export declare function teardownRecord(record: Model): void;
-export declare function modelFor<T>(type: TypeFromInstance<T>): typeof Model | void;
-export declare function modelFor(type: string): typeof Model | void;
+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 declare function instantiateRecord(this: Store, identifier: StableRecordIdentifier, createRecordArgs: {
+      [key: string]: unknown;
+  }): Model;
+  export declare function teardownRecord(record: Model): void;
+  export declare function modelFor<T>(type: TypeFromInstance<T>): typeof Model | void;
+  export declare function modelFor(type: string): typeof Model | void;
+}
 //# sourceMappingURL=hooks.d.ts.map

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

@@ -1,60 +1,62 @@
-import type { UpgradedMeta } from '@ember-data/graph/-private/-edge-definition';
-import type { CollectionEdge } from '@ember-data/graph/-private/edges/collection';
-import type { ResourceEdge } from '@ember-data/graph/-private/edges/resource';
-import type { Graph } from '@ember-data/graph/-private/graph';
-import type Store from '@ember-data/store';
-import type { Cache } from '@ember-data/store/-types/q/cache';
-import type { JsonApiRelationship } from '@ember-data/store/-types/q/record-data-json-api';
-import type { OpaqueRecordInstance } from '@ember-data/store/-types/q/record-instance';
-import type { BaseFinderOptions } from '@ember-data/store/-types/q/store';
-import type { StableRecordIdentifier } from '@warp-drive/core-types';
-import type { CollectionRelationship } from '@warp-drive/core-types/cache/relationship';
-import type { LocalRelationshipOperation } from '@warp-drive/core-types/graph';
-import type { CollectionResourceRelationship, SingleResourceRelationship } from '@warp-drive/core-types/spec/raw';
-import RelatedCollection from './many-array';
-import type { MinimalLegacyRecord } from './model-methods';
-import type { BelongsToProxyCreateArgs } from './promise-belongs-to';
-import { PromiseBelongsTo } from './promise-belongs-to';
-import type { HasManyProxyCreateArgs } from './promise-many-array';
-import PromiseManyArray from './promise-many-array';
-import BelongsToReference from './references/belongs-to';
-import HasManyReference from './references/has-many';
-export declare const LEGACY_SUPPORT: Map<StableRecordIdentifier | MinimalLegacyRecord, LegacySupport>;
-export declare function lookupLegacySupport(record: MinimalLegacyRecord): LegacySupport;
-export declare class LegacySupport {
-    record: MinimalLegacyRecord;
-    store: Store;
-    graph: Graph;
-    cache: Cache;
-    references: Record<string, BelongsToReference | HasManyReference>;
-    identifier: StableRecordIdentifier;
-    _manyArrayCache: Record<string, RelatedCollection>;
-    _relationshipPromisesCache: Record<string, Promise<RelatedCollection | OpaqueRecordInstance>>;
-    _relationshipProxyCache: Record<string, PromiseManyArray | PromiseBelongsTo | undefined>;
-    _pending: Record<string, Promise<StableRecordIdentifier | null> | undefined>;
-    isDestroying: boolean;
-    isDestroyed: boolean;
-    constructor(record: MinimalLegacyRecord);
-    _syncArray(array: RelatedCollection): 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(identifier: StableRecordIdentifier, field: string): [StableRecordIdentifier[], CollectionRelationship];
-    getManyArray<T>(key: string, definition?: UpgradedMeta): RelatedCollection<T>;
-    fetchAsyncHasMany(key: string, relationship: CollectionEdge, manyArray: RelatedCollection, options?: BaseFinderOptions): Promise<RelatedCollection>;
-    reloadHasMany(key: string, options?: BaseFinderOptions): Promise<unknown> | PromiseManyArray<unknown>;
-    getHasMany(key: string, options?: BaseFinderOptions): PromiseManyArray | RelatedCollection;
-    _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: string | null, name: string): BelongsToReference<unknown, string, unknown> | HasManyReference<unknown, string, unknown>;
-    _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;
+declare module '@ember-data/model/-private/legacy-relationships-support' {
+  import type { UpgradedMeta } from '@ember-data/graph/-private/-edge-definition';
+  import type { CollectionEdge } from '@ember-data/graph/-private/edges/collection';
+  import type { ResourceEdge } from '@ember-data/graph/-private/edges/resource';
+  import type { Graph } from '@ember-data/graph/-private/graph';
+  import type Store from '@ember-data/store';
+  import type { Cache } from '@ember-data/store/-types/q/cache';
+  import type { JsonApiRelationship } from '@ember-data/store/-types/q/record-data-json-api';
+  import type { OpaqueRecordInstance } from '@ember-data/store/-types/q/record-instance';
+  import type { BaseFinderOptions } from '@ember-data/store/-types/q/store';
+  import type { StableRecordIdentifier } from '@warp-drive/core-types';
+  import type { CollectionRelationship } from '@warp-drive/core-types/cache/relationship';
+  import type { LocalRelationshipOperation } from '@warp-drive/core-types/graph';
+  import type { CollectionResourceRelationship, SingleResourceRelationship } from '@warp-drive/core-types/spec/raw';
+  import RelatedCollection 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 declare const LEGACY_SUPPORT: Map<StableRecordIdentifier | MinimalLegacyRecord, LegacySupport>;
+  export declare function lookupLegacySupport(record: MinimalLegacyRecord): LegacySupport;
+  export declare class LegacySupport {
+      record: MinimalLegacyRecord;
+      store: Store;
+      graph: Graph;
+      cache: Cache;
+      references: Record<string, BelongsToReference | HasManyReference>;
+      identifier: StableRecordIdentifier;
+      _manyArrayCache: Record<string, RelatedCollection>;
+      _relationshipPromisesCache: Record<string, Promise<RelatedCollection | OpaqueRecordInstance>>;
+      _relationshipProxyCache: Record<string, PromiseManyArray | PromiseBelongsTo | undefined>;
+      _pending: Record<string, Promise<StableRecordIdentifier | null> | undefined>;
+      isDestroying: boolean;
+      isDestroyed: boolean;
+      constructor(record: MinimalLegacyRecord);
+      _syncArray(array: RelatedCollection): 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(identifier: StableRecordIdentifier, field: string): [StableRecordIdentifier[], CollectionRelationship];
+      getManyArray<T>(key: string, definition?: UpgradedMeta): RelatedCollection<T>;
+      fetchAsyncHasMany(key: string, relationship: CollectionEdge, manyArray: RelatedCollection, options?: BaseFinderOptions): Promise<RelatedCollection>;
+      reloadHasMany(key: string, options?: BaseFinderOptions): Promise<unknown> | PromiseManyArray<unknown>;
+      getHasMany(key: string, options?: BaseFinderOptions): PromiseManyArray | RelatedCollection;
+      _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: string | null, name: string): BelongsToReference<unknown, string, unknown> | HasManyReference<unknown, string, unknown>;
+      _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 declare function areAllInverseRecordsLoaded(store: Store, resource: JsonApiRelationship): boolean;
 }
-export declare function areAllInverseRecordsLoaded(store: Store, resource: JsonApiRelationship): boolean;
 //# sourceMappingURL=legacy-relationships-support.d.ts.map