@warp-drive/legacy 5.6.0-alpha.15 → 5.6.0-alpha.18

package/declarations/model/-private/has-many.d.ts

@@ -1,164 +1,167 @@
-import type { TypeFromInstance } from '@warp-drive/core/types/record';
-import type { NoNull, RelationshipDecorator, RelationshipOptions } from './belongs-to.ts';
+import type { TypeFromInstance } from "@warp-drive/core/types/record";
+import type { NoNull, RelationshipDecorator, RelationshipOptions } from "./belongs-to.js";
 /**
-  `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` 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:
+`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.
+- `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
+### Examples
 
-  To declare a **many-to-one** (or one-to-many) relationship, use
-  `belongsTo` in combination with `hasMany`:
+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 '@warp-drive/legacy/model';
+```js
+// app/models/post.js
+import { Model, hasMany } from '@warp-drive/legacy/model';
 
-  export default class Post extends Model {
-    @hasMany('comment', { async: false, inverse: 'post' }) comments;
-  }
+export default class Post extends Model {
+@hasMany('comment', { async: false, inverse: 'post' }) comments;
+}
 
 
-  // app/models/comment.js
-  import { Model, belongsTo } from '@warp-drive/legacy/model';
+// app/models/comment.js
+import { Model, belongsTo } from '@warp-drive/legacy/model';
 
-  export default class Comment extends Model {
-    @belongsTo('post', { async: false, inverse: 'comments' }) post;
-  }
-  ```
+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:
+To declare a **many-to-many** relationship with managed inverses, use `hasMany` for both sides:
 
-  ```js
-  // app/models/post.js
-  import { Model, hasMany } from '@warp-drive/legacy/model';
+```js
+// app/models/post.js
+import { Model, hasMany } from '@warp-drive/legacy/model';
 
-  export default class Post extends Model {
-    @hasMany('tag', { async: true, inverse: 'posts' }) tags;
-  }
+export default class Post extends Model {
+@hasMany('tag', { async: true, inverse: 'posts' }) tags;
+}
 
-  // app/models/tag.js
-  import { Model, hasMany } from '@warp-drive/legacy/model';
+// app/models/tag.js
+import { Model, hasMany } from '@warp-drive/legacy/model';
 
-  export default class Tag extends Model {
-    @hasMany('post', { async: true, inverse: 'tags' }) posts;
-  }
-  ```
+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:
+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 '@warp-drive/legacy/model';
+```js
+// app/models/post.js
+import { Model, hasMany } from '@warp-drive/legacy/model';
 
-  export default class Post extends Model {
-    @hasMany('tag', { async: true, inverse: null }) tags;
-  }
+export default class Post extends Model {
+@hasMany('tag', { async: true, inverse: null }) tags;
+}
 
-  // app/models/tag.js
-  import { Model, hasMany } from '@warp-drive/legacy/model';
+// app/models/tag.js
+import { Model, hasMany } from '@warp-drive/legacy/model';
 
-  export default class Tag extends Model {
-    @hasMany('post', { async: true, inverse: null }) posts;
-  }
-  ```
+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::
+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 '@warp-drive/legacy/model';
+```js
+// app/models/post.js
+import { Model, hasMany } from '@warp-drive/legacy/model';
 
-  export default class Post extends Model {
-    @hasMany('category', { async: true, inverse: null }) categories;
-  }
-  ```
+export default class Post extends Model {
+@hasMany('category', { async: true, inverse: null }) categories;
+}
+```
 
-  #### Sync vs Async Relationships
+#### Sync vs Async Relationships
 
-  EmberData fulfills relationships using resource data available in
-  the cache.
+EmberData fulfills relationships using resource data available in
+the cache.
 
-  Sync relationships point directly to the known related resources.
+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.
+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.
+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.
+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:
+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();
-  ```
+```js
+post.hasMany('comments').reload();
+```
 
-  #### Polymorphic Relationships
+#### Polymorphic Relationships
 
-  To declare a polymorphic relationship, use `hasMany` with the `polymorphic`
-  option set to `true`:
+To declare a polymorphic relationship, use `hasMany` with the `polymorphic`
+option set to `true`:
 
-  ```js
-  // app/models/comment.js
-  import { Model, belongsTo } from '@warp-drive/legacy/model';
+```js
+// app/models/comment.js
+import { Model, belongsTo } from '@warp-drive/legacy/model';
 
-  export default class Comment extends Model {
-    @belongsTo('commentable', { async: false, inverse: 'comments', polymorphic: true }) parent;
-  }
-  ```
+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.
+`'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.
+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.
+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 '@warp-drive/legacy/model';
+```js
+// app/models/post.js
+import { Model, hasMany } from '@warp-drive/legacy/model';
 
-  export default class Post extends Model {
-    @hasMany('comment', { async: false, inverse: 'parent', as: 'commentable' }) comments;
-  }
-  ```
+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.
+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.
+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.
 
-  @public
-  @param {String} type (optional) the name of the related resource
-  @param {Object} options (optional) a hash of options
-  @return {PropertyDescriptor} relationship
+@public
+@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 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/declarations/model/-private/hooks.d.ts

@@ -1,11 +1,10 @@
-import { type Store } from '@warp-drive/core/store/-private';
-import type { StableRecordIdentifier } from '@warp-drive/core/types/identifier';
-import type { TypeFromInstance } from '@warp-drive/core/types/record';
-import type { Model } from './model.ts';
+import { type Store } from "@warp-drive/core/store/-private";
+import type { StableRecordIdentifier } from "@warp-drive/core/types/identifier";
+import type { TypeFromInstance } from "@warp-drive/core/types/record";
+import type { Model } from "./model.js";
 export declare function instantiateRecord(this: Store, identifier: StableRecordIdentifier, createRecordArgs: {
-    [key: string]: unknown;
+	[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/declarations/model/-private/legacy-relationships-support.d.ts

@@ -1,57 +1,56 @@
-import type { Store } from '@warp-drive/core';
-import type { CollectionEdge, Graph, ResourceEdge, UpgradedMeta } from '@warp-drive/core/graph/-private';
-import type { LiveArray } from '@warp-drive/core/store/-private';
-import { RelatedCollection as ManyArray } from '@warp-drive/core/store/-private';
-import type { BaseFinderOptions, 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 type { MinimalLegacyRecord } from './model-methods.ts';
-import type { BelongsToProxyCreateArgs } from './promise-belongs-to.ts';
-import { PromiseBelongsTo } from './promise-belongs-to.ts';
-import type { HasManyProxyCreateArgs } from './promise-many-array.ts';
-import { PromiseManyArray } from './promise-many-array.ts';
-import BelongsToReference from './references/belongs-to.ts';
-import HasManyReference from './references/has-many.ts';
+import type { Store } from "@warp-drive/core";
+import type { CollectionEdge, Graph, ResourceEdge, UpgradedMeta } from "@warp-drive/core/graph/-private";
+import type { LiveArray } from "@warp-drive/core/store/-private";
+import { RelatedCollection as ManyArray } from "@warp-drive/core/store/-private";
+import type { BaseFinderOptions, 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 type { MinimalLegacyRecord } from "./model-methods.js";
+import type { BelongsToProxyCreateArgs } from "./promise-belongs-to.js";
+import { PromiseBelongsTo } from "./promise-belongs-to.js";
+import type { HasManyProxyCreateArgs } from "./promise-many-array.js";
+import { PromiseManyArray } from "./promise-many-array.js";
+import BelongsToReference from "./references/belongs-to.js";
+import HasManyReference from "./references/has-many.js";
 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, 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;
+	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 declare function areAllInverseRecordsLoaded(store: Store, resource: InnerRelationshipDocument): boolean;
-//# sourceMappingURL=legacy-relationships-support.d.ts.map

package/declarations/model/-private/model-for-mixin.d.ts

@@ -1,4 +1,19 @@
-import type { Store } from '@warp-drive/core';
-import { type ModelFactory } from './model';
+import type { Store } from "@warp-drive/core";
+import { type ModelFactory } from "./model.js";
+/*
+In case someone defined a relationship to a mixin, for example:
+```ts
+class CommentModel extends Model {
+@belongsTo('commentable', { polymorphic: true }) owner;
+}
+
+let Commentable = Mixin.create({
+@hasMany('comment') comments;
+});
+```
+we want to look up a Commentable class which has all the necessary
+relationship meta data. Thus, we look up the mixin and create a mock
+Model, so we can access the relationship CPs of the mixin (`comments`)
+in this case
+*/
 export default function modelForMixin(store: Store, normalizedModelName: string): ModelFactory | undefined;
-//# sourceMappingURL=model-for-mixin.d.ts.map

package/declarations/model/-private/model-methods.d.ts

@@ -1,30 +1,36 @@
-import type { Store } from '@warp-drive/core';
-import type { ChangedAttributesHash } from '@warp-drive/core/types/cache';
-import { RecordStore } from '@warp-drive/core/types/symbols';
-import type { Snapshot } from '../../compat/-private.ts';
-import type { Errors } from './errors.ts';
-import type RecordState from './record-state.ts';
-import type BelongsToReference from './references/belongs-to.ts';
-import type HasManyReference from './references/has-many.ts';
-import type { MaybeBelongsToFields, MaybeHasManyFields } from './type-utils.ts';
+import type { Store } from "@warp-drive/core";
+import type { ChangedAttributesHash } from "@warp-drive/core/types/cache";
+import { RecordStore } from "@warp-drive/core/types/symbols";
+import type { Snapshot } from "../../compat/-private.js";
+import type { Errors } from "./errors.js";
+import type RecordState from "./record-state.js";
+import type BelongsToReference from "./references/belongs-to.js";
+import type HasManyReference from "./references/has-many.js";
+import type { MaybeBelongsToFields, MaybeHasManyFields } from "./type-utils.js";
 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<this>;
-    destroyRecord<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<this>;
+	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<this>;
+	destroyRecord<T extends MinimalLegacyRecord>(this: T, options?: Record<string, unknown>): Promise<this>;
 }
 export declare function rollbackAttributes<T extends MinimalLegacyRecord>(this: T): void;
 export declare function unloadRecord<T extends MinimalLegacyRecord>(this: T): void;
-export declare function belongsTo<T extends MinimalLegacyRecord, K extends MaybeBelongsToFields<T>>(this: T, prop: K): BelongsToReference<T, K>;
-export declare function hasMany<T extends MinimalLegacyRecord, K extends MaybeHasManyFields<T>>(this: T, prop: K): HasManyReference<T, K>;
+export declare function belongsTo<
+	T extends MinimalLegacyRecord,
+	K extends MaybeBelongsToFields<T>
+>(this: T, prop: K): BelongsToReference<T, K>;
+export declare function hasMany<
+	T extends MinimalLegacyRecord,
+	K extends MaybeHasManyFields<T>
+>(this: T, prop: K): HasManyReference<T, K>;
 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;
@@ -32,4 +38,3 @@ export declare function deleteRecord<T extends MinimalLegacyRecord>(this: T): vo
 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