@ember-data/model 5.6.0-alpha.5 → 5.6.0-beta.1

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

@@ -1,506 +0,0 @@
-declare module '@ember-data/model/-private/references/has-many' {
-  import type { CollectionEdge, Graph } from '@ember-data/graph/-private';
-  import type Store from '@ember-data/store';
-  import type { RelatedCollection as ManyArray } from '@ember-data/store/-private';
-  import type { BaseFinderOptions } from '@ember-data/store/types';
-  import type { StableRecordIdentifier } from '@warp-drive/core-types';
-  import type { TypeFromInstanceOrString } from '@warp-drive/core-types/record';
-  import type { CollectionResourceDocument, CollectionResourceRelationship, ExistingResourceObject, LinkObject, Meta, PaginationLinks } from '@warp-drive/core-types/spec/json-api-raw';
-  import type { IsUnknown } from '@ember-data/model/-private/belongs-to';
-  import type { MaybeHasManyFields } from '@ember-data/model/-private/type-utils';
-  interface ResourceIdentifier {
-      links?: {
-          related?: string | LinkObject;
-      };
-      meta?: Meta;
-  }
-  type ArrayItemType<T> = T extends (infer U)[] ? U : never;
-  /**
-   A `HasManyReference` is a low-level API that allows access
-   and manipulation of a hasMany relationship.
-  
-   It is especially useful when you're dealing with `async` relationships
-   from `@ember-data/model` as it allows synchronous access to
-   the relationship data if loaded, as well as APIs for loading, reloading
-   the data or accessing available information without triggering a load.
-  
-   It may also be useful when using `sync` relationships with `@ember-data/model`
-   that need to be loaded/reloaded with more precise timing than marking the
-   relationship as `async` and relying on autofetch would have allowed.
-  
-   However,keep in mind that marking a relationship as `async: false` will introduce
-   bugs into your application if the data is not always guaranteed to be available
-   by the time the relationship is accessed. Ergo, it is recommended when using this
-   approach to utilize `links` for unloaded relationship state instead of identifiers.
-  
-   Reference APIs are entangled with the relationship's underlying state,
-   thus any getters or cached properties that utilize these will properly
-   invalidate if the relationship state changes.
-  
-   References are "stable", meaning that multiple calls to retrieve the reference
-    for a given relationship will always return the same HasManyReference.
-  
-   @class HasManyReference
-   @public
-   */
-  export default class HasManyReference<T = unknown, K extends string = IsUnknown<T> extends true ? string : MaybeHasManyFields<T>, Related = K extends keyof T ? ArrayItemType<Awaited<T[K]>> : unknown> {
-      graph: Graph;
-      store: Store;
-      hasManyRelationship: CollectionEdge;
-      /**
-       * The field name on the parent record for this has-many relationship.
-       *
-       * @property key
-       * @type {String}
-       * @public
-       */
-      key: K;
-      /**
-       * The type of resource this relationship will contain.
-       *
-       * @property type
-       * @type {String}
-       * @public
-       */
-      type: TypeFromInstanceOrString<Related>;
-      ___token: object;
-      ___identifier: StableRecordIdentifier<TypeFromInstanceOrString<T>>;
-      ___relatedTokenMap: Map<StableRecordIdentifier, object>;
-      _ref: number;
-      constructor(store: Store, graph: Graph, parentIdentifier: StableRecordIdentifier<TypeFromInstanceOrString<T>>, hasManyRelationship: CollectionEdge, key: K);
-      /**
-       * This method should never be called by user code.
-       *
-       * @internal
-       */
-      destroy(): void;
-      /**
-       * An array of identifiers for the records that this reference refers to.
-       *
-       * @property identifiers
-       * @type {StableRecordIdentifier[]}
-       * @public
-       */
-      get identifiers(): StableRecordIdentifier<TypeFromInstanceOrString<Related>>[];
-      _resource(): CollectionResourceRelationship;
-      /**
-       This returns a string that represents how the reference will be
-       looked up when it is loaded. If the relationship has a link it will
-       use the "link" otherwise it defaults to "id".
-    
-       Example
-    
-       ```js [app/models/post.js]
-       import Model, { hasMany } from '@ember-data/model';
-    
-       export default class PostModel extends Model {
-         @hasMany('comment', { async: true, inverse: null }) comments;
-       }
-       ```
-    
-       ```javascript
-       let post = store.push({
-         data: {
-           type: 'post',
-           id: 1,
-           relationships: {
-             comments: {
-               data: [{ type: 'comment', id: 1 }]
-             }
-           }
-         }
-       });
-    
-       let commentsRef = post.hasMany('comments');
-    
-       // get the identifier of the reference
-       if (commentsRef.remoteType() === "ids") {
-         let ids = commentsRef.ids();
-       } else if (commentsRef.remoteType() === "link") {
-         let link = commentsRef.link();
-       }
-       ```
-    
-       @public
-       @return {String} The name of the remote type. This should either be `link` or `ids`
-       */
-      remoteType(): 'link' | 'ids';
-      /**
-       `ids()` returns an array of the record IDs in this relationship.
-    
-       Example
-    
-       ```js [app/models/post.js]
-       import Model, { hasMany } from '@ember-data/model';
-    
-       export default class PostModel extends Model {
-         @hasMany('comment', { async: true, inverse: null }) comments;
-       }
-       ```
-    
-       ```javascript
-       let post = store.push({
-         data: {
-           type: 'post',
-           id: 1,
-           relationships: {
-             comments: {
-               data: [{ type: 'comment', id: 1 }]
-             }
-           }
-         }
-       });
-    
-       let commentsRef = post.hasMany('comments');
-    
-       commentsRef.ids(); // ['1']
-       ```
-    
-        @public
-       @return {Array} The ids in this has-many relationship
-       */
-      ids(): Array<string | null>;
-      /**
-       The link Ember Data will use to fetch or reload this belongs-to
-       relationship. By default it uses only the "related" resource linkage.
-    
-       Example
-    
-       ```javascript
-       // models/blog.js
-       import Model, { belongsTo } from '@ember-data/model';
-       export default Model.extend({
-          user: belongsTo('user', { async: true, inverse: null })
-        });
-    
-       let blog = store.push({
-          data: {
-            type: 'blog',
-            id: 1,
-            relationships: {
-              user: {
-                links: {
-                  related: '/articles/1/author'
-                }
-              }
-            }
-          }
-        });
-       let userRef = blog.belongsTo('user');
-    
-       // get the identifier of the reference
-       if (userRef.remoteType() === "link") {
-          let link = userRef.link();
-        }
-       ```
-    
-       @public
-       @return {String} The link Ember Data will use to fetch or reload this belongs-to relationship.
-       */
-      link(): string | null;
-      /**
-       * any links that have been received for this relationship
-       *
-       * @public
-       * @return
-       */
-      links(): PaginationLinks | null;
-      /**
-       The meta data for the has-many relationship.
-    
-       Example
-    
-       ```javascript
-       // models/blog.js
-       import Model, { hasMany } from '@ember-data/model';
-       export default Model.extend({
-          users: hasMany('user', { async: true, inverse: null })
-        });
-    
-       let blog = store.push({
-          data: {
-            type: 'blog',
-            id: 1,
-            relationships: {
-              users: {
-                links: {
-                  related: {
-                    href: '/articles/1/authors'
-                  },
-                },
-                meta: {
-                  lastUpdated: 1458014400000
-                }
-              }
-            }
-          }
-        });
-    
-       let usersRef = blog.hasMany('user');
-    
-       usersRef.meta() // { lastUpdated: 1458014400000 }
-       ```
-    
-      @public
-      @return {Object|null} The meta information for the belongs-to relationship.
-      */
-      meta(): Meta | null;
-      /**
-       `push` can be used to update the data in the relationship and EmberData
-       will treat the new data as the canonical value of this relationship on
-       the backend. An empty array will signify the canonical value should be
-       empty.
-    
-       Example model
-    
-       ```js [app/models/post.js]
-       import Model, { hasMany } from '@ember-data/model';
-    
-       export default class PostModel extends Model {
-         @hasMany('comment', { async: true, inverse: null }) comments;
-       }
-       ```
-    
-       Setup some initial state, note we haven't loaded the comments yet:
-    
-       ```js
-       const post = store.push({
-         data: {
-           type: 'post',
-           id: '1',
-           relationships: {
-             comments: {
-               data: [{ type: 'comment', id: '1' }]
-             }
-           }
-         }
-       });
-    
-       const commentsRef = post.hasMany('comments');
-       commentsRef.ids(); // ['1']
-       ```
-    
-       Update the state using `push`, note we can do this even without
-       having loaded these comments yet by providing resource identifiers.
-    
-       Both full resources and resource identifiers are supported.
-    
-       ```js
-       await commentsRef.push({
-        data: [
-         { type: 'comment', id: '2' },
-         { type: 'comment', id: '3' },
-        ]
-       });
-    
-       commentsRef.ids(); // ['2', '3']
-       ```
-    
-       For convenience, you can also pass in an array of resources or resource identifiers
-       without wrapping them in the `data` property:
-    
-       ```js
-       await commentsRef.push([
-         { type: 'comment', id: '4' },
-         { type: 'comment', id: '5' },
-       ]);
-    
-       commentsRef.ids(); // ['4', '5']
-       ```
-    
-       When using the `data` property, you may also include other resource data via included,
-       as well as provide new links and meta to the relationship.
-    
-       ```js
-       await commentsRef.push({
-         links: {
-           related: '/posts/1/comments'
-         },
-         meta: {
-           total: 2
-         },
-         data: [
-           { type: 'comment', id: '4' },
-           { type: 'comment', id: '5' },
-         ],
-         included: [
-           { type: 'other-thing', id: '1', attributes: { foo: 'bar' },
-         ]
-       });
-       ```
-    
-       By default, the store will attempt to fetch any unloaded records before resolving
-       the returned promise with the ManyArray.
-    
-       Alternatively, pass `true` as the second argument to avoid fetching unloaded records
-       and instead the promise will resolve with void without attempting to fetch. This is
-       particularly useful if you want to update the state of the relationship without
-       forcing the load of all of the associated records.
-    
-       @public
-       @param {Array|Object} doc a JSONAPI document object describing the new value of this relationship.
-       @param {Boolean} [skipFetch] if `true`, do not attempt to fetch unloaded records
-       @return {Promise<ManyArray | void>}
-      */
-      push(doc: ExistingResourceObject[] | CollectionResourceDocument, skipFetch?: boolean): Promise<ManyArray<Related> | void>;
-      _isLoaded(): boolean | undefined;
-      /**
-       `value()` synchronously returns the current value of the has-many
-       relationship. Unlike `record.relationshipName`, calling
-       `value()` on a reference does not trigger a fetch if the async
-       relationship is not yet loaded. If the relationship is not loaded
-       it will always return `null`.
-    
-       Example
-    
-       ```js [app/models/post.js]
-       import Model, { hasMany } from '@ember-data/model';
-    
-       export default class PostModel extends Model {
-         @hasMany('comment', { async: true, inverse: null }) comments;
-       }
-       ```
-    
-       ```javascript
-       let post = store.push({
-         data: {
-           type: 'post',
-           id: 1,
-           relationships: {
-             comments: {
-               data: [{ type: 'comment', id: 1 }]
-             }
-           }
-         }
-       });
-    
-       let commentsRef = post.hasMany('comments');
-    
-       post.comments.then(function(comments) {
-         commentsRef.value() === comments
-       })
-       ```
-    
-        @public
-       @return {ManyArray}
-       */
-      value(): ManyArray<Related> | null;
-      /**
-       Loads the relationship if it is not already loaded.  If the
-       relationship is already loaded this method does not trigger a new
-       load. This causes a request to the specified
-       relationship link or reloads all items currently in the relationship.
-    
-       Example
-    
-       ```js [app/models/post.js]
-       import Model, { hasMany } from '@ember-data/model';
-    
-       export default class PostModel extends Model {
-         @hasMany('comment', { async: true, inverse: null }) comments;
-       }
-       ```
-    
-       ```javascript
-       let post = store.push({
-         data: {
-           type: 'post',
-           id: 1,
-           relationships: {
-             comments: {
-               data: [{ type: 'comment', id: 1 }]
-             }
-           }
-         }
-       });
-    
-       let commentsRef = post.hasMany('comments');
-    
-       commentsRef.load().then(function(comments) {
-         //...
-       });
-       ```
-    
-       You may also pass in an options object whose properties will be
-       fed forward. This enables you to pass `adapterOptions` into the
-       request given to the adapter via the reference.
-    
-       Example
-    
-       ```javascript
-       commentsRef.load({ adapterOptions: { isPrivate: true } })
-         .then(function(comments) {
-           //...
-         });
-       ```
-    
-       ```js [app/adapters/comment.js]
-       export default ApplicationAdapter.extend({
-         findMany(store, type, id, snapshots) {
-           // In the adapter you will have access to adapterOptions.
-           let adapterOptions = snapshots[0].adapterOptions;
-         }
-       });
-       ```
-    
-       @public
-       @param {Object} options the options to pass in.
-       @return {Promise} a promise that resolves with the ManyArray in
-       this has-many relationship.
-       */
-      load(options?: BaseFinderOptions): Promise<ManyArray<Related>>;
-      /**
-       Reloads this has-many relationship. This causes a request to the specified
-       relationship link or reloads all items currently in the relationship.
-    
-       Example
-    
-       ```js [app/models/post.js]
-       import Model, { hasMany } from '@ember-data/model';
-    
-       export default class PostModel extends Model {
-         @hasMany('comment', { async: true, inverse: null }) comments;
-       }
-       ```
-    
-       ```javascript
-       let post = store.push({
-         data: {
-           type: 'post',
-           id: 1,
-           relationships: {
-             comments: {
-               data: [{ type: 'comment', id: 1 }]
-             }
-           }
-         }
-       });
-    
-       let commentsRef = post.hasMany('comments');
-    
-       commentsRef.reload().then(function(comments) {
-         //...
-       });
-       ```
-    
-       You may also pass in an options object whose properties will be
-       fed forward. This enables you to pass `adapterOptions` into the
-       request given to the adapter via the reference. A full example
-       can be found in the `load` method.
-    
-       Example
-    
-       ```javascript
-       commentsRef.reload({ adapterOptions: { isPrivate: true } })
-       ```
-    
-        @public
-       @param {Object} options the options to pass in.
-       @return {Promise} a promise that resolves with the ManyArray in this has-many relationship.
-       */
-      reload(options?: BaseFinderOptions): Promise<ManyArray<Related>>;
-  }
-  export function isMaybeResource(object: ExistingResourceObject | ResourceIdentifier): object is ExistingResourceObject;
-  export {};
-}
-//# sourceMappingURL=has-many.d.ts.map

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

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

package/unstable-preview-types/-private/schema-provider.d.ts

@@ -1,65 +0,0 @@
-declare module '@ember-data/model/-private/schema-provider' {
-  import type Store from '@ember-data/store';
-  import type { SchemaService } from '@ember-data/store/types';
-  import type { RecordIdentifier, StableRecordIdentifier } from '@warp-drive/core-types/identifier';
-  import type { ObjectValue } from '@warp-drive/core-types/json/raw';
-  import type { Derivation, HashFn, Transformation } from '@warp-drive/core-types/schema/concepts';
-  import type { ArrayField, DerivedField, GenericField, HashField, LegacyAttributeField, LegacyField, LegacyRelationshipField, ObjectField, ObjectSchema, ResourceSchema } from '@warp-drive/core-types/schema/fields';
-  import type { ModelFactory, ModelStore } from '@ember-data/model/-private/model';
-  type AttributesSchema = ReturnType<Exclude<SchemaService['attributesDefinitionFor'], undefined>>;
-  type RelationshipsSchema = ReturnType<Exclude<SchemaService['relationshipsDefinitionFor'], undefined>>;
-  type InternalSchema = {
-      schema: ResourceSchema;
-      fields: Map<string, LegacyAttributeField | LegacyRelationshipField>;
-      attributes: Record<string, LegacyAttributeField>;
-      relationships: Record<string, LegacyRelationshipField>;
-  };
-  export interface ModelSchemaProvider {
-      attributesDefinitionFor(resource: RecordIdentifier | {
-          type: string;
-      }): AttributesSchema;
-      relationshipsDefinitionFor(resource: RecordIdentifier | {
-          type: string;
-      }): RelationshipsSchema;
-      doesTypeExist(type: string): boolean;
-  }
-  export class ModelSchemaProvider implements SchemaService {
-      store: ModelStore;
-      _schemas: Map<string, InternalSchema>;
-      _typeMisses: Set<string>;
-      constructor(store: ModelStore);
-      resourceTypes(): Readonly<string[]>;
-      hasTrait(type: string): boolean;
-      resourceHasTrait(resource: StableRecordIdentifier | {
-          type: string;
-      }, trait: string): boolean;
-      transformation(field: GenericField | ObjectField | ArrayField | {
-          type: string;
-      }): Transformation;
-      derivation(field: DerivedField | {
-          type: string;
-      }): Derivation;
-      hashFn(field: HashField | {
-          type: string;
-      }): HashFn;
-      resource(resource: StableRecordIdentifier | {
-          type: string;
-      }): ResourceSchema | ObjectSchema;
-      registerResources(schemas: Array<ResourceSchema | ObjectSchema>): void;
-      registerResource(schema: ResourceSchema | ObjectSchema): void;
-      registerTransformation(transform: Transformation): void;
-      registerDerivation<R, T, FM extends ObjectValue | null>(derivation: Derivation<R, T, FM>): void;
-      registerHashFn(hashFn: HashFn): void;
-      _loadModelSchema(type: string): InternalSchema;
-      fields(resource: RecordIdentifier | {
-          type: string;
-      }): Map<string, LegacyField>;
-      hasResource(resource: {
-          type: string;
-      }): boolean;
-  }
-  export function buildSchema(store: Store): SchemaService;
-  export function getModelFactory(store: ModelStore, type: string): ModelFactory | null;
-  export {};
-}
-//# sourceMappingURL=schema-provider.d.ts.map

package/unstable-preview-types/-private/schema-provider.d.ts.map

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

package/unstable-preview-types/-private/type-utils.d.ts

@@ -1,59 +0,0 @@
-declare module '@ember-data/model/-private/type-utils' {
-  import type { RelatedCollection } from '@ember-data/store/-private';
-  import type { TypedRecordInstance } from '@warp-drive/core-types/record';
-  import type { Type } from '@warp-drive/core-types/symbols';
-  import type { Model } from '@ember-data/model/-private/model';
-  import type { PromiseBelongsTo } from '@ember-data/model/-private/promise-belongs-to';
-  import type { PromiseManyArray } from '@ember-data/model/-private/promise-many-array';
-  type ExcludeNull<T> = Exclude<T, null> extends never ? T : Exclude<T, null>;
-  type GetMappedKey<M, V> = {
-      [K in keyof M]-?: ExcludeNull<M[K]> extends V ? K : never;
-  }[keyof M] & string;
-  /**
-   * Get the keys of fields that are maybe defined as `belongsTo` relationships
-   *
-   * "Maybe" because getter/computed fields might be returning values that look
-   * like relationships, but are not.
-   *
-   */
-  export type MaybeBelongsToFields<ThisType> = _TrueKeys<ThisType> extends never ? string : _MaybeBelongsToFields<ThisType>;
-  export type _MaybeBelongsToFields<ThisType> = GetMappedKey<ThisType, PromiseBelongsTo | TypedRecordInstance>;
-  /**
-   * Get the keys of fields that are maybe defined as `hasMany` relationships
-   *
-   * "Maybe" because getter/computed fields might be returning values that look
-   * like relationships, but are not.
-   *
-   */
-  export type MaybeHasManyFields<ThisType> = _TrueKeys<ThisType> extends never ? string : _MaybeHasManyFields<ThisType>;
-  type _MaybeHasManyFields<ThisType> = GetMappedKey<ThisType, RelatedCollection | PromiseManyArray>;
-  /**
-   * Get the keys of fields that are maybe defined as `attr` fields
-   *
-   * "Maybe" because getter/computed fields might be returning values that look
-   * like attributes, but are not.
-   *
-   * This is computed by excluding the keys that are defined as `belongsTo` or `hasMany`
-   * as well as the keys on EmberObject and the Model base class
-   *
-   */
-  export type MaybeAttrFields<ThisType> = Exclude<_TrueKeys<ThisType>, _MaybeBelongsToFields<ThisType> | _MaybeHasManyFields<ThisType>>;
-  /**
-   * Get the keys of fields that are maybe defined as relationships
-   *
-   * "Maybe" because getter/computed fields might be returning values that look
-   * like relationships, but are not.
-   *
-   */
-  export type MaybeRelationshipFields<ThisType> = _TrueKeys<ThisType> extends never ? string : _MaybeBelongsToFields<ThisType> | _MaybeHasManyFields<ThisType>;
-  type _TrueKeys<ThisType> = Exclude<keyof ThisType & string, (keyof Model & string) | typeof Type>;
-  export type isSubClass<ThisType> = _TrueKeys<ThisType> extends never ? false : true;
-  /**
-   * Get the keys of all fields defined on the given subclass of Model
-   * that don't exist on EmberObject or Model.
-   *
-   */
-  export type SubclassKeys<ThisType> = _TrueKeys<ThisType> extends never ? string : _TrueKeys<ThisType>;
-  export {};
-}
-//# sourceMappingURL=type-utils.d.ts.map

package/unstable-preview-types/-private/type-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"type-utils.d.ts","sourceRoot":"","sources":["../../src/-private/type-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,4BAA4B,CAAC;AACpE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACzE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,gCAAgC,CAAC;AAE3D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AACrC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAC7D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAE7D,KAAK,WAAW,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,EAAE,IAAI,CAAC,SAAS,KAAK,GAAG,CAAC,GAAG,OAAO,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;AAC5E,KAAK,YAAY,CAAC,CAAC,EAAE,CAAC,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,GAAG,KAAK;CAAE,CAAC,MAAM,CAAC,CAAC,GAAG,MAAM,CAAC;AAE1G;;;;;;GAMG;AACH,MAAM,MAAM,oBAAoB,CAAC,QAAQ,IACvC,SAAS,CAAC,QAAQ,CAAC,SAAS,KAAK,GAAG,MAAM,GAAG,qBAAqB,CAAC,QAAQ,CAAC,CAAC;AAC/E,MAAM,MAAM,qBAAqB,CAAC,QAAQ,IAAI,YAAY,CAAC,QAAQ,EAAE,gBAAgB,GAAG,mBAAmB,CAAC,CAAC;AAE7G;;;;;;GAMG;AACH,MAAM,MAAM,kBAAkB,CAAC,QAAQ,IAAI,SAAS,CAAC,QAAQ,CAAC,SAAS,KAAK,GAAG,MAAM,GAAG,mBAAmB,CAAC,QAAQ,CAAC,CAAC;AACtH,KAAK,mBAAmB,CAAC,QAAQ,IAAI,YAAY,CAAC,QAAQ,EAAE,iBAAiB,GAAG,gBAAgB,CAAC,CAAC;AAElG;;;;;;;;;GASG;AACH,MAAM,MAAM,eAAe,CAAC,QAAQ,IAAI,OAAO,CAC7C,SAAS,CAAC,QAAQ,CAAC,EACnB,qBAAqB,CAAC,QAAQ,CAAC,GAAG,mBAAmB,CAAC,QAAQ,CAAC,CAChE,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,uBAAuB,CAAC,QAAQ,IAC1C,SAAS,CAAC,QAAQ,CAAC,SAAS,KAAK,GAAG,MAAM,GAAG,qBAAqB,CAAC,QAAQ,CAAC,GAAG,mBAAmB,CAAC,QAAQ,CAAC,CAAC;AAE/G,KAAK,SAAS,CAAC,QAAQ,IAAI,OAAO,CAAC,MAAM,QAAQ,GAAG,MAAM,EAAE,CAAC,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,OAAO,IAAI,CAAC,CAAC;AAClG,MAAM,MAAM,UAAU,CAAC,QAAQ,IAAI,SAAS,CAAC,QAAQ,CAAC,SAAS,KAAK,GAAG,KAAK,GAAG,IAAI,CAAC;AACpF;;;;GAIG;AACH,MAAM,MAAM,YAAY,CAAC,QAAQ,IAAI,SAAS,CAAC,QAAQ,CAAC,SAAS,KAAK,GAAG,MAAM,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC"}

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

@@ -1,8 +0,0 @@
-declare module '@ember-data/model/-private/util' {
-  export type DecoratorPropertyDescriptor = (PropertyDescriptor & {
-      initializer?: () => unknown;
-  }) | undefined;
-  export function isElementDescriptor(args: unknown[]): args is [object, string, DecoratorPropertyDescriptor];
-  export function normalizeModelName(type: string): string;
-}
-//# sourceMappingURL=util.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/-private/util.ts"],"names":[],"mappings":"AAKA,MAAM,MAAM,2BAA2B,GAAG,CAAC,kBAAkB,GAAG;IAAE,WAAW,CAAC,EAAE,MAAM,OAAO,CAAA;CAAE,CAAC,GAAG,SAAS,CAAC;AAE7G,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,2BAA2B,CAAC,CAkB1G;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAsBvD"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"-private.d.ts","sourceRoot":"","sources":["../src/-private.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE3C,OAAO,EAAE,iBAAiB,IAAI,SAAS,EAAE,MAAM,4BAA4B,CAAC;AAC5E,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AAGjE,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,yCAAyC,CAAC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../src/hooks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC/E,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC"}

package/unstable-preview-types/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAE,KAAK,IAAI,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAEpD,YAAY,EAAE,gBAAgB,IAAI,cAAc,EAAE,MAAM,+BAA+B,CAAC;AACxF,YAAY,EAAE,gBAAgB,IAAI,YAAY,EAAE,MAAM,+BAA+B,CAAC;AACtF,YAAY,EAAE,iBAAiB,IAAI,SAAS,EAAE,MAAM,4BAA4B,CAAC;AACjF,YAAY,EAAE,iBAAiB,IAAI,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAC/E,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAC/E,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC"}