@veap/database 0.0.0-stage → 0.1.0

package/dist/relations/belongs-to-many.d.ts

@@ -0,0 +1,15 @@
+import type { Model } from "../model";
+import type { ModelQueryBuilder } from "../query-builder";
+import { Relation } from "./relation";
+export declare class BelongsToMany<Parent extends Model = any, Related extends Model = any> extends Relation<Parent, Related> {
+    pivotTable: string;
+    foreignPivotKey: string;
+    relatedPivotKey: string;
+    relatedKey: string;
+    constructor(parent: Parent, related: any, pivotTable: string, foreignPivotKey: string, relatedPivotKey: string, localKey?: string, relatedKey?: string);
+    query(): ModelQueryBuilder<Related>;
+    get(): Promise<Related[]>;
+    attach(relatedId: any, extraAttributes?: Record<string, any>): Promise<void>;
+    detach(relatedId?: any): Promise<void>;
+    match(parents: Parent[], relationName: string): Promise<void>;
+}

package/dist/relations/belongs-to-many.js

@@ -0,0 +1,80 @@
+import { getKnex } from "../connection";
+import { Relation } from "./relation";
+export class BelongsToMany extends Relation {
+    pivotTable;
+    foreignPivotKey;
+    relatedPivotKey;
+    relatedKey;
+    constructor(parent, related, pivotTable, foreignPivotKey, relatedPivotKey, localKey = "id", relatedKey = "id") {
+        super(parent, related, foreignPivotKey, localKey);
+        this.pivotTable = pivotTable;
+        this.foreignPivotKey = foreignPivotKey;
+        this.relatedPivotKey = relatedPivotKey;
+        this.relatedKey = relatedKey;
+    }
+    query() {
+        const localKeyValue = this.parent.getAttribute(this.localKey);
+        const relatedTable = this.related.table;
+        return this.related
+            .query()
+            .join(this.pivotTable, `${relatedTable}.${this.relatedKey}`, `${this.pivotTable}.${this.relatedPivotKey}`)
+            .where(`${this.pivotTable}.${this.foreignPivotKey}`, localKeyValue);
+    }
+    async get() {
+        const localKeyValue = this.parent.getAttribute(this.localKey);
+        if (localKeyValue === null || localKeyValue === undefined) {
+            return [];
+        }
+        return await this.query().get();
+    }
+    async attach(relatedId, extraAttributes = {}) {
+        const knex = getKnex();
+        const localKeyValue = this.parent.getAttribute(this.localKey);
+        await knex(this.pivotTable).insert({
+            [this.foreignPivotKey]: localKeyValue,
+            [this.relatedPivotKey]: relatedId,
+            ...extraAttributes,
+        });
+    }
+    async detach(relatedId) {
+        const knex = getKnex();
+        const localKeyValue = this.parent.getAttribute(this.localKey);
+        let q = knex(this.pivotTable).where(this.foreignPivotKey, localKeyValue);
+        if (relatedId !== undefined) {
+            q = q.where(this.relatedPivotKey, relatedId);
+        }
+        await q.delete();
+    }
+    async match(parents, relationName) {
+        const localKeys = Array.from(new Set(parents
+            .map((p) => p.getAttribute(this.localKey))
+            .filter((key) => key !== null && key !== undefined)));
+        if (localKeys.length === 0) {
+            for (const parent of parents) {
+                parent.setRelation(relationName, []);
+            }
+            return;
+        }
+        const knex = getKnex();
+        const relatedTable = this.related.table;
+        // Fetch related records joined with the pivot table so we can associate by foreignPivotKey
+        const rows = await knex(relatedTable)
+            .join(this.pivotTable, `${relatedTable}.${this.relatedKey}`, `${this.pivotTable}.${this.relatedPivotKey}`)
+            .whereIn(`${this.pivotTable}.${this.foreignPivotKey}`, localKeys)
+            .select(`${relatedTable}.*`, `${this.pivotTable}.${this.foreignPivotKey} as _pivot_foreign_key`);
+        const lookup = new Map();
+        for (const row of rows) {
+            const parentFk = row._pivot_foreign_key;
+            delete row._pivot_foreign_key;
+            const model = new this.related(row, false);
+            if (!lookup.has(parentFk)) {
+                lookup.set(parentFk, []);
+            }
+            lookup.get(parentFk).push(model);
+        }
+        for (const parent of parents) {
+            const lk = parent.getAttribute(this.localKey);
+            parent.setRelation(relationName, lookup.get(lk) || []);
+        }
+    }
+}

package/dist/relations/belongs-to.d.ts

@@ -0,0 +1,8 @@
+import type { Model } from "../model";
+import type { ModelQueryBuilder } from "../query-builder";
+import { Relation } from "./relation";
+export declare class BelongsTo<Parent extends Model = any, Related extends Model = any> extends Relation<Parent, Related> {
+    query(): ModelQueryBuilder<Related>;
+    get(): Promise<Related | null>;
+    match(parents: Parent[], relationName: string): Promise<void>;
+}

package/dist/relations/belongs-to.js

@@ -0,0 +1,37 @@
+import { Relation } from "./relation";
+export class BelongsTo extends Relation {
+    query() {
+        const foreignKeyValue = this.parent.getAttribute(this.foreignKey);
+        return this.related.query().where(this.localKey, foreignKeyValue);
+    }
+    async get() {
+        const foreignKeyValue = this.parent.getAttribute(this.foreignKey);
+        if (foreignKeyValue === null || foreignKeyValue === undefined) {
+            return null;
+        }
+        return await this.query().first();
+    }
+    async match(parents, relationName) {
+        const foreignKeys = Array.from(new Set(parents
+            .map((p) => p.getAttribute(this.foreignKey))
+            .filter((key) => key !== null && key !== undefined)));
+        if (foreignKeys.length === 0) {
+            for (const parent of parents) {
+                parent.setRelation(relationName, null);
+            }
+            return;
+        }
+        const results = await this.related
+            .query()
+            .whereIn(this.localKey, foreignKeys)
+            .get();
+        const lookup = new Map();
+        for (const item of results) {
+            lookup.set(item.getAttribute(this.localKey), item);
+        }
+        for (const parent of parents) {
+            const fk = parent.getAttribute(this.foreignKey);
+            parent.setRelation(relationName, lookup.get(fk) || null);
+        }
+    }
+}

package/dist/relations/eager-loader.d.ts

@@ -0,0 +1,5 @@
+import type { Model } from "../model";
+/**
+ * Loads relations onto an array of model instances in bulk queries, avoiding N+1.
+ */
+export declare function eagerLoadRelations<M extends Model>(models: M[], relations: string[]): Promise<void>;

package/dist/relations/eager-loader.js

@@ -0,0 +1,66 @@
+import { DatabaseError } from "../errors";
+/**
+ * Loads relations onto an array of model instances in bulk queries, avoiding N+1.
+ */
+export async function eagerLoadRelations(models, relations) {
+    if (models.length === 0 || relations.length === 0) {
+        return;
+    }
+    // Parse nested relations, e.g. "posts.comments" -> { posts: ["comments"] }
+    const tree = {};
+    for (const rel of relations) {
+        const parts = rel.split(".");
+        const head = parts[0];
+        const tail = parts.slice(1).join(".");
+        if (!tree[head]) {
+            tree[head] = [];
+        }
+        if (tail) {
+            tree[head].push(tail);
+        }
+    }
+    const sample = models[0];
+    for (const [relationName, nestedRels] of Object.entries(tree)) {
+        // Resolve relation instance from model (handling cases where loaded relation data shadows the method)
+        let relationInstance = null;
+        if (typeof sample.getRelationDefinition === "function") {
+            relationInstance = sample.getRelationDefinition(relationName);
+        }
+        if (!relationInstance) {
+            if (typeof sample[relationName] === "function") {
+                relationInstance = sample[relationName]();
+            }
+            else {
+                let proto = Object.getPrototypeOf(sample);
+                while (proto && proto !== Object.prototype) {
+                    const desc = Object.getOwnPropertyDescriptor(proto, relationName);
+                    if (desc && typeof desc.value === "function") {
+                        relationInstance = desc.value.call(sample);
+                        break;
+                    }
+                    proto = Object.getPrototypeOf(proto);
+                }
+            }
+        }
+        if (!relationInstance) {
+            throw DatabaseError.Internal(`[veap:ORM] Relation "${relationName}" is not defined on model ${sample.constructor.name}.`);
+        }
+        await relationInstance.match(models, relationName);
+        // If there are nested relations, recursively eager load them on the children
+        if (nestedRels.length > 0) {
+            const allChildren = [];
+            for (const parent of models) {
+                const childOrChildren = parent.getRelation(relationName);
+                if (Array.isArray(childOrChildren)) {
+                    allChildren.push(...childOrChildren);
+                }
+                else if (childOrChildren) {
+                    allChildren.push(childOrChildren);
+                }
+            }
+            if (allChildren.length > 0) {
+                await eagerLoadRelations(allChildren, nestedRels);
+            }
+        }
+    }
+}

package/dist/relations/has-many.d.ts

@@ -0,0 +1,9 @@
+import type { Model } from "../model";
+import type { ModelQueryBuilder } from "../query-builder";
+import { Relation } from "./relation";
+export declare class HasMany<Parent extends Model = any, Related extends Model = any> extends Relation<Parent, Related> {
+    query(): ModelQueryBuilder<Related>;
+    get(): Promise<Related[]>;
+    create(attributes?: Record<string, any>): Promise<Related>;
+    match(parents: Parent[], relationName: string): Promise<void>;
+}

package/dist/relations/has-many.js

@@ -0,0 +1,48 @@
+import { Relation } from "./relation";
+export class HasMany extends Relation {
+    query() {
+        const localKeyValue = this.parent.getAttribute(this.localKey);
+        return this.related.query().where(this.foreignKey, localKeyValue);
+    }
+    async get() {
+        const localKeyValue = this.parent.getAttribute(this.localKey);
+        if (localKeyValue === null || localKeyValue === undefined) {
+            return [];
+        }
+        return await this.query().get();
+    }
+    async create(attributes = {}) {
+        const localKeyValue = this.parent.getAttribute(this.localKey);
+        return await this.related.create({
+            ...attributes,
+            [this.foreignKey]: localKeyValue,
+        });
+    }
+    async match(parents, relationName) {
+        const localKeys = Array.from(new Set(parents
+            .map((p) => p.getAttribute(this.localKey))
+            .filter((key) => key !== null && key !== undefined)));
+        if (localKeys.length === 0) {
+            for (const parent of parents) {
+                parent.setRelation(relationName, []);
+            }
+            return;
+        }
+        const results = await this.related
+            .query()
+            .whereIn(this.foreignKey, localKeys)
+            .get();
+        const lookup = new Map();
+        for (const item of results) {
+            const fk = item.getAttribute(this.foreignKey);
+            if (!lookup.has(fk)) {
+                lookup.set(fk, []);
+            }
+            lookup.get(fk).push(item);
+        }
+        for (const parent of parents) {
+            const lk = parent.getAttribute(this.localKey);
+            parent.setRelation(relationName, lookup.get(lk) || []);
+        }
+    }
+}

package/dist/relations/has-one.d.ts

@@ -0,0 +1,8 @@
+import type { Model } from "../model";
+import type { ModelQueryBuilder } from "../query-builder";
+import { Relation } from "./relation";
+export declare class HasOne<Parent extends Model = any, Related extends Model = any> extends Relation<Parent, Related> {
+    query(): ModelQueryBuilder<Related>;
+    get(): Promise<Related | null>;
+    match(parents: Parent[], relationName: string): Promise<void>;
+}

package/dist/relations/has-one.js

@@ -0,0 +1,37 @@
+import { Relation } from "./relation";
+export class HasOne extends Relation {
+    query() {
+        const localKeyValue = this.parent.getAttribute(this.localKey);
+        return this.related.query().where(this.foreignKey, localKeyValue);
+    }
+    async get() {
+        const localKeyValue = this.parent.getAttribute(this.localKey);
+        if (localKeyValue === null || localKeyValue === undefined) {
+            return null;
+        }
+        return await this.query().first();
+    }
+    async match(parents, relationName) {
+        const localKeys = Array.from(new Set(parents
+            .map((p) => p.getAttribute(this.localKey))
+            .filter((key) => key !== null && key !== undefined)));
+        if (localKeys.length === 0) {
+            for (const parent of parents) {
+                parent.setRelation(relationName, null);
+            }
+            return;
+        }
+        const results = await this.related
+            .query()
+            .whereIn(this.foreignKey, localKeys)
+            .get();
+        const lookup = new Map();
+        for (const item of results) {
+            lookup.set(item.getAttribute(this.foreignKey), item);
+        }
+        for (const parent of parents) {
+            const lk = parent.getAttribute(this.localKey);
+            parent.setRelation(relationName, lookup.get(lk) || null);
+        }
+    }
+}

package/dist/relations/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./belongs-to";
+export * from "./belongs-to-many";
+export * from "./eager-loader";
+export * from "./has-many";
+export * from "./has-one";
+export * from "./morph-many";
+export * from "./morph-map";
+export * from "./morph-one";
+export * from "./morph-to";
+export * from "./morph-to-many";
+export * from "./relation";

package/dist/relations/index.js

@@ -0,0 +1,11 @@
+export * from "./belongs-to";
+export * from "./belongs-to-many";
+export * from "./eager-loader";
+export * from "./has-many";
+export * from "./has-one";
+export * from "./morph-many";
+export * from "./morph-map";
+export * from "./morph-one";
+export * from "./morph-to";
+export * from "./morph-to-many";
+export * from "./relation";

package/dist/relations/morph-many.d.ts

@@ -0,0 +1,14 @@
+import type { Model } from "../model";
+import type { ModelQueryBuilder } from "../query-builder";
+import { Relation } from "./relation";
+export declare class MorphMany<Parent extends Model = any, Related extends Model = any> extends Relation<Parent, Related> {
+    morphName: string;
+    typeColumn: string;
+    idColumn: string;
+    morphType: string;
+    constructor(parent: Parent, related: any, morphName: string, typeColumn: string, idColumn: string, localKey?: string);
+    query(): ModelQueryBuilder<Related>;
+    get(): Promise<Related[]>;
+    create(attributes?: Record<string, any>): Promise<Related>;
+    match(parents: Parent[], relationName: string): Promise<void>;
+}

package/dist/relations/morph-many.js

@@ -0,0 +1,65 @@
+import { MorphMap } from "./morph-map";
+import { Relation } from "./relation";
+export class MorphMany extends Relation {
+    morphName;
+    typeColumn;
+    idColumn;
+    morphType;
+    constructor(parent, related, morphName, typeColumn, idColumn, localKey = parent.constructor.primaryKey || "id") {
+        super(parent, related, idColumn, localKey);
+        this.morphName = morphName;
+        this.typeColumn = typeColumn;
+        this.idColumn = idColumn;
+        this.morphType = MorphMap.getMorphAlias(parent);
+    }
+    query() {
+        const localKeyValue = this.parent.getAttribute(this.localKey);
+        return this.related
+            .query()
+            .where(this.typeColumn, this.morphType)
+            .where(this.idColumn, localKeyValue);
+    }
+    async get() {
+        const localKeyValue = this.parent.getAttribute(this.localKey);
+        if (localKeyValue === null || localKeyValue === undefined) {
+            return [];
+        }
+        return await this.query().get();
+    }
+    async create(attributes = {}) {
+        const localKeyValue = this.parent.getAttribute(this.localKey);
+        return await this.related.create({
+            ...attributes,
+            [this.typeColumn]: this.morphType,
+            [this.idColumn]: localKeyValue,
+        });
+    }
+    async match(parents, relationName) {
+        const localKeys = Array.from(new Set(parents
+            .map((p) => p.getAttribute(this.localKey))
+            .filter((key) => key !== null && key !== undefined)));
+        if (localKeys.length === 0) {
+            for (const parent of parents) {
+                parent.setRelation(relationName, []);
+            }
+            return;
+        }
+        const results = await this.related
+            .query()
+            .where(this.typeColumn, this.morphType)
+            .whereIn(this.idColumn, localKeys)
+            .get();
+        const lookup = new Map();
+        for (const item of results) {
+            const fk = item.getAttribute(this.idColumn);
+            if (!lookup.has(fk)) {
+                lookup.set(fk, []);
+            }
+            lookup.get(fk).push(item);
+        }
+        for (const parent of parents) {
+            const lk = parent.getAttribute(this.localKey);
+            parent.setRelation(relationName, lookup.get(lk) || []);
+        }
+    }
+}

package/dist/relations/morph-map.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Registry storing polymorphic type aliases mapped to Model constructors and vice-versa.
+ */
+export declare class MorphMap {
+    private static get aliasToModel();
+    private static get modelToAlias();
+    /**
+     * Registers a mapping of aliases to Model constructors.
+     *
+     * Example:
+     * MorphMap.register({
+     *   post: BlogPost,
+     *   user: User,
+     *   comment: BlogComment,
+     * });
+     */
+    static register(map: Record<string, any>): void;
+    /**
+     * Gets the Model constructor registered for a given morph alias.
+     * If not registered in morphMap, attempts to return the input if it's already a class.
+     */
+    static getModel(aliasOrName: string): any;
+    /**
+     * Resolves the polymorphic string type for a model class or instance.
+     * Returns the registered morph alias if exists, otherwise falls back to model table name or class name.
+     */
+    static getMorphAlias(modelClassOrInstance: any): string;
+    /**
+     * Clears the morph map registry (mainly used for testing).
+     */
+    static clear(): void;
+}

package/dist/relations/morph-map.js

@@ -0,0 +1,73 @@
+const globalForMorph = globalThis;
+/**
+ * Registry storing polymorphic type aliases mapped to Model constructors and vice-versa.
+ */
+export class MorphMap {
+    static get aliasToModel() {
+        if (!globalForMorph.__VEAP_MORPH_ALIAS_TO_MODEL__) {
+            globalForMorph.__VEAP_MORPH_ALIAS_TO_MODEL__ = new Map();
+        }
+        return globalForMorph.__VEAP_MORPH_ALIAS_TO_MODEL__;
+    }
+    static get modelToAlias() {
+        if (!globalForMorph.__VEAP_MORPH_MODEL_TO_ALIAS__) {
+            globalForMorph.__VEAP_MORPH_MODEL_TO_ALIAS__ = new Map();
+        }
+        return globalForMorph.__VEAP_MORPH_MODEL_TO_ALIAS__;
+    }
+    /**
+     * Registers a mapping of aliases to Model constructors.
+     *
+     * Example:
+     * MorphMap.register({
+     *   post: BlogPost,
+     *   user: User,
+     *   comment: BlogComment,
+     * });
+     */
+    static register(map) {
+        for (const [alias, modelClass] of Object.entries(map)) {
+            this.aliasToModel.set(alias, modelClass);
+            if (!this.modelToAlias.has(modelClass)) {
+                this.modelToAlias.set(modelClass, alias);
+            }
+        }
+    }
+    /**
+     * Gets the Model constructor registered for a given morph alias.
+     * If not registered in morphMap, attempts to return the input if it's already a class.
+     */
+    static getModel(aliasOrName) {
+        return this.aliasToModel.get(aliasOrName) || null;
+    }
+    /**
+     * Resolves the polymorphic string type for a model class or instance.
+     * Returns the registered morph alias if exists, otherwise falls back to model table name or class name.
+     */
+    static getMorphAlias(modelClassOrInstance) {
+        const ctor = typeof modelClassOrInstance === "function"
+            ? modelClassOrInstance
+            : modelClassOrInstance?.constructor;
+        if (ctor && this.modelToAlias.has(ctor)) {
+            return this.modelToAlias.get(ctor);
+        }
+        if (ctor?.morphAlias) {
+            this.register({ [ctor.morphAlias]: ctor });
+            return ctor.morphAlias;
+        }
+        if (ctor?.table) {
+            return ctor.table;
+        }
+        if (ctor?.name) {
+            return ctor.name;
+        }
+        return String(modelClassOrInstance);
+    }
+    /**
+     * Clears the morph map registry (mainly used for testing).
+     */
+    static clear() {
+        this.aliasToModel.clear();
+        this.modelToAlias.clear();
+    }
+}

package/dist/relations/morph-one.d.ts

@@ -0,0 +1,14 @@
+import type { Model } from "../model";
+import type { ModelQueryBuilder } from "../query-builder";
+import { Relation } from "./relation";
+export declare class MorphOne<Parent extends Model = any, Related extends Model = any> extends Relation<Parent, Related> {
+    morphName: string;
+    typeColumn: string;
+    idColumn: string;
+    morphType: string;
+    constructor(parent: Parent, related: any, morphName: string, typeColumn: string, idColumn: string, localKey?: string);
+    query(): ModelQueryBuilder<Related>;
+    get(): Promise<Related | null>;
+    create(attributes?: Record<string, any>): Promise<Related>;
+    match(parents: Parent[], relationName: string): Promise<void>;
+}

package/dist/relations/morph-one.js

@@ -0,0 +1,65 @@
+import { MorphMap } from "./morph-map";
+import { Relation } from "./relation";
+export class MorphOne extends Relation {
+    morphName;
+    typeColumn;
+    idColumn;
+    morphType;
+    constructor(parent, related, morphName, typeColumn, idColumn, localKey = parent.constructor.primaryKey || "id") {
+        super(parent, related, idColumn, localKey);
+        this.morphName = morphName;
+        this.typeColumn = typeColumn;
+        this.idColumn = idColumn;
+        this.morphType = MorphMap.getMorphAlias(parent);
+    }
+    query() {
+        const localKeyValue = this.parent.getAttribute(this.localKey);
+        return this.related
+            .query()
+            .where(this.typeColumn, this.morphType)
+            .where(this.idColumn, localKeyValue);
+    }
+    async get() {
+        const localKeyValue = this.parent.getAttribute(this.localKey);
+        if (localKeyValue === null || localKeyValue === undefined) {
+            return null;
+        }
+        const result = await this.query().first();
+        return result || null;
+    }
+    async create(attributes = {}) {
+        const localKeyValue = this.parent.getAttribute(this.localKey);
+        return await this.related.create({
+            ...attributes,
+            [this.typeColumn]: this.morphType,
+            [this.idColumn]: localKeyValue,
+        });
+    }
+    async match(parents, relationName) {
+        const localKeys = Array.from(new Set(parents
+            .map((p) => p.getAttribute(this.localKey))
+            .filter((key) => key !== null && key !== undefined)));
+        if (localKeys.length === 0) {
+            for (const parent of parents) {
+                parent.setRelation(relationName, null);
+            }
+            return;
+        }
+        const results = await this.related
+            .query()
+            .where(this.typeColumn, this.morphType)
+            .whereIn(this.idColumn, localKeys)
+            .get();
+        const lookup = new Map();
+        for (const item of results) {
+            const fk = item.getAttribute(this.idColumn);
+            if (!lookup.has(fk)) {
+                lookup.set(fk, item);
+            }
+        }
+        for (const parent of parents) {
+            const lk = parent.getAttribute(this.localKey);
+            parent.setRelation(relationName, lookup.get(lk) || null);
+        }
+    }
+}

package/dist/relations/morph-to-many.d.ts

@@ -0,0 +1,44 @@
+import type { Model } from "../model";
+import type { ModelQueryBuilder } from "../query-builder";
+import { Relation } from "./relation";
+/**
+ * MorphToMany represents a many-to-many polymorphic relation where the parent
+ * owns the polymorphic side of the pivot table (e.g. BlogPost -> tags via taggables).
+ * Pivot columns: ${morphName}_id, ${morphName}_type, ${relatedPivotKey}
+ */
+export declare class MorphToMany<Parent extends Model = any, Related extends Model = any> extends Relation<Parent, Related> {
+    morphName: string;
+    pivotTable: string;
+    foreignPivotKey: string;
+    relatedPivotKey: string;
+    morphTypeColumn: string;
+    relatedKey: string;
+    morphType: string;
+    constructor(parent: Parent, related: any, morphName: string, pivotTable: string, foreignPivotKey: string, relatedPivotKey: string, morphTypeColumn: string, localKey?: string, relatedKey?: string);
+    query(): ModelQueryBuilder<Related>;
+    get(): Promise<Related[]>;
+    attach(relatedId: any, extraAttributes?: Record<string, any>): Promise<void>;
+    detach(relatedId?: any): Promise<void>;
+    sync(ids: any[]): Promise<void>;
+    match(parents: Parent[], relationName: string): Promise<void>;
+}
+/**
+ * MorphedByMany represents the inverse of MorphToMany (e.g. Tag -> posts via taggables).
+ * Pivot columns: ${relatedPivotKey} (tag_id), ${foreignPivotKey} (taggable_id), ${morphTypeColumn} (taggable_type)
+ */
+export declare class MorphedByMany<Parent extends Model = any, Related extends Model = any> extends Relation<Parent, Related> {
+    morphName: string;
+    pivotTable: string;
+    foreignPivotKey: string;
+    relatedPivotKey: string;
+    morphTypeColumn: string;
+    relatedKey: string;
+    morphType: string;
+    constructor(parent: Parent, related: any, morphName: string, pivotTable: string, foreignPivotKey: string, relatedPivotKey: string, morphTypeColumn: string, localKey?: string, relatedKey?: string);
+    query(): ModelQueryBuilder<Related>;
+    get(): Promise<Related[]>;
+    attach(relatedId: any, extraAttributes?: Record<string, any>): Promise<void>;
+    detach(relatedId?: any): Promise<void>;
+    sync(ids: any[]): Promise<void>;
+    match(parents: Parent[], relationName: string): Promise<void>;
+}