pinia-orm-edge 1.9.0-28582105.fda0f99 → 1.9.0-28583149.676ad48

package/dist/shared/{pinia-orm.4d8aa1c7.d.mts → pinia-orm.b86abeaa.d.mts}

@@ -1,6 +1,7 @@
 import * as pinia from 'pinia';
 import { PiniaPlugin, Pinia, DefineStoreOptionsBase } from 'pinia';
 import { schema, Schema as Schema$1 } from '@pinia-orm/normalizr';
+import { Model as Model$1, WithKeys as WithKeys$1 } from '@/model/Model';
 import * as __composables from '@/composables';
 
 interface Constructor<T> {
@@ -290,13 +291,20 @@ declare class Interpreter {
     private getSchema;
 }
 
-interface Where {
-    field: WherePrimaryClosure | string;
-    value: WhereSecondaryClosure | any;
+interface Where<T = Model$1> {
+    field: WherePrimaryClosure<T> | NonMethodKeys<T> | string | string[];
+    value: WhereSecondaryClosure<T> | any;
     boolean: 'and' | 'or';
 }
-type WherePrimaryClosure = (model: any) => boolean;
-type WhereSecondaryClosure = (value: any) => boolean;
+type NonMethodKeys<T> = {
+    [P in keyof T]: T[P] extends Function ? never : P;
+}[keyof T];
+type GetElementType<T extends unknown[] | unknown> = T extends (infer U)[] ? U : T;
+type UltimateKeys<M> = {
+    [T in keyof M]: M[T] extends Model$1 | Model$1[] | null ? GetElementType<NonNullable<M[T]>> : never;
+};
+type WherePrimaryClosure<T> = (model: T) => boolean;
+type WhereSecondaryClosure<T> = (value: T) => boolean;
 interface WhereGroup {
     and?: Where[];
     or?: Where[];
@@ -312,10 +320,10 @@ type OrderBy = string | ((model: any) => any);
 type GroupBy = string;
 type GroupByFields = string[];
 type OrderDirection = 'asc' | 'desc';
-interface EagerLoad {
-    [name: string]: EagerLoadConstraint;
-}
-type EagerLoadConstraint = (query: Query) => void;
+type EagerLoad<M extends Model$1> = {
+    [K in keyof M]: EagerLoadConstraint<GetElementType<M[WithKeys$1<M>] extends Model$1 ? M[WithKeys$1<M>] : never>>;
+};
+type EagerLoadConstraint<M extends Model$1> = (query: Query<M>) => void;
 
 declare class Query<M extends Model = Model> {
     /**
@@ -329,7 +337,7 @@ declare class Query<M extends Model = Model> {
     /**
      * The where constraints for the query.
      */
-    protected wheres: Where[];
+    protected wheres: Where<M>[];
     /**
      * The orderings for the query.
      */
@@ -361,7 +369,7 @@ declare class Query<M extends Model = Model> {
     /**
      * The relationships that should be eager loaded.
      */
-    protected eagerLoad: EagerLoad;
+    protected eagerLoad: EagerLoad<M> | {};
     /**
      * The pinia store.
      */
@@ -380,15 +388,15 @@ declare class Query<M extends Model = Model> {
     /**
      * Create a new query instance for the given model.
      */
-    newQuery(model: string): Query;
+    newQuery(model: string): Query<M>;
     /**
      * Create a new query instance with constraints for the given model.
      */
-    newQueryWithConstraints(model: string): Query;
+    newQueryWithConstraints(model: string): Query<M>;
     /**
      * Create a new query instance from the given relation.
      */
-    newQueryForRelation(relation: Relation): Query;
+    newQueryForRelation(relation: Relation): Query<M>;
     /**
      * Create a new interpreter instance.
      */
@@ -412,11 +420,23 @@ declare class Query<M extends Model = Model> {
     /**
      * Add a basic where clause to the query.
      */
-    where(field: WherePrimaryClosure | string, value?: WhereSecondaryClosure | any): this;
+    where<T extends WherePrimaryClosure<M> | NonMethodKeys<M> | string[] | (string & {})>(field: T, value?: T extends string[] ? string | number | (string | number)[] : WhereSecondaryClosure<M[T extends keyof M ? T : never]> | M[T extends keyof M ? T : never] | null): this;
     /**
      * Add a "where in" clause to the query.
      */
-    whereIn(field: string, values: any[] | Set<any>): this;
+    whereIn<T extends NonMethodKeys<M>>(field: T | string & {}, values: any[] | Set<any>): this;
+    /**
+     * Add a "where not in" clause to the query.
+     */
+    whereNotIn(field: string, values: any[] | Set<any>): this;
+    /**
+     * Add a "where not in" clause to the query.
+     */
+    orWhereIn(field: string, values: any[] | Set<any>): this;
+    /**
+     * Add a "where not in" clause to the query.
+     */
+    orWhereNotIn(field: string, values: any[] | Set<any>): this;
     /**
      * Add a where clause on the primary key to the query.
      */
@@ -424,15 +444,23 @@ declare class Query<M extends Model = Model> {
     /**
      * Add an "or where" clause to the query.
      */
-    orWhere(field: WherePrimaryClosure | string, value?: WhereSecondaryClosure | any): this;
+    orWhere<T extends WherePrimaryClosure<M> | NonMethodKeys<M> | string & {}>(field: T, value?: WhereSecondaryClosure<M[T extends keyof M ? T : never]> | M[T extends keyof M ? T : never]): this;
+    /**
+     * Add a "whereNULL" clause to the query.
+     */
+    whereNull(field: string): this;
+    /**
+     * Add a "whereNotNULL" clause to the query.
+     */
+    whereNotNull(field: string): this;
     /**
      * Add a "where has" clause to the query.
      */
-    whereHas(relation: string, callback?: EagerLoadConstraint, operator?: string | number, count?: number): this;
+    whereHas<T extends WithKeys<M>>(relation: T | string & {}, callback?: M[T] extends Model | Model[] | null ? EagerLoadConstraint<GetElementType<NonNullable<M[T]>>> : () => void, operator?: string | number, count?: number): this;
     /**
      * Add an "or where has" clause to the query.
      */
-    orWhereHas(relation: string, callback?: EagerLoadConstraint, operator?: string | number, count?: number): this;
+    orWhereHas<T extends WithKeys<M>>(relation: T | string & {}, callback?: M[T] extends Model | Model[] | null ? EagerLoadConstraint<GetElementType<NonNullable<M[T]>>> : () => void, operator?: string | number, count?: number): this;
     /**
      * Add a "has" clause to the query.
      */
@@ -452,11 +480,11 @@ declare class Query<M extends Model = Model> {
     /**
      * Add a "where doesn't have" clause to the query.
      */
-    whereDoesntHave(relation: string, callback?: EagerLoadConstraint): this;
+    whereDoesntHave<T extends WithKeys<M>>(relation: T | string & {}, callback?: M[T] extends Model | Model[] | null ? EagerLoadConstraint<GetElementType<NonNullable<M[T]>>> : () => void): this;
     /**
      * Add an "or where doesn't have" clause to the query.
      */
-    orWhereDoesntHave(relation: string, callback?: EagerLoadConstraint): this;
+    orWhereDoesntHave<T extends WithKeys<M>>(relation: T | string & {}, callback?: M[T] extends Model | Model[] | null ? EagerLoadConstraint<GetElementType<NonNullable<M[T]>>> : () => void): this;
     /**
      * Add a "group by" clause to the query.
      */
@@ -476,11 +504,11 @@ declare class Query<M extends Model = Model> {
     /**
      * Set the relationships that should be eager loaded.
      */
-    with(name: string, callback?: EagerLoadConstraint): this;
+    with<T extends WithKeys<M>>(name: T | string & {}, callback?: M[T] extends Model | Model[] | null ? EagerLoadConstraint<GetElementType<NonNullable<M[T]>>> : () => void): this;
     /**
      * Set to eager load all top-level relationships. Constraint is set for all relationships.
      */
-    withAll(callback?: EagerLoadConstraint): this;
+    withAll(callback?: EagerLoadConstraint<any>): this;
     /**
      * Set to eager load all relationships recursively.
      */
@@ -492,7 +520,7 @@ declare class Query<M extends Model = Model> {
     /**
      * Get where closure for relations
      */
-    protected getFieldWhereForRelations(relation: string, callback?: EagerLoadConstraint, operator?: string | number, count?: number): WherePrimaryClosure;
+    protected getFieldWhereForRelations<T extends WithKeys<M>>(relation: T | (string & {}), callback?: M[T] extends Model | Model[] | null ? EagerLoadConstraint<GetElementType<NonNullable<M[T]>>> : () => void, operator?: string | number, count?: number): WherePrimaryClosure<M>;
     /**
      * Get all models by id from the store. The difference with the `get` is that this
      * method will not process any query chain.
@@ -528,11 +556,11 @@ declare class Query<M extends Model = Model> {
     /**
      * Get comparator for the where clause.
      */
-    protected getWhereComparator(): (model: any) => boolean;
+    protected getWhereComparator(): (model: M) => boolean;
     /**
      * The function to compare where clause to the given model.
      */
-    protected whereComparator(model: M, where: Where): boolean;
+    protected whereComparator(model: M, where: Where<M>): boolean;
     /**
      * Filter the given collection by the registered order conditions.
      */
@@ -556,7 +584,7 @@ declare class Query<M extends Model = Model> {
     /**
      * Eagerly load the relationship on a set of models.
      */
-    protected eagerLoadRelation(models: Collection<M>, name: string, constraints: EagerLoadConstraint): void;
+    protected eagerLoadRelation<T extends WithKeys<M>>(models: Collection<M>, name: T | string & {}, constraints: EagerLoadConstraint<M>): void;
     /**
      * Get the relation instance for the given relation name.
      */
@@ -682,15 +710,15 @@ declare abstract class Relation extends Attribute {
     /**
      * Set the constraints for an eager loading relation.
      */
-    abstract addEagerConstraints(query: Query, models: Collection): void;
+    abstract addEagerConstraints(query: Query<any>, models: Collection): void;
     /**
      * Match the eagerly loaded results to their parents.
      */
-    abstract match(relation: string, models: Collection, query: Query): void;
+    abstract match(relation: string, models: Collection, query: Query<any>): void;
     /**
      * Get all of the primary keys for an array of models.
      */
-    protected getKeys(models: Collection, key: string): (string | number)[];
+    protected getKeys<M extends Model = Model>(models: Collection<any>, key: string): (string | number)[];
     /**
      * Specify how this model should behave on delete
      */
@@ -698,7 +726,7 @@ declare abstract class Relation extends Attribute {
     /**
      * Run a dictionary map over the items.
      */
-    protected mapToDictionary(models: Collection, callback: (model: Model) => [string, Model]): Dictionary;
+    protected mapToDictionary(models: Collection<any>, callback: (model: Model) => [string, Model]): Dictionary;
     /**
      * Call a function for a current key match
      */
@@ -741,11 +769,11 @@ declare class HasOne extends Relation {
     /**
      * Match the eagerly loaded results to their parents.
      */
-    match(relation: string, models: Collection, query: Query): void;
+    match(relation: string, models: Collection<any>, query: Query<any>): void;
     /**
      * Build model dictionary keyed by the relation's foreign key.
      */
-    protected buildDictionary(results: Collection): Dictionary;
+    protected buildDictionary(results: Collection<any>): Dictionary;
     /**
      * Make a related model.
      */
@@ -788,15 +816,15 @@ declare class BelongsTo extends Relation {
     /**
      * Gather the keys from a collection of related models.
      */
-    protected getEagerModelKeys(models: Collection, foreignKey: string): (string | number)[];
+    protected getEagerModelKeys(models: Collection<any>, foreignKey: string): (string | number)[];
     /**
      * Match the eagerly loaded results to their respective parents.
      */
-    match(relation: string, models: Collection, query: Query): void;
+    match(relation: string, models: Collection<any>, query: Query): void;
     /**
      * Build model dictionary keyed by relation's parent key.
      */
-    protected buildDictionary(models: Collection): Record<string, Model>;
+    protected buildDictionary(models: Collection<any>): Record<string, Model>;
     /**
      * Make a related model.
      */
@@ -851,7 +879,7 @@ declare class BelongsToMany extends Relation {
     /**
      * Match the eagerly loaded results to their parents.
      */
-    match(relation: string, models: Collection, query: Query): void;
+    match(relation: string, models: Collection<any>, query: Query<any>): void;
     /**
      * Set the constraints for the related relation.
      */
@@ -890,11 +918,11 @@ declare class HasMany extends Relation {
     /**
      * Match the eagerly loaded results to their parents.
      */
-    match(relation: string, models: Collection, query: Query): void;
+    match(relation: string, models: Collection<any>, query: Query<any>): void;
     /**
      * Build model dictionary keyed by the relation's foreign key.
      */
-    protected buildDictionary(results: Collection): Dictionary;
+    protected buildDictionary(results: Collection<any>): Dictionary;
     /**
      * Make related models.
      */
@@ -942,15 +970,15 @@ declare class HasManyBy extends Relation {
     /**
      * Gather the keys from a collection of related models.
      */
-    protected getEagerModelKeys(models: Collection): (string | number)[];
+    protected getEagerModelKeys(models: Collection<any>): (string | number)[];
     /**
      * Match the eagerly loaded results to their parents.
      */
-    match(relation: string, models: Collection, query: Query): void;
+    match(relation: string, models: Collection<any>, query: Query<any>): void;
     /**
      * Build model dictionary keyed by the relation's foreign key.
      */
-    protected buildDictionary(models: Collection): Record<string, Model>;
+    protected buildDictionary(models: Collection<any>): Record<string, Model>;
     /**
      * Get all related models from the given dictionary.
      */
@@ -993,15 +1021,15 @@ declare class MorphOne extends Relation {
     /**
      * Set the constraints for an eager load of the relation.
      */
-    addEagerConstraints(query: Query, models: Collection): void;
+    addEagerConstraints(query: Query<any>, models: Collection<any>): void;
     /**
      * Match the eagerly loaded results to their parents.
      */
-    match(relation: string, models: Collection, query: Query): void;
+    match(relation: string, models: Collection<any>, query: Query<any>): void;
     /**
      * Build model dictionary keyed by the relation's foreign key.
      */
-    protected buildDictionary(models: Collection): Record<string, Model>;
+    protected buildDictionary(models: Collection<any>): Record<string, Model>;
     /**
      * Make a related model.
      */
@@ -1075,11 +1103,11 @@ declare class MorphTo extends Relation {
     /**
      * Build model dictionary keyed by the owner key for each entity.
      */
-    protected buildDictionary(query: Query, models: Collection): DictionaryByEntities;
+    protected buildDictionary(query: Query<any>, models: Collection<any>): DictionaryByEntities;
     /**
      * Get the relation's primary keys grouped by its entity.
      */
-    protected getKeysByEntity(models: Collection): Record<string, (string | number)[]>;
+    protected getKeysByEntity(models: Collection<any>): Record<string, (string | number)[]>;
 }
 
 declare class MorphMany extends Relation {
@@ -1114,15 +1142,15 @@ declare class MorphMany extends Relation {
     /**
      * Set the constraints for an eager load of the relation.
      */
-    addEagerConstraints(query: Query, models: Collection): void;
+    addEagerConstraints(query: Query<any>, models: Collection<any>): void;
     /**
      * Match the eagerly loaded results to their parents.
      */
-    match(relation: string, models: Collection, query: Query): void;
+    match(relation: string, models: Collection<any>, query: Query<any>): void;
     /**
      * Build model dictionary keyed by the relation's foreign key.
      */
-    protected buildDictionary(results: Collection): Dictionary;
+    protected buildDictionary(results: Collection<any>): Dictionary;
     /**
      * Make related models.
      */
@@ -1217,11 +1245,11 @@ declare class HasManyThrough extends Relation {
     /**
      * Match the eagerly loaded results to their parents.
      */
-    match(relation: string, models: Collection, query: Query): void;
+    match(relation: string, models: Collection<any>, query: Query<any>): void;
     /**
      * Build model dictionary keyed by the relation's foreign key.
      */
-    protected buildDictionary(throughResults: Collection, results: Collection): Dictionary;
+    protected buildDictionary(throughResults: Collection<any>, results: Collection<any>): Dictionary;
     /**
      * Make related models.
      */
@@ -1280,7 +1308,7 @@ declare class MorphToMany extends Relation {
     /**
      * Match the eagerly loaded results to their parents.
      */
-    match(relation: string, models: Collection, query: Query): void;
+    match(relation: string, models: Collection<any>, query: Query<any>): void;
     /**
      * Set the constraints for the related relation.
      */
@@ -1314,8 +1342,11 @@ interface AfterHook {
 interface InheritanceTypes {
     [key: string]: typeof Model;
 }
+type WithKeys<T> = {
+    [P in keyof T]: T[P] extends (Model | null) | Model[] ? P & string : never;
+}[keyof T];
 declare class Model {
-    [s: keyof ModelFields]: any;
+    pivot?: any;
     _meta: undefined | MetaValues;
     /**
      * The name of the model.
@@ -1733,7 +1764,7 @@ interface ModelConstructor<M extends Model> extends Constructor<M> {
     newRawInstance(): M;
 }
 
-declare function useDataStore<S extends DataStoreState, T extends DataStore = DataStore>(id: string, options: DefineStoreOptionsBase<S, T>, query?: Query): pinia.StoreDefinition<string, S, {}, {
+declare function useDataStore<S extends DataStoreState, T extends DataStore = DataStore>(id: string, options: DefineStoreOptionsBase<S, T>, query?: Query<any>): pinia.StoreDefinition<string, S, {}, {
     save(this: any, records: Elements, triggerQueryAction?: boolean): void;
     insert(this: any, records: Elements, triggerQueryAction?: boolean): void;
     update(this: any, records: Elements, triggerQueryAction?: boolean): void;
@@ -1783,7 +1814,7 @@ declare class Repository<M extends Model = Model> {
     /**
      * The model object to be used for the custom repository.
      */
-    static useModel?: Model;
+    static useModel?: typeof Model;
     /**
      * Global config
      */
@@ -1797,7 +1828,7 @@ declare class Repository<M extends Model = Model> {
     /**
      * Set the model
      */
-    static setModel(model: Model): typeof Repository;
+    static setModel(model: typeof Model): typeof Repository;
     /**
      * Set the global config
      */
@@ -1844,19 +1875,19 @@ declare class Repository<M extends Model = Model> {
     /**
      * Add a basic where clause to the query.
      */
-    where(field: WherePrimaryClosure | string, value?: WhereSecondaryClosure | any): Query<M>;
+    where<T extends WherePrimaryClosure<M> | NonMethodKeys<M> | string & {}>(field: T, value?: T extends string[] ? string | number | (string | number)[] : WhereSecondaryClosure<M[T extends keyof M ? T : never]> | M[T extends keyof M ? T : never]): Query<M>;
     /**
      * Add an "or where" clause to the query.
      */
-    orWhere(field: WherePrimaryClosure | string, value?: WhereSecondaryClosure | any): Query<M>;
+    orWhere<T extends WherePrimaryClosure<M> | NonMethodKeys<M> | string & {}>(field: T, value?: WhereSecondaryClosure<M[T extends keyof M ? T : never]> | M[T extends keyof M ? T : never]): Query<M>;
     /**
      * Add a "where has" clause to the query.
      */
-    whereHas(relation: string, callback?: EagerLoadConstraint, operator?: string | number, count?: number): Query<M>;
+    whereHas<T extends WithKeys<M>>(relation: T | string & {}, callback?: M[T] extends Model | Model[] | null ? EagerLoadConstraint<GetElementType<NonNullable<M[T]>>> : () => void, operator?: string | number, count?: number): Query<M>;
     /**
      * Add an "or where has" clause to the query.
      */
-    orWhereHas(relation: string, callback?: EagerLoadConstraint, operator?: string | number, count?: number): Query<M>;
+    orWhereHas<T extends WithKeys<M>>(relation: T | string & {}, callback?: M[T] extends Model | Model[] | null ? EagerLoadConstraint<GetElementType<NonNullable<M[T]>>> : () => void, operator?: string | number, count?: number): Query<M>;
     /**
      * Add a "has" clause to the query.
      */
@@ -1876,11 +1907,11 @@ declare class Repository<M extends Model = Model> {
     /**
      * Add a "where doesn't have" clause to the query.
      */
-    whereDoesntHave(relation: string, callback?: EagerLoadConstraint): Query<M>;
+    whereDoesntHave<T extends WithKeys<M>>(relation: T | string & {}, callback?: M[T] extends Model | Model[] | null ? EagerLoadConstraint<GetElementType<NonNullable<M[T]>>> : () => void): Query<M>;
     /**
      * Add an "or where doesn't have" clause to the query.
      */
-    orWhereDoesntHave(relation: string, callback?: EagerLoadConstraint): Query<M>;
+    orWhereDoesntHave<T extends WithKeys<M>>(relation: T | string & {}, callback?: M[T] extends Model | Model[] | null ? EagerLoadConstraint<GetElementType<NonNullable<M[T]>>> : () => void): Query<M>;
     /**
      * Make meta field visible
      */
@@ -1912,11 +1943,11 @@ declare class Repository<M extends Model = Model> {
     /**
      * Set the relationships that should be eager loaded.
      */
-    with(name: string, callback?: EagerLoadConstraint): Query<M>;
+    with<T extends WithKeys<M>>(name: string & {} | T, callback?: M[T] extends Model | Model[] | null ? EagerLoadConstraint<GetElementType<NonNullable<M[T]>>> : never): Query<M>;
     /**
      * Set to eager load all top-level relationships. Constraint is set for all relationships.
      */
-    withAll(callback?: EagerLoadConstraint): Query<M>;
+    withAll(callback?: EagerLoadConstraint<M>): Query<M>;
     /**
      * Set to eager load all top-level relationships. Constraint is set for all relationships.
      */
@@ -1929,11 +1960,6 @@ declare class Repository<M extends Model = Model> {
      * Get all models from the store.
      */
     all(): Collection<M>;
-    /**
-     * Find the model with the given id.
-     */
-    find(id: string | number): Item<M>;
-    find(ids: (string | number)[]): Collection<M>;
     /**
      * Retrieves the models from the store by following the given
      * normalized schema.
@@ -1974,4 +2000,4 @@ declare class Repository<M extends Model = Model> {
     flush(): M[];
 }
 
-export { CastAttribute as $, type AfterHook as A, type BeforeHook as B, type Constructor as C, type DataStore as D, type Elements as E, type FilledInstallOptions as F, type GroupedCollection as G, Relation as H, type Item as I, BelongsTo as J, BelongsToMany as K, HasMany as L, Model as M, type NormalizedData as N, HasOne as O, type PiniaOrmPluginContext as P, Query as Q, Repository as R, type Schemas as S, HasManyBy as T, HasManyThrough as U, MorphMany as V, WeakCache as W, MorphTo as X, MorphToMany as Y, MorphOne as Z, type Casts as _, type Element as a, type TypeDefault as a0, Type as a1, Interpreter as a2, type Where as a3, type WherePrimaryClosure as a4, type WhereSecondaryClosure as a5, type WhereGroup as a6, type Order as a7, type Group as a8, type OrderBy as a9, type GroupBy as aa, type GroupByFields as ab, type OrderDirection as ac, type EagerLoad as ad, type EagerLoadConstraint as ae, type PropertyDecorator as af, type TypeOptions as ag, type UidOptions as ah, type Mutator as ai, type NanoidOptions as aj, type Collection as b, type DataStoreState as c, type PiniaOrmPlugin as d, definePiniaOrmPlugin as e, type ModelConfigOptions as f, type CacheConfigOptions as g, type InstallOptions as h, type CreatePiniaOrm as i, createORM as j, Database as k, Schema as l, type ModelFields as m, type ModelSchemas as n, type ModelRegistries as o, plugins as p, type ModelRegistry as q, registerPlugins as r, type PrimaryKey as s, type ModelOptions as t, useDataStore as u, type MetaValues as v, type InheritanceTypes as w, Attribute as x, type Dictionary as y, type deleteModes as z };
+export { type Casts as $, type AfterHook as A, type BeforeHook as B, type Constructor as C, type DataStore as D, type Elements as E, type FilledInstallOptions as F, type GroupedCollection as G, type deleteModes as H, type Item as I, Relation as J, BelongsTo as K, BelongsToMany as L, Model as M, type NormalizedData as N, HasMany as O, type PiniaOrmPluginContext as P, Query as Q, Repository as R, type Schemas as S, HasOne as T, HasManyBy as U, HasManyThrough as V, WeakCache as W, MorphMany as X, MorphTo as Y, MorphToMany as Z, MorphOne as _, type Element as a, CastAttribute as a0, type TypeDefault as a1, Type as a2, Interpreter as a3, type Where as a4, type NonMethodKeys as a5, type GetElementType as a6, type UltimateKeys as a7, type WherePrimaryClosure as a8, type WhereSecondaryClosure as a9, type WhereGroup as aa, type Order as ab, type Group as ac, type OrderBy as ad, type GroupBy as ae, type GroupByFields as af, type OrderDirection as ag, type EagerLoad as ah, type EagerLoadConstraint as ai, type Mutator as aj, type MutatorFunctions as ak, type Mutators as al, type CacheConfig as am, type PropertyDecorator as an, type TypeOptions as ao, type UidOptions as ap, type NanoidOptions as aq, type Collection as b, type DataStoreState as c, type PiniaOrmPlugin as d, definePiniaOrmPlugin as e, type ModelConfigOptions as f, type CacheConfigOptions as g, type InstallOptions as h, type CreatePiniaOrm as i, createORM as j, Database as k, Schema as l, type ModelFields as m, type ModelSchemas as n, type ModelRegistries as o, plugins as p, type ModelRegistry as q, registerPlugins as r, type PrimaryKey as s, type ModelOptions as t, useDataStore as u, type MetaValues as v, type InheritanceTypes as w, type WithKeys as x, Attribute as y, type Dictionary as z };