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

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

@@ -0,0 +1,306 @@
+/// <reference types="ember-source/types" />
+/// <reference types="ember-source/types" />
+import { type NativeArray } from '@ember/array';
+import ArrayProxy from '@ember/array/proxy';
+import type RecordState from './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;
+}
+declare 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
+ */
+declare 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
+      import Controller from '@ember/controller';
+      import { action } from '@ember/object';
+  
+      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 default Errors;
+//# 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,+CAAyE,CAAC;AAE7G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AACH,cAAM,MAAO,SAAQ,6BAA6B,CAAC,eAAe,CAAC;IACzD,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,IACa,OAAO,IAAI,WAAW,CAAC,eAAe,CAAC,CAEnD;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;IACM,KAAK,IAAI,IAAI;IAqBtB;;;;;;;;;;;;;;;;;;;;;;MAsBE;IACF,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;CAGhC;AAED,eAAe,MAAM,CAAC"}

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

@@ -0,0 +1,168 @@
+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>;
+//# 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":"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"}

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

@@ -0,0 +1,2 @@
+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,11 @@
+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;
+//# 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":"AAGA,OAAO,EAAoC,KAAK,KAAK,EAAY,MAAM,4BAA4B,CAAC;AACpG,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 @@
+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;
+}
+export declare function areAllInverseRecordsLoaded(store: Store, resource: JsonApiRelationship): 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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"}