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

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

@@ -1,101 +1,104 @@
-import type EmberObject from '@ember/object';
-
-import type { Errors } from './errors';
-import type Store from '@ember-data/store';
-
-import type { AttributeSchema, RelationshipSchema, RelationshipsSchema } from '@warp-drive/core-types/schema';
-import type { JsonApiError } from '@ember-data/store/-types/q/record-data-json-api';
-import type HasManyReference from './references/has-many';
-import type BelongsToReference from './references/belongs-to';
-import type { StableRecordIdentifier } from '@warp-drive/core-types';
-import type { LegacySupport } from './legacy-relationships-support';
-import type { Cache } from '@warp-drive/core-types/cache';
-import type RecordState from './record-state';
-
-export type ModelCreateArgs = {
-  _createProps: Record<string, unknown>;
-  // TODO @deprecate consider deprecating accessing record properties during init which the below is necessary for
-  _secretInit: {
-    identifier: StableRecordIdentifier;
-    cache: Cache;
-    store: Store;
-    cb: (record: Model, cache: Cache, identifier: StableRecordIdentifier, store: Store) => void;
+declare module '@ember-data/model/-private/model' {
+  import type EmberObject from '@ember/object';
+  
+  import type { Errors } from '@ember-data/model/-private/errors';
+  import type Store from '@ember-data/store';
+  
+  import type { AttributeSchema, RelationshipSchema, RelationshipsSchema } from '@warp-drive/core-types/schema';
+  import type { JsonApiError } from '@ember-data/store/-types/q/record-data-json-api';
+  import type HasManyReference from '@ember-data/model/-private/references/has-many';
+  import type BelongsToReference from '@ember-data/model/-private/references/belongs-to';
+  import type { StableRecordIdentifier } from '@warp-drive/core-types';
+  import type { LegacySupport } from '@ember-data/model/-private/legacy-relationships-support';
+  import type { Cache } from '@warp-drive/core-types/cache';
+  import type RecordState from '@ember-data/model/-private/record-state';
+  
+  export type ModelCreateArgs = {
+    _createProps: Record<string, unknown>;
+    // TODO @deprecate consider deprecating accessing record properties during init which the below is necessary for
+    _secretInit: {
+      identifier: StableRecordIdentifier;
+      cache: Cache;
+      store: Store;
+      cb: (record: Model, cache: Cache, identifier: StableRecordIdentifier, store: Store) => void;
+    };
   };
-};
-
-class Model extends EmberObject {
-  store: Store;
-  errors: Errors;
-  currentState: RecordState;
-  adapterError?: Error;
-  toString(): string;
-  save(): Promise<this>;
-  hasMany<T extends keyof this & string>(key: T): HasManyReference<this, T>;
-  belongsTo<T extends keyof this & string>(key: T): BelongsToReference<this, T>;
-  eachRelationship<T extends Model, K extends keyof T & string>(
-    callback: (this: T, key: K, meta: RelationshipSchema) => void,
-    binding?: T
-  ): void;
-  eachAttribute<T extends Model, K extends keyof T & string>(
-    callback: (this: T, key: K, meta: AttributeSchema) => void,
-    binding?: T
-  ): void;
-  invalidErrorsChanged(errors: JsonApiError[]): void;
-  rollbackAttributes(): void;
-  changedAttributes(): Record<string, [unknown, unknown]>;
-  id: string;
-  isValid: boolean;
-  isSaving: boolean;
-  isNew: boolean;
-  isEmpty: boolean;
-  isDeleted: boolean;
-  hasDirtyAttributes: boolean;
-  isLoaded: boolean;
-  isLoading: boolean;
-  isReloading: boolean;
-  dirtyType: string;
-  deleteRecord(): void;
-  unloadRecord(): void;
-  serialize(): Record<string, unknown>;
-
-  static modelName: string;
-  static fields: Map<keyof this & string, 'attribute' | 'belongsTo' | 'hasMany'>;
-  static attributes: Map<keyof this & string, AttributeSchema>;
-  static relationshipsByName: Map<keyof this & string, RelationshipSchema>;
-  static eachAttribute<K extends keyof this & string>(
-    callback: (this: ModelSchema<this>, key: K, attribute: AttributeSchema) => void,
-    binding?: T
-  ): void;
-  static eachRelationship<K extends keyof this & string>(
-    callback: (this: ModelSchema<this>, key: K, relationship: RelationshipSchema) => void,
-    binding?: T
-  ): void;
-  static eachTransformedAttribute<K extends keyof this & string>(
-    callback: (this: ModelSchema<this>, key: K, type: string | null) => void,
-    binding?: T
-  ): void;
-
-  static toString(): string;
-  static isModel: true;
-  static relationshipsObject: RelationshipsSchema;
-  static extend(...mixins: unknown[]): typeof Model;
-  static create(createArgs: ModelCreateArgs): Model;
-  static __isMixin?: true;
-  static __mixin?: unknown;
-}
-
-interface Model {
-  constructor: typeof Model;
-}
-
-export { Model };
-
-export type StaticModel = typeof Model;
-
-export const LEGACY_SUPPORT: Map<StableRecordIdentifier | Model, LegacySupport>;
-
-export type ModelFactory = { class: StaticModel };
-export type FactoryCache = Record<string, ModelFactory>;
-// we put this on the store for interop because it's used by modelFor and
-// instantiateRecord as well.
-export type ModelStore = Store & { _modelFactoryCache: FactoryCache };
+  
+  class Model extends EmberObject {
+    store: Store;
+    errors: Errors;
+    currentState: RecordState;
+    adapterError?: Error;
+    toString(): string;
+    save(): Promise<this>;
+    hasMany<T extends keyof this & string>(key: T): HasManyReference<this, T>;
+    belongsTo<T extends keyof this & string>(key: T): BelongsToReference<this, T>;
+    eachRelationship<T extends Model, K extends keyof T & string>(
+      callback: (this: T, key: K, meta: RelationshipSchema) => void,
+      binding?: T
+    ): void;
+    eachAttribute<T extends Model, K extends keyof T & string>(
+      callback: (this: T, key: K, meta: AttributeSchema) => void,
+      binding?: T
+    ): void;
+    invalidErrorsChanged(errors: JsonApiError[]): void;
+    rollbackAttributes(): void;
+    changedAttributes(): Record<string, [unknown, unknown]>;
+    id: string;
+    isValid: boolean;
+    isSaving: boolean;
+    isNew: boolean;
+    isEmpty: boolean;
+    isDeleted: boolean;
+    hasDirtyAttributes: boolean;
+    isLoaded: boolean;
+    isLoading: boolean;
+    isReloading: boolean;
+    dirtyType: string;
+    deleteRecord(): void;
+    unloadRecord(): void;
+    serialize(): Record<string, unknown>;
+  
+    static modelName: string;
+    static fields: Map<keyof this & string, 'attribute' | 'belongsTo' | 'hasMany'>;
+    static attributes: Map<keyof this & string, AttributeSchema>;
+    static relationshipsByName: Map<keyof this & string, RelationshipSchema>;
+    static eachAttribute<K extends keyof this & string>(
+      callback: (this: ModelSchema<this>, key: K, attribute: AttributeSchema) => void,
+      binding?: T
+    ): void;
+    static eachRelationship<K extends keyof this & string>(
+      callback: (this: ModelSchema<this>, key: K, relationship: RelationshipSchema) => void,
+      binding?: T
+    ): void;
+    static eachTransformedAttribute<K extends keyof this & string>(
+      callback: (this: ModelSchema<this>, key: K, type: string | null) => void,
+      binding?: T
+    ): void;
+  
+    static toString(): string;
+    static isModel: true;
+    static relationshipsObject: RelationshipsSchema;
+    static extend(...mixins: unknown[]): typeof Model;
+    static create(createArgs: ModelCreateArgs): Model;
+    static __isMixin?: true;
+    static __mixin?: unknown;
+  }
+  
+  interface Model {
+    constructor: typeof Model;
+  }
+  
+  export { Model };
+  
+  export type StaticModel = typeof Model;
+  
+  export const LEGACY_SUPPORT: Map<StableRecordIdentifier | Model, LegacySupport>;
+  
+  export type ModelFactory = { class: StaticModel };
+  export type FactoryCache = Record<string, ModelFactory>;
+  // we put this on the store for interop because it's used by modelFor and
+  // instantiateRecord as well.
+  export type ModelStore = Store & { _modelFactoryCache: FactoryCache };
+  
+}

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

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

package/unstable-preview-types/-private/notify-changes.d.ts

@@ -1,6 +1,8 @@
-import type Store from '@ember-data/store';
-import type { NotificationType } from '@ember-data/store/-private/managers/notification-manager';
-import type { StableRecordIdentifier } from '@warp-drive/core-types';
-import type { Model } from './model';
-export default function notifyChanges(identifier: StableRecordIdentifier, value: NotificationType, key: string | undefined, record: Model, store: Store): void;
+declare module '@ember-data/model/-private/notify-changes' {
+  import type Store from '@ember-data/store';
+  import type { NotificationType } from '@ember-data/store/-private/managers/notification-manager';
+  import type { StableRecordIdentifier } from '@warp-drive/core-types';
+  import type { Model } from '@ember-data/model/-private/model';
+  export default function notifyChanges(identifier: StableRecordIdentifier, value: NotificationType, key: string | undefined, record: Model, store: Store): void;
+}
 //# sourceMappingURL=notify-changes.d.ts.map

package/unstable-preview-types/-private/promise-belongs-to.d.ts

@@ -1,45 +1,47 @@
-/// <reference types="ember-source/types" />
-/// <reference types="ember-source/types" />
-import type PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
-import type ObjectProxy from '@ember/object/proxy';
-import type Store from '@ember-data/store';
-import type { OpaqueRecordInstance } from '@ember-data/store/-types/q/record-instance';
-import type { TypeFromInstanceOrString } from '@warp-drive/core-types/record';
-import type { LegacySupport } from './legacy-relationships-support';
-export interface BelongsToProxyMeta<T = unknown> {
-    key: string;
-    store: Store;
-    legacySupport: LegacySupport;
-    modelName: TypeFromInstanceOrString<T>;
+declare module '@ember-data/model/-private/promise-belongs-to' {
+  /// <reference types="ember-source/types" />
+  /// <reference types="ember-source/types" />
+  import type PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
+  import type ObjectProxy from '@ember/object/proxy';
+  import type Store from '@ember-data/store';
+  import type { OpaqueRecordInstance } from '@ember-data/store/-types/q/record-instance';
+  import type { TypeFromInstanceOrString } from '@warp-drive/core-types/record';
+  import type { LegacySupport } from '@ember-data/model/-private/legacy-relationships-support';
+  export interface BelongsToProxyMeta<T = unknown> {
+      key: string;
+      store: Store;
+      legacySupport: LegacySupport;
+      modelName: TypeFromInstanceOrString<T>;
+  }
+  export interface BelongsToProxyCreateArgs<T = unknown> {
+      promise: Promise<T | null>;
+      content?: T | null;
+      _belongsToState: BelongsToProxyMeta<T>;
+  }
+  interface PromiseObjectType<T> extends PromiseProxyMixin<T | null>, ObjectProxy<T> {
+      new <PT>(...args: unknown[]): PromiseObjectType<PT>;
+  }
+  declare class PromiseObjectType<T> {
+  }
+  declare const Extended: PromiseObjectType<OpaqueRecordInstance>;
+  /**
+   @module @ember-data/model
+   */
+  /**
+    A PromiseBelongsTo is a PromiseObject that also proxies certain method calls
+    to the underlying belongsTo model.
+    Right now we proxy:
+      * `reload()`
+    @class PromiseBelongsTo
+    @extends PromiseObject
+    @private
+  */
+  declare class PromiseBelongsTo<T = unknown> extends Extended<T> {
+      _belongsToState: BelongsToProxyMeta<T>;
+      get id(): string | null;
+      get meta(): void;
+      reload(options: Record<string, unknown>): Promise<this>;
+  }
+  export { PromiseBelongsTo };
 }
-export interface BelongsToProxyCreateArgs<T = unknown> {
-    promise: Promise<T | null>;
-    content?: T | null;
-    _belongsToState: BelongsToProxyMeta<T>;
-}
-interface PromiseObjectType<T> extends PromiseProxyMixin<T | null>, ObjectProxy<T> {
-    new <PT>(...args: unknown[]): PromiseObjectType<PT>;
-}
-declare class PromiseObjectType<T> {
-}
-declare const Extended: PromiseObjectType<OpaqueRecordInstance>;
-/**
- @module @ember-data/model
- */
-/**
-  A PromiseBelongsTo is a PromiseObject that also proxies certain method calls
-  to the underlying belongsTo model.
-  Right now we proxy:
-    * `reload()`
-  @class PromiseBelongsTo
-  @extends PromiseObject
-  @private
-*/
-declare class PromiseBelongsTo<T = unknown> extends Extended<T> {
-    _belongsToState: BelongsToProxyMeta<T>;
-    get id(): string | null;
-    get meta(): void;
-    reload(options: Record<string, unknown>): Promise<this>;
-}
-export { PromiseBelongsTo };
 //# sourceMappingURL=promise-belongs-to.d.ts.map

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

@@ -1,127 +1,129 @@
-import type { BaseFinderOptions } from '@ember-data/store/-types/q/store';
-import type ManyArray from './many-array';
-export interface HasManyProxyCreateArgs<T = unknown> {
-    promise: Promise<ManyArray<T>>;
-    content?: ManyArray<T>;
-}
-/**
- @module @ember-data/model
- */
-/**
-  This class is returned as the result of accessing an async hasMany relationship
-  on an instance of a Model extending from `@ember-data/model`.
-
-  A PromiseManyArray is an iterable proxy that allows templates to consume related
-  ManyArrays and update once their contents are no longer pending.
-
-  In your JS code you should resolve the promise first.
-
-  ```js
-  const comments = await post.comments;
-  ```
-
-  @class PromiseManyArray
-  @public
-*/
-export default class PromiseManyArray<T = unknown> {
-    promise: Promise<ManyArray<T>> | null;
-    isDestroyed: boolean;
-    content: ManyArray<T> | null;
-    constructor(promise: Promise<ManyArray<T>>, content?: ManyArray<T>);
-    /**
-     * Retrieve the length of the content
-     * @property length
-     * @public
-     */
-    get length(): number;
-    /**
-     * Iterate the proxied content. Called by the glimmer iterator in #each
-     * We do not guarantee that forEach will always be available. This
-     * may eventually be made to use Symbol.Iterator once glimmer supports it.
-     *
-     * @method forEach
-     * @param cb
-     * @return
-     * @private
-     */
-    forEach(cb: (item: T, index: number, array: T[]) => void): void;
-    /**
-     * Reload the relationship
-     * @method reload
-     * @public
-     * @param options
-     * @return
-     */
-    reload(options: Omit<BaseFinderOptions, ''>): this;
-    /**
-     * Whether the loading promise is still pending
-     *
-     * @property {boolean} isPending
-     * @public
-     */
-    isPending: boolean;
-    /**
-     * Whether the loading promise rejected
-     *
-     * @property {boolean} isRejected
-     * @public
-     */
-    isRejected: boolean;
-    /**
-     * Whether the loading promise succeeded
-     *
-     * @property {boolean} isFulfilled
-     * @public
-     */
-    isFulfilled: boolean;
-    /**
-     * Whether the loading promise completed (resolved or rejected)
-     *
-     * @property {boolean} isSettled
-     * @public
-     */
-    isSettled: boolean;
-    /**
-     * chain this promise
-     *
-     * @method then
-     * @public
-     * @param success
-     * @param fail
-     * @return Promise
-     */
-    then(s: Parameters<Promise<ManyArray<T>>['then']>[0], f?: Parameters<Promise<ManyArray<T>>['then']>[1]): Promise<unknown>;
-    /**
-     * catch errors thrown by this promise
-     * @method catch
-     * @public
-     * @param callback
-     * @return Promise
-     */
-    catch(cb: Parameters<Promise<ManyArray<T>>['catch']>[0]): Promise<unknown>;
-    /**
-     * run cleanup after this promise completes
-     *
-     * @method finally
-     * @public
-     * @param callback
-     * @return Promise
-     */
-    finally(cb: Parameters<Promise<ManyArray<T>>['finally']>[0]): Promise<ManyArray<T>>;
-    destroy(): void;
-    /**
-     * Retrieve the links for this relationship
-     * @property links
-     * @public
-     */
-    get links(): import("@warp-drive/core-types/spec/raw").Links | null | undefined;
-    /**
-     * Retrieve the meta for this relationship
-     * @property meta
-     * @public
-     */
-    get meta(): Record<string, unknown> | null | undefined;
-    _update(promise: Promise<ManyArray<T>>, content?: ManyArray<T>): void;
-    static create<T>({ promise, content }: HasManyProxyCreateArgs<T>): PromiseManyArray<T>;
+declare module '@ember-data/model/-private/promise-many-array' {
+  import type { BaseFinderOptions } from '@ember-data/store/-types/q/store';
+  import type ManyArray from '@ember-data/model/-private/many-array';
+  export interface HasManyProxyCreateArgs<T = unknown> {
+      promise: Promise<ManyArray<T>>;
+      content?: ManyArray<T>;
+  }
+  /**
+   @module @ember-data/model
+   */
+  /**
+    This class is returned as the result of accessing an async hasMany relationship
+    on an instance of a Model extending from `@ember-data/model`.
+  
+    A PromiseManyArray is an iterable proxy that allows templates to consume related
+    ManyArrays and update once their contents are no longer pending.
+  
+    In your JS code you should resolve the promise first.
+  
+    ```js
+    const comments = await post.comments;
+    ```
+  
+    @class PromiseManyArray
+    @public
+  */
+  export default class PromiseManyArray<T = unknown> {
+      promise: Promise<ManyArray<T>> | null;
+      isDestroyed: boolean;
+      content: ManyArray<T> | null;
+      constructor(promise: Promise<ManyArray<T>>, content?: ManyArray<T>);
+      /**
+       * Retrieve the length of the content
+       * @property length
+       * @public
+       */
+      get length(): number;
+      /**
+       * Iterate the proxied content. Called by the glimmer iterator in #each
+       * We do not guarantee that forEach will always be available. This
+       * may eventually be made to use Symbol.Iterator once glimmer supports it.
+       *
+       * @method forEach
+       * @param cb
+       * @return
+       * @private
+       */
+      forEach(cb: (item: T, index: number, array: T[]) => void): void;
+      /**
+       * Reload the relationship
+       * @method reload
+       * @public
+       * @param options
+       * @return
+       */
+      reload(options: Omit<BaseFinderOptions, ''>): this;
+      /**
+       * Whether the loading promise is still pending
+       *
+       * @property {boolean} isPending
+       * @public
+       */
+      isPending: boolean;
+      /**
+       * Whether the loading promise rejected
+       *
+       * @property {boolean} isRejected
+       * @public
+       */
+      isRejected: boolean;
+      /**
+       * Whether the loading promise succeeded
+       *
+       * @property {boolean} isFulfilled
+       * @public
+       */
+      isFulfilled: boolean;
+      /**
+       * Whether the loading promise completed (resolved or rejected)
+       *
+       * @property {boolean} isSettled
+       * @public
+       */
+      isSettled: boolean;
+      /**
+       * chain this promise
+       *
+       * @method then
+       * @public
+       * @param success
+       * @param fail
+       * @return Promise
+       */
+      then(s: Parameters<Promise<ManyArray<T>>['then']>[0], f?: Parameters<Promise<ManyArray<T>>['then']>[1]): Promise<unknown>;
+      /**
+       * catch errors thrown by this promise
+       * @method catch
+       * @public
+       * @param callback
+       * @return Promise
+       */
+      catch(cb: Parameters<Promise<ManyArray<T>>['catch']>[0]): Promise<unknown>;
+      /**
+       * run cleanup after this promise completes
+       *
+       * @method finally
+       * @public
+       * @param callback
+       * @return Promise
+       */
+      finally(cb: Parameters<Promise<ManyArray<T>>['finally']>[0]): Promise<ManyArray<T>>;
+      destroy(): void;
+      /**
+       * Retrieve the links for this relationship
+       * @property links
+       * @public
+       */
+      get links(): import("@warp-drive/core-types/spec/raw").Links | null | undefined;
+      /**
+       * Retrieve the meta for this relationship
+       * @property meta
+       * @public
+       */
+      get meta(): Record<string, unknown> | null | undefined;
+      _update(promise: Promise<ManyArray<T>>, content?: ManyArray<T>): void;
+      static create<T>({ promise, content }: HasManyProxyCreateArgs<T>): PromiseManyArray<T>;
+  }
 }
 //# sourceMappingURL=promise-many-array.d.ts.map