adminizer 4.7.0-build.222 → 5.0.0-build.0

package/lib/model/ModelHandler.js

@@ -1,5 +1,33 @@
 import { Adminizer } from "../Adminizer.js";
 import { InternalModelAccessFactory } from "./InternalModelAccessFactory.js";
+import { createInternalModelRepository } from "./internalModelRepository.js";
+function normalizeName(name) {
+    return name.toLowerCase();
+}
+export class AppModelAccess {
+    getModel;
+    appName;
+    allowedModels;
+    constructor(getModel, appName, allowedModels) {
+        this.getModel = getModel;
+        this.appName = appName;
+        this.allowedModels = allowedModels;
+    }
+    get(modelName) {
+        const normalizedModelName = normalizeName(modelName);
+        if (!this.allowedModels().has(normalizedModelName)) {
+            throw new Error(`App model access denied: app "${this.appName}" cannot use model "${modelName}"`);
+        }
+        const model = this.getModel(modelName);
+        if (!model) {
+            throw new Error(`App model access failed: model "${modelName}" was not found`);
+        }
+        return createInternalModelRepository(modelName, model);
+    }
+    has(modelName) {
+        return this.allowedModels().has(normalizeName(modelName)) && Boolean(this.getModel(modelName));
+    }
+}
 /**
  * Central registry (service locator) for all AbstractModel instances in the application.
  * A single instance is created in Adminizer and shared across the entire app via `req.adminizer.modelHandler`.
@@ -7,27 +35,105 @@ import { InternalModelAccessFactory } from "./InternalModelAccessFactory.js";
  * Models are registered at startup via `bindModels`, then looked up by name from controllers,
  * services, helpers, and system utilities — without importing each model directly.
  *
- * Lookup is case-insensitive: `"UserAP"`, `"userap"`, and `"USERAP"` all resolve to the same model.
+ * Lookup is case-insensitive and can resolve aliases registered at startup via system model bindings.
  */
 export class ModelHandler {
     models = new Map();
+    modelAliases = new Map();
     internalAccess;
-    add(modelName, modelInstance) {
+    appAccessRecords = new Map();
+    add(modelName, modelInstance, aliases = []) {
         const modelname = modelName.toLowerCase();
-        this.models.set(modelname, modelInstance);
+        this.models.set(modelname, {
+            id: modelname,
+            name: modelName,
+            model: modelInstance,
+            enabled: true,
+        });
+        this.registerAliases(modelName, aliases);
         Adminizer.log.debug(`Model with name [${modelname}] was registered`);
     }
-    // TODO: 'hot reload' need add method for delete model
-    /** Improved model getter, so you can write both model.get("UserAP") and model.get("userap") */
+    register(appName, modelName, modelInstance) {
+        const normalizedModelName = normalizeName(modelName);
+        if (this.models.has(normalizedModelName)) {
+            throw new Error(`Model "${modelName}" is already registered`);
+        }
+        this.models.set(normalizedModelName, {
+            id: normalizedModelName,
+            name: modelName,
+            model: modelInstance,
+            ownerApp: appName,
+            enabled: true,
+        });
+        Adminizer.log.debug(`Model with name [${normalizedModelName}] was registered by app [${appName}]`);
+        return normalizedModelName;
+    }
+    unregister(id) {
+        const record = this.models.get(normalizeName(id));
+        if (!record?.ownerApp) {
+            return;
+        }
+        this.models.delete(normalizeName(id));
+    }
+    disable(id) {
+        const record = this.models.get(normalizeName(id));
+        if (!record?.ownerApp) {
+            return;
+        }
+        record.enabled = false;
+    }
+    enable(id) {
+        const record = this.models.get(normalizeName(id));
+        if (!record?.ownerApp) {
+            return;
+        }
+        record.enabled = true;
+    }
+    getByApp(appName) {
+        return Array.from(this.models.values()).filter((record) => record.ownerApp === appName);
+    }
+    registerAppAccess(appName, id, models) {
+        const resourceId = `${appName}:${id}`;
+        if (this.appAccessRecords.has(resourceId)) {
+            throw new Error(`App model access "${resourceId}" is already registered`);
+        }
+        const missingModels = models.filter((modelName) => !this.model.has(modelName));
+        if (missingModels.length) {
+            throw new Error(`App "${appName}" requested missing models: ${missingModels.join(", ")}`);
+        }
+        this.appAccessRecords.set(resourceId, {
+            id: resourceId,
+            appName,
+            models: Array.from(new Set(models.map(normalizeName))),
+        });
+        return resourceId;
+    }
+    unregisterAppAccess(id) {
+        this.appAccessRecords.delete(id);
+    }
+    getAppAccessRecords(appName) {
+        return Array.from(this.appAccessRecords.values()).filter((record) => record.appName === appName);
+    }
+    createAppAccess(appName) {
+        return new AppModelAccess((modelName) => this.model.get(modelName), appName, () => this.getAllowedAppModels(appName));
+    }
+    // TODO: 'hot reload' need add method for delete model & unbind
+    /** Improved model getter with case-insensitive lookup and configured alias support. */
     get model() {
         return {
-            get: (modelName) => this.models.get(modelName.toLowerCase()),
-            has: (modelName) => this.models.has(modelName.toLowerCase()),
-            entries: () => this.models.entries(),
-            keys: () => this.models.keys(),
-            values: () => this.models.values(),
+            get: (modelName) => this.models.get(this.resolveName(modelName))?.enabled
+                ? this.models.get(this.resolveName(modelName)).model
+                : undefined,
+            has: (modelName) => Boolean(this.models.get(this.resolveName(modelName))?.enabled),
+            entries: () => this.enabledModelEntries(),
+            keys: () => this.enabledModelKeys(),
+            values: () => this.enabledModelValues(),
         };
     }
+    resolveModelName(modelName) {
+        const resolvedName = this.resolveName(modelName);
+        return this.models.get(resolvedName)?.name ?? modelName;
+    }
     configureInternalAccess(accessMap) {
         this.internalAccess = new InternalModelAccessFactory((modelName) => this.model.get(modelName), accessMap);
     }
@@ -45,11 +151,62 @@ export class ModelHandler {
      */
     get all() {
         try {
-            return Array.from(this.models.values());
+            return Array.from(this.enabledModelValues());
         }
         catch (e) {
             Adminizer.log.error(e);
             return [];
         }
     }
+    getAllowedAppModels(appName) {
+        const allowedModels = new Set();
+        for (const record of this.getAppAccessRecords(appName)) {
+            for (const modelName of record.models) {
+                allowedModels.add(modelName);
+            }
+        }
+        return allowedModels;
+    }
+    registerAliases(modelName, aliases) {
+        const normalizedModelName = normalizeName(modelName);
+        for (const alias of aliases) {
+            const normalizedAlias = normalizeName(alias);
+            if (normalizedAlias === normalizedModelName) {
+                continue;
+            }
+            const existingTarget = this.modelAliases.get(normalizedAlias);
+            if (existingTarget && existingTarget !== normalizedModelName) {
+                throw new Error(`Model alias "${alias}" is already registered for model "${existingTarget}"`);
+            }
+            if (this.models.has(normalizedAlias) && normalizedAlias !== normalizedModelName) {
+                throw new Error(`Model alias "${alias}" conflicts with a registered model`);
+            }
+            this.modelAliases.set(normalizedAlias, normalizedModelName);
+        }
+    }
+    resolveName(modelName) {
+        const normalizedModelName = normalizeName(modelName);
+        return this.modelAliases.get(normalizedModelName) ?? normalizedModelName;
+    }
+    *enabledModelEntries() {
+        for (const [modelName, record] of this.models.entries()) {
+            if (record.enabled) {
+                yield [modelName, record.model];
+            }
+        }
+    }
+    *enabledModelKeys() {
+        for (const [modelName, record] of this.models.entries()) {
+            if (record.enabled) {
+                yield modelName;
+            }
+        }
+    }
+    *enabledModelValues() {
+        for (const record of this.models.values()) {
+            if (record.enabled) {
+                yield record.model;
+            }
+        }
+    }
 }

package/lib/model/adapter/sequelize.d.ts

@@ -1,5 +1,5 @@
 import { Sequelize, ModelStatic } from "sequelize";
-import { AbstractAdapter, AbstractModel, Attribute } from "../AbstractModel";
+import { AbstractAdapter, AbstractAdapterOptions, AbstractModel, Attribute } from "../AbstractModel";
 import { QueryCriteria } from "../../../interfaces/queryCriteria";
 export declare function mapSequelizeToAdminizerAttributes(model: ModelStatic<any>): Record<string, Attribute>;
 export declare class SequelizeModel<T> extends AbstractModel<T> {
@@ -47,10 +47,8 @@ export declare class SequelizeModel<T> extends AbstractModel<T> {
 export declare class SequelizeAdapter extends AbstractAdapter {
     sequelize: Sequelize;
     Model: typeof SequelizeModel;
-    constructor(sequelize: Sequelize);
+    constructor(sequelize: Sequelize, options?: AbstractAdapterOptions);
     get models(): Record<string, any>;
     getModel(modelName: string): any;
     getAttributes(modelName: string): any;
-    /** Registration of system models */
-    static registerSystemModels(sequelize: Sequelize, alter?: boolean): Promise<void>;
 }

package/lib/model/adapter/sequelize.js

@@ -1,82 +1,5 @@
-import { Sequelize, DataTypes, Op, HasMany } from "sequelize";
+import { Sequelize, Op, HasMany } from "sequelize";
 import { AbstractAdapter, AbstractModel } from "../AbstractModel.js";
-import path from "path";
-import fs from "fs";
-import { pathToFileURL } from "url";
-import { fileURLToPath } from "url";
-function generateAssociationsFromSchema(models, schemas) {
-    for (const modelName in schemas) {
-        const schema = schemas[modelName];
-        const model = models[modelName];
-        if (!model)
-            continue;
-        for (const fieldName in schema) {
-            const field = schema[fieldName];
-            if (field.collection && field.via) {
-                const targetModel = models[field.collection];
-                const targetSchema = schemas[field.collection];
-                const inverseField = targetSchema?.[field.via];
-                // Normalize join table to lowercase for consistency across dialects
-                const throughTableName = [modelName, field.collection]
-                    .sort()
-                    .join("")
-                    .toLowerCase();
-                // 💡 M:N connection
-                if (inverseField && inverseField.collection === modelName) {
-                    model.belongsToMany(targetModel, {
-                        through: throughTableName,
-                        as: fieldName,
-                        foreignKey: `${modelName}Id`,
-                        otherKey: `${field.collection}Id`
-                    });
-                }
-                // 💡 O:M communication (one to many)
-                else {
-                    let foreignKey = `${modelName}Id`;
-                    if (field.collection === modelName) {
-                        foreignKey = `${field.via}Id`;
-                    }
-                    model.hasMany(targetModel, {
-                        as: fieldName,
-                        foreignKey,
-                    });
-                    const alias = field.via;
-                    const belongsToOptions = { foreignKey };
-                    if (targetModel.rawAttributes[alias] || targetModel.associations[alias]) {
-                        belongsToOptions.as = `${alias}Ref`;
-                    }
-                    else {
-                        belongsToOptions.as = alias;
-                    }
-                    targetModel.belongsTo(model, belongsToOptions);
-                }
-            }
-            // 💡 O:1 or 1:1 (belongsTo)
-            if (field.model) {
-                const targetModel = models[field.model];
-                if (!targetModel)
-                    continue;
-                // Avoid naming collisions by using an explicit foreign key
-                const alias = fieldName;
-                const foreignKey = `${alias}Id`;
-                // Reuse the attribute name unless it already exists on the model or association
-                let asName = alias;
-                if (model.rawAttributes[alias] || model.associations[alias]) {
-                    asName = `${alias}Ref`;
-                }
-                const belongsToOptions = {
-                    as: asName,
-                    foreignKey,
-                };
-                // Add onDelete constraint if specified
-                if (field.onDelete) {
-                    belongsToOptions.onDelete = field.onDelete;
-                }
-                model.belongsTo(targetModel, belongsToOptions);
-            }
-        }
-    }
-}
 function resolveType(type) {
     const sqlType = typeof type.toString === "function"
         ? type.toString().toLowerCase()
@@ -117,7 +40,7 @@ export function mapSequelizeToAdminizerAttributes(model) {
         switch (assoc.associationType) {
             case "BelongsTo": {
                 const a = assoc;
-                result[a.foreignKey]["primaryKeyForAssociation"] = true;
+                markAssociationForeignKey(result, a.foreignKey);
                 result[alias] = {
                     type: "association",
                     model: a.target.name,
@@ -127,7 +50,7 @@ export function mapSequelizeToAdminizerAttributes(model) {
             }
             case "HasOne": {
                 const a = assoc;
-                result[a.foreignKey]["primaryKeyForAssociation"] = true;
+                markAssociationForeignKey(result, a.foreignKey);
                 result[alias] = {
                     type: "association",
                     model: a.target.name,
@@ -159,6 +82,11 @@ export function mapSequelizeToAdminizerAttributes(model) {
     }
     return result;
 }
+function markAssociationForeignKey(attributes, foreignKey) {
+    if (typeof foreignKey === "string" && attributes[foreignKey]) {
+        attributes[foreignKey].primaryKeyForAssociation = true;
+    }
+}
 function capitalize(str) {
     return str.charAt(0).toUpperCase() + str.slice(1);
 }
@@ -868,16 +796,16 @@ export class SequelizeModel extends AbstractModel {
     _buildIncludes() {
         return Object.keys(this.model.associations).map(key => ({ association: key }));
     }
-    _buildAttributes(select) {
+    _buildAttributes(select, rawAttributes = this.model.rawAttributes) {
         if (!select) {
             return undefined;
         }
         if (Array.isArray(select)) {
-            const attributes = select.filter((field) => this.model.rawAttributes?.[field]);
+            const attributes = select.filter((field) => rawAttributes?.[field]);
             return attributes.length ? attributes : undefined;
         }
         const attributes = Object.entries(select)
-            .filter(([field, enabled]) => enabled && this.model.rawAttributes?.[field])
+            .filter(([field, enabled]) => enabled && rawAttributes?.[field])
             .map(([field]) => field);
         return attributes.length ? attributes : undefined;
     }
@@ -886,8 +814,10 @@ export class SequelizeModel extends AbstractModel {
             if (nestedCriteria === true) {
                 return { association };
             }
-            const { where, attributes, order, limit, } = this._convertAdminizerCriteriaToSequelizeOptions(nestedCriteria);
+            const { where, order, limit, } = this._convertAdminizerCriteriaToSequelizeOptions(nestedCriteria);
             const include = { association };
+            const targetAttributes = this.model.associations[association]?.target?.rawAttributes;
+            const attributes = this._buildAttributes(nestedCriteria.select, targetAttributes);
             if (where && (Object.keys(where).length > 0 || Object.getOwnPropertySymbols(where).length > 0)) {
                 include.where = where;
             }
@@ -910,8 +840,8 @@ export class SequelizeModel extends AbstractModel {
 export class SequelizeAdapter extends AbstractAdapter {
     sequelize;
     Model = SequelizeModel;
-    constructor(sequelize) {
-        super("sequelize", sequelize);
+    constructor(sequelize, options = {}) {
+        super("sequelize", sequelize, options);
         this.sequelize = sequelize;
     }
     get models() {
@@ -928,111 +858,4 @@ export class SequelizeAdapter extends AbstractAdapter {
         const model = this.getModel(modelName);
         return model?.getAttributes();
     }
-    /** Registration of system models */
-    static async registerSystemModels(sequelize, alter = true) {
-        // Get current file directory from import.meta.url
-        const currentDir = import.meta.url ? path.dirname(fileURLToPath(import.meta.url)) : process.cwd();
-        // Try multiple possible model locations
-        const possiblePaths = [
-            path.resolve(currentDir, "../../../../models"),
-            path.resolve(currentDir, "../../../../src/models"),
-            path.resolve(currentDir, "../../../models"),
-            path.resolve(currentDir, "../../../src/models"),
-            path.resolve(process.cwd(), "node_modules/adminizer/src/models"),
-            path.resolve(process.cwd(), "node_modules/adminizer/models")
-        ];
-        let modelsDir = null;
-        for (const possiblePath of possiblePaths) {
-            if (fs.existsSync(possiblePath)) {
-                modelsDir = possiblePath;
-                break;
-            }
-        }
-        if (!modelsDir) {
-            return;
-        }
-        let files = fs.readdirSync(modelsDir).filter((f) => f.endsWith(".js"));
-        if (!files.length) {
-            files = fs.readdirSync(modelsDir).filter((f) => f.endsWith(".ts") && !f.endsWith(".d.ts"));
-        }
-        if (!files.length) {
-            return;
-        }
-        const schemas = {};
-        for (const file of files) {
-            const modelName = path.basename(file, path.extname(file));
-            const filePath = path.resolve(modelsDir, file);
-            const mod = await import(pathToFileURL(filePath).href);
-            const definition = mod.default;
-            schemas[modelName] = definition;
-            generateSequelizeModel(sequelize, modelName, definition);
-        }
-        generateAssociationsFromSchema(sequelize.models, schemas);
-        // Check ORM_ALTER environment variable before sync
-        if (process.env.ORM_ALTER !== 'false' && alter) {
-            await sequelize.sync();
-        }
-        else {
-        }
-    }
-}
-/** Generation of the Sequelize model from Adminizer's model definition */
-function generateSequelizeModel(sequelize, modelName, rawAttributes) {
-    const attributes = {};
-    let primaryKey = null;
-    for (const field in rawAttributes) {
-        const attr = { ...rawAttributes[field] };
-        // 💥 Skip associations (handled separately)
-        if (attr.model || attr.collection) {
-            continue;
-        }
-        if (attr.primaryKey) {
-            primaryKey = field;
-            attr.primaryKey = true;
-        }
-        if (attr.uuid && attr.type === "string") {
-            attr.type = DataTypes.UUID;
-            attr.defaultValue = DataTypes.UUIDV4;
-            delete attr.uuid;
-        }
-        if (attr.autoIncrement) {
-            attr.autoIncrement = true;
-        }
-        if (attr.unique) {
-            attr.unique = true;
-        }
-        if (typeof attr.type === "string") {
-            switch (attr.type) {
-                case "string":
-                    attr.type = DataTypes.STRING;
-                    break;
-                case "number":
-                    attr.type = DataTypes.INTEGER;
-                    break;
-                case "boolean":
-                    attr.type = DataTypes.BOOLEAN;
-                    break;
-                case "json":
-                    attr.type = DataTypes.JSON;
-                    break;
-                case "ref":
-                    attr.type = DataTypes.JSON;
-                    break;
-                case "datetime":
-                case "date":
-                    attr.type = DataTypes.DATE;
-                    break;
-                default:
-                    throw new Error(`Unrecognized datatype "${attr.type}" for field "${field}" in model "${modelName}"`);
-            }
-        }
-        attributes[field] = attr;
-    }
-    if (!primaryKey) {
-        throw new Error(`Model "${modelName}" must have a primary key`);
-    }
-    return sequelize.define(modelName, attributes, {
-        tableName: modelName.toLowerCase(),
-        timestamps: true,
-    });
 }

package/lib/model/adapter/typeorm.d.ts

@@ -1,5 +1,5 @@
 import { DataSource, EntityMetadata, EntitySchema, ObjectLiteral } from "typeorm";
-import { AbstractAdapter, AbstractModel, ModelAttributes } from "../AbstractModel";
+import { AbstractAdapter, AbstractAdapterOptions, AbstractModel, ModelAttributes } from "../AbstractModel";
 import { QueryCriteria } from "../../../interfaces/queryCriteria";
 /**
  * Experimental TypeORM adapter.
@@ -11,7 +11,6 @@ import { QueryCriteria } from "../../../interfaces/queryCriteria";
 type AdminizerSchema = Record<string, any>;
 export declare function mapTypeOrmToAdminizerAttributes(metadata: EntityMetadata): ModelAttributes;
 export declare function createTypeOrmEntitySchemaFromAdminizerSchema(modelName: string, schema: AdminizerSchema, allSchemas: Record<string, AdminizerSchema>): EntitySchema;
-export declare function loadSystemTypeOrmEntities(): Promise<EntitySchema[]>;
 export declare class TypeOrmModel<T extends ObjectLiteral> extends AbstractModel<T> {
     private readonly metadata;
     private readonly repository;
@@ -52,11 +51,10 @@ export declare class TypeOrmModel<T extends ObjectLiteral> extends AbstractModel
 export declare class TypeOrmAdapter extends AbstractAdapter {
     dataSource: DataSource;
     Model: typeof TypeOrmModel;
-    constructor(dataSource: DataSource);
+    constructor(dataSource: DataSource, options?: AbstractAdapterOptions);
     get models(): Record<string, EntityMetadata>;
     getModel(modelName: string): EntityMetadata | undefined;
     getAttributes(modelName: string): ModelAttributes | undefined;
     static createEntitySchema(modelName: string, schema: AdminizerSchema, allSchemas?: Record<string, AdminizerSchema>): EntitySchema;
-    static loadSystemEntities(): Promise<EntitySchema[]>;
 }
 export {};

package/lib/model/adapter/typeorm.js

@@ -1,6 +1,3 @@
-import fs from "fs";
-import path from "path";
-import { pathToFileURL, fileURLToPath } from "url";
 import { Brackets, EntitySchema, NotBrackets, } from "typeorm";
 import { v4 as uuid } from "uuid";
 import { AbstractAdapter, AbstractModel } from "../AbstractModel.js";
@@ -216,33 +213,6 @@ export function createTypeOrmEntitySchemaFromAdminizerSchema(modelName, schema,
         relations,
     });
 }
-export async function loadSystemTypeOrmEntities() {
-    const currentDir = import.meta.url ? path.dirname(fileURLToPath(import.meta.url)) : process.cwd();
-    const possiblePaths = [
-        path.resolve(currentDir, "../../../../models"),
-        path.resolve(currentDir, "../../../../src/models"),
-        path.resolve(currentDir, "../../../models"),
-        path.resolve(currentDir, "../../../src/models"),
-        path.resolve(process.cwd(), "node_modules/adminizer/src/models"),
-        path.resolve(process.cwd(), "node_modules/adminizer/models"),
-    ];
-    const modelsDir = possiblePaths.find((possiblePath) => fs.existsSync(possiblePath));
-    if (!modelsDir) {
-        return [];
-    }
-    let files = fs.readdirSync(modelsDir).filter((file) => file.endsWith(".js"));
-    if (!files.length) {
-        files = fs.readdirSync(modelsDir).filter((file) => file.endsWith(".ts") && !file.endsWith(".d.ts"));
-    }
-    const schemas = {};
-    for (const file of files) {
-        const modelName = path.basename(file, path.extname(file));
-        const filePath = path.resolve(modelsDir, file);
-        const mod = await import(pathToFileURL(filePath).href);
-        schemas[modelName] = mod.default;
-    }
-    return Object.entries(schemas).map(([modelName, schema]) => createTypeOrmEntitySchemaFromAdminizerSchema(modelName, schema, schemas));
-}
 export class TypeOrmModel extends AbstractModel {
     metadata;
     repository;
@@ -750,8 +720,8 @@ export class TypeOrmModel extends AbstractModel {
 export class TypeOrmAdapter extends AbstractAdapter {
     dataSource;
     Model = TypeOrmModel;
-    constructor(dataSource) {
-        super("typeorm", dataSource);
+    constructor(dataSource, options = {}) {
+        super("typeorm", dataSource, options);
         this.dataSource = dataSource;
     }
     get models() {
@@ -771,7 +741,4 @@ export class TypeOrmAdapter extends AbstractAdapter {
     static createEntitySchema(modelName, schema, allSchemas = { [modelName]: schema }) {
         return createTypeOrmEntitySchemaFromAdminizerSchema(modelName, schema, allSchemas);
     }
-    static async loadSystemEntities() {
-        return await loadSystemTypeOrmEntities();
-    }
 }

package/lib/notifications/AbstractNotificationService.d.ts

@@ -1,8 +1,8 @@
 import { EventEmitter } from 'events';
 import { Adminizer } from '../Adminizer';
 import { INotification, INotificationEvent } from '../../interfaces/types';
-import { NotificationAPModel } from "../../models/NotificationAP";
-import { UserAP } from "../../models/UserAP";
+import { NotificationModel } from "../../models/Notification";
+import { User } from "../../models/User";
 /**
  * ░█████╗░██████╗░░██████╗████████╗██████╗░░█████╗░░█████╗░████████╗
  * ██╔══██╗██╔══██╗██╔════╝╚══██╔══╝██╔══██╗██╔══██╗██╔══██╗╚══██╔══╝
@@ -58,7 +58,7 @@ export declare abstract class AbstractNotificationService extends EventEmitter {
     constructor(adminizer: Adminizer);
     protected notificationModel(): import("../..").InternalModelRepository<any>;
     protected userNotificationModel(): import("../..").InternalModelRepository<any>;
-    protected userModel(): import("../..").InternalModelRepository<UserAP>;
+    protected userModel(): import("../..").InternalModelRepository<User>;
     private _bindAccessRight;
     /**
      * Registers a client for a user and associates it with a send function.
@@ -66,9 +66,9 @@ export declare abstract class AbstractNotificationService extends EventEmitter {
      * The client is then added to the user's Map with the provided send function.
      * @param {string} clientId - The unique identifier of the client to be registered.
      * @param {(event: INotificationEvent) => void} sendFn - The function used to send notifications to the client.
-     * @param {UserAP} user - The user associated with the client.
+     * @param {User} user - The user associated with the client.
      */
-    addClient(clientId: string, sendFn: (event: INotificationEvent) => void, user: UserAP): void;
+    addClient(clientId: string, sendFn: (event: INotificationEvent) => void, user: User): void;
     /**
      * Removes a client from the internal tracking structure.
      * If the user associated with the client has no more clients after removal, the user's Map is also removed.
@@ -113,7 +113,7 @@ export declare abstract class AbstractNotificationService extends EventEmitter {
      */
     sendHeartbeat(clientId: string): void;
     /**
-     * Creates a new user notification record in the 'usernotificationap' model.
+     * Creates a new user notification record in the 'UserNotification' model.
      * This method is used to associate a notification with a specific user and mark it as unread.
      * @param {string} notificationId - The unique identifier of the notification.
      * @param {number} [userId] - The ID of the user to associate the notification with. Optional.
@@ -121,7 +121,7 @@ export declare abstract class AbstractNotificationService extends EventEmitter {
      */
     protected createUserNotification(notificationId: string, userId?: number): Promise<void>;
     /**
-     * Retrieves a user notification record from the 'usernotificationap' model.
+     * Retrieves a user notification record from the 'UserNotification' model.
      * The record is fetched based on the provided notification ID and user ID.
      * @param {string} notificationId - The unique identifier of the notification.
      * @param {number} userId - The ID of the user associated with the notification.
@@ -139,11 +139,11 @@ export declare abstract class AbstractNotificationService extends EventEmitter {
     getNotifications(userId: number, limit?: number, skip?: number, unreadOnly?: boolean): Promise<INotification[]>;
     /**
      * Prepares notification data by enriching it with user-specific read status and icon information.
-     * @param {NotificationAPModel[]} notificationsDB - An array of raw notification records from the database.
+     * @param {NotificationModel[]} notificationsDB - An array of raw notification records from the database.
      * @param {number} userId - The ID of the user for whom the read status is determined.
      * @returns {Promise<INotification[]>} A promise that resolves with an array of enriched notification objects.
      */
-    protected prepareNotification(notificationsDB: NotificationAPModel[], userId: number): Promise<INotification[]>;
+    protected prepareNotification(notificationsDB: NotificationModel[], userId: number): Promise<INotification[]>;
     /**
      * Searches for notifications for a specific user based on a message keyword.
      * @param {string} s - The search string used to filter notifications by message content.