@warp-drive/legacy 5.6.0-alpha.11

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

@@ -0,0 +1,504 @@
+import type { Store } from '@warp-drive/core';
+import type { CollectionEdge, Graph } from '@warp-drive/core/graph/-private';
+import type { RelatedCollection as ManyArray } from '@warp-drive/core/store/-private';
+import type { BaseFinderOptions } from '@warp-drive/core/types';
+import type { StableRecordIdentifier } from '@warp-drive/core/types/identifier';
+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 '../belongs-to.ts';
+import type { MaybeHasManyFields } from '../type-utils.ts';
+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 '@warp-drive/legacy/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 '@warp-drive/legacy/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 '@warp-drive/legacy/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 '@warp-drive/legacy/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 '@warp-drive/legacy/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 '@warp-drive/legacy/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 '@warp-drive/legacy/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 '@warp-drive/legacy/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 declare function isMaybeResource(object: ExistingResourceObject | ResourceIdentifier): object is ExistingResourceObject;
+export {};
+//# sourceMappingURL=has-many.d.ts.map

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

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

package/declarations/model/-private/schema-provider.d.ts

@@ -0,0 +1,63 @@
+import type { Store } from '@warp-drive/core';
+import type { SchemaService } from '@warp-drive/core/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 './model.ts';
+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 declare 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 declare function buildSchema(store: Store): SchemaService;
+export declare function getModelFactory(store: ModelStore, type: string): ModelFactory | null;
+export {};
+//# sourceMappingURL=schema-provider.d.ts.map

package/declarations/model/-private/schema-provider.d.ts.map

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

package/declarations/model/-private/type-utils.d.ts

@@ -0,0 +1,57 @@
+import type { RelatedCollection } from '@warp-drive/core/store/-private';
+import type { TypedRecordInstance } from '@warp-drive/core/types/record';
+import type { Type } from '@warp-drive/core/types/symbols';
+import type { Model } from './model.ts';
+import type { PromiseBelongsTo } from './promise-belongs-to.ts';
+import type { PromiseManyArray } from './promise-many-array.ts';
+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/declarations/model/-private/type-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type-utils.d.ts","sourceRoot":"","sources":["../../../src/model/-private/type-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACzE,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,YAAY,CAAC;AACxC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,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/declarations/model/-private/util.d.ts

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

package/declarations/model/-private/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../src/model/-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/declarations/model/-private.d.ts

@@ -0,0 +1,8 @@
+export { type MinimalLegacyRecord } from './-private/model-methods.ts';
+export type { ModelStore } from './-private/model.ts';
+export { Errors } from './-private/errors.ts';
+export { RelatedCollection as ManyArray } from '@warp-drive/core/store/-private';
+export { PromiseBelongsTo } from './-private/promise-belongs-to.ts';
+export { PromiseManyArray } from './-private/promise-many-array.ts';
+export { lookupLegacySupport, LEGACY_SUPPORT } from './-private/legacy-relationships-support.ts';
+//# sourceMappingURL=-private.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"-private.d.ts","sourceRoot":"","sources":["../../src/model/-private.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAEvE,YAAY,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAE9C,OAAO,EAAE,iBAAiB,IAAI,SAAS,EAAE,MAAM,iCAAiC,CAAC;AACjF,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,kCAAkC,CAAC;AAGpE,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,4CAA4C,CAAC"}