adminizer 5.0.0-build.12 → 5.0.0-build.13

package/helpers/controllerHelper.js

@@ -89,19 +89,27 @@ export class ControllerHelper {
      * @returns {?string}
      */
     static findModelResourceName(req) {
-        if (req.params.modelResourceName) {
-            return req.params.modelResourceName;
+        const models = req.adminizer.config.models;
+        const requestedName = req.params.modelResourceName
+            ?? req.params.model
+            ?? req.originalUrl.split('/')[3];
+        return this.resolveConfiguredResourceName(models, requestedName);
+    }
+    static resolveConfiguredResourceName(models, requestedName) {
+        if (!models || !requestedName) {
+            throw new Error(`Model "${requestedName}" not found`);
         }
-        if (req.params.model) {
-            return req.params.model;
+        if (Object.prototype.hasOwnProperty.call(models, requestedName)) {
+            return requestedName;
         }
-        const urlParts = req.originalUrl.split('/');
-        const modelResourceName = urlParts[3];
-        const models = req.adminizer.config.models;
-        if (!models || !Object.keys(models).some(key => key.toLowerCase() === modelResourceName.toLowerCase())) {
-            throw new Error(`Model "${modelResourceName}" not found`);
+        const candidates = Object.keys(models).filter((key) => key.toLowerCase() === requestedName.toLowerCase());
+        if (candidates.length === 1) {
+            return candidates[0];
+        }
+        if (candidates.length > 1) {
+            throw new Error(`Model resource "${requestedName}" is ambiguous: ${candidates.join(", ")}`);
         }
-        return Object.keys(models).find(key => key.toLowerCase() === modelResourceName.toLowerCase());
+        throw new Error(`Model "${requestedName}" not found`);
     }
     /**
      * Searches for config from admin panel
@@ -116,12 +124,14 @@ export class ControllerHelper {
             Adminizer.log.error('No models configuration found');
             return null;
         }
-        const foundKey = Object.keys(models).find(key => key.toLowerCase() === modelResourceName.toLowerCase());
-        if (!foundKey) {
-            Adminizer.log.error(`No such route exists: ${modelResourceName}`);
+        try {
+            const foundKey = this.resolveConfiguredResourceName(models, modelResourceName);
+            return this._normalizeModelConfig(foundKey, models[foundKey]);
+        }
+        catch (error) {
+            Adminizer.log.error(error);
             return null;
         }
-        return this._normalizeModelConfig(foundKey, models[foundKey]);
     }
     /**
      * Will get action config from configuration file depending to given action
@@ -197,7 +207,7 @@ export class ControllerHelper {
         modelResource.config = this.findModelConfig(req, modelResourceName);
         // Find and add the model itself to the ModelResource
         if (this._isValidModelConfig(modelResource.config)) {
-            modelResource.model = req.adminizer.modelHandler.model.get(modelResource.config.model);
+            modelResource.model = req.adminizer.modelHandler.getResource(modelResourceName);
         }
         // Return the completed ModelResource object
         return modelResource;

package/helpers/fieldsHelper.js

@@ -30,9 +30,9 @@ export class FieldsHelper {
                 Adminizer.log.error('No model found for field: ', fields[key]);
                 return;
             }
-            const resolvedModelName = req.adminizer.modelHandler.resolveModelName(modelName);
-            let Model = req.adminizer.modelHandler.model.get(resolvedModelName);
-            if (!Model) {
+            const resolvedModelName = req.adminizer.modelHandler.resolveAssociationResource(modelName, fields[key].model.resourceName);
+            let Model = resolvedModelName ? req.adminizer.modelHandler.getResource(resolvedModelName) : undefined;
+            if (!Model || !resolvedModelName) {
                 return;
             }
             let list;

package/helpers/inertiaAddHelper.js

@@ -62,7 +62,7 @@ export default function inertiaAddHelper(req, modelResource, fields, record, vie
         let canCreateRelated = false;
         const controlContext = `${modelResource.name}.${key}`;
         //@ts-ignore TODO: fix field type
-        if (modelResource.config.model && req.adminizer.configHelper.isId(field, modelResource.config.model)) {
+        if (req.adminizer.configHelper.isId(field, modelResource.name)) {
             disabled = true;
         }
         if (['string', 'password', 'date', 'datetime', 'time', 'integer', 'number', 'float', 'email', 'month', 'week', 'range'].includes(type)) {

package/helpers/modelResourceHelper.d.ts

@@ -5,5 +5,5 @@ import type { Adminizer } from '../lib/Adminizer.js';
 export declare function normalizeModelConfig(name: string, config: ModelConfig | boolean): ModelConfig;
 /** Every configured model resource whose model is actually registered. */
 export declare function listModelResources(adminizer: Adminizer): ModelResource[];
-/** Resolves a resource by its config key or by the underlying model name. */
+/** Resolves a resource by its Adminizer name, then by a uniquely registered host model name. */
 export declare function resolveModelResource(adminizer: Adminizer, modelName: string): ModelResource | undefined;

package/helpers/modelResourceHelper.js

@@ -20,7 +20,7 @@ export function listModelResources(adminizer) {
     const resources = [];
     for (const [configName, configValue] of Object.entries(adminizer.config.models ?? {})) {
         const config = normalizeModelConfig(configName, configValue);
-        const model = adminizer.modelHandler.model.get(config.model.toLowerCase());
+        const model = adminizer.modelHandler.getResource(configName);
         if (!model)
             continue;
         resources.push({
@@ -32,8 +32,12 @@ export function listModelResources(adminizer) {
     }
     return resources;
 }
-/** Resolves a resource by its config key or by the underlying model name. */
+/** Resolves a resource by its Adminizer name, then by a uniquely registered host model name. */
 export function resolveModelResource(adminizer, modelName) {
-    const loweredName = modelName.trim().toLowerCase();
-    return listModelResources(adminizer).find((resource) => resource.name.toLowerCase() === loweredName || resource.config?.model?.toLowerCase() === loweredName);
+    const requestedName = modelName.trim();
+    const resourceName = adminizer.modelHandler.getResourceRecord(requestedName)?.name
+        ?? adminizer.modelHandler.resolveResourceByHostModel(requestedName);
+    return resourceName
+        ? listModelResources(adminizer).find((resource) => resource.name === resourceName)
+        : undefined;
 }

package/interfaces/adminpanelConfig.d.ts

@@ -299,9 +299,14 @@ export interface ModelConfig {
     adapter?: string;
     title: string;
     /**
-     * Model name
+     * Physical host ORM model name.
      * */
     model: string;
+    /**
+     * Required only when two or more Adminizer resources use the same host model.
+     * The primary resource is selected for associations that reference the host model.
+     */
+    primary?: boolean;
     /**
      * Optional display name for history. Should be a attribute of the model, or a function.
      */

package/lib/DataAccessor.d.ts

@@ -18,6 +18,7 @@ export declare class DataAccessor {
     private getModelConfig;
     private accessRelationModel;
     private resolveRelationTarget;
+    private getRelationModel;
     /**
      * Retrieves the fields for the given ModelResource based on action type,
      * taking into account access rights and configuration settings.

package/lib/DataAccessor.js

@@ -46,29 +46,28 @@ export class DataAccessor {
         this.action = action;
         this.actionVerb = getTokenAction(this.action);
     }
-    getModelConfig(modelName) {
-        const resolvedModelName = this.adminizer.modelHandler.resolveModelName(modelName);
-        const entry = Object.entries(this.adminizer.config.models)
-            .find(([key, config]) => {
-            if (key.toLowerCase() === resolvedModelName.toLowerCase()) {
-                return true;
-            }
-            if (!isObject(config)) {
-                return false;
-            }
-            return config.model?.toLowerCase() === resolvedModelName.toLowerCase();
-        });
-        const config = entry ? entry[1] : undefined;
+    getModelConfig(resourceName) {
+        const config = this.adminizer.config.models?.[resourceName];
         return isObject(config) ? config : undefined;
     }
-    accessRelationModel(modelName) {
-        return this.adminizer.modelHandler.internal("data-accessor").get(modelName);
+    accessRelationModel(modelName, resourceName) {
+        const resolvedResourceName = this.resolveRelationTarget(modelName, resourceName);
+        if (!resolvedResourceName) {
+            throw new Error(`Relation model "${modelName}" was not found`);
+        }
+        return this.adminizer.modelHandler.internal("data-accessor").get(resolvedResourceName);
     }
-    resolveRelationTarget(modelName) {
+    resolveRelationTarget(modelName, resourceName) {
         if (!modelName) {
             return undefined;
         }
-        return this.adminizer.modelHandler.resolveModelName(modelName).toLowerCase();
+        return this.adminizer.modelHandler.resolveAssociationResource(modelName, resourceName);
+    }
+    getRelationModel(modelName, resourceName) {
+        const resolvedResourceName = this.resolveRelationTarget(modelName, resourceName);
+        return resolvedResourceName
+            ? this.adminizer.modelHandler.getResource(resolvedResourceName)
+            : undefined;
     }
     /**
      * Retrieves the fields for the given ModelResource based on action type,
@@ -86,9 +85,9 @@ export class DataAccessor {
         const actionConfig = ControllerHelper.findActionConfig(this.modelResource, this.action);
         const fieldsConfig = this.modelResource.config?.fields || {};
         const modelAttributes = this.modelResource.model.attributes;
-        const tokenId = `${this.actionVerb}-${this.modelResource.model.modelname}-${MODEL_TOKEN_SUFFIX}`;
+        const tokenId = `${this.actionVerb}-${this.modelResource.name}-${MODEL_TOKEN_SUFFIX}`;
         if (!this.adminizer.accessRightsHelper.hasPermission(tokenId, this.user)) {
-            Adminizer.log.debug(`getFieldsConfig > No access rights to ${this.actionVerb} model: ${this.modelResource.model.modelname}`);
+            Adminizer.log.debug(`getFieldsConfig > No access rights to ${this.actionVerb} model: ${this.modelResource.name}`);
             return undefined;
         }
         const result = {};
@@ -131,14 +130,14 @@ export class DataAccessor {
             let populatedModelFieldsConfig = {};
             if (modelField.type === "association" || modelField.type === "association-many") {
                 const modelName = modelField.model || modelField.collection;
-                const resolvedModelName = modelName ? this.adminizer.modelHandler.resolveModelName(modelName) : undefined;
+                const resolvedModelName = this.resolveRelationTarget(modelName, modelField.resourceName);
                 if (modelName && resolvedModelName) {
                     const tokenId = `read-${resolvedModelName}-${MODEL_TOKEN_SUFFIX}`;
                     if (!this.adminizer.accessRightsHelper.hasPermission(tokenId, this.user)) {
-                        Adminizer.log.silly(`No access rights to model: ${this.modelResource.model.modelname}`);
+                        Adminizer.log.silly(`No access rights to model: ${this.modelResource.name}`);
                         return undefined;
                     }
-                    const model = this.adminizer.modelHandler.model.get(modelName);
+                    const model = this.adminizer.modelHandler.getResource(resolvedModelName);
                     if (model) {
                         populatedModelFieldsConfig = this.getAssociatedFieldsConfig(resolvedModelName);
                         const modelCfg = this.getModelConfig(resolvedModelName);
@@ -186,17 +185,16 @@ export class DataAccessor {
         Object.keys(fields).forEach(appendField);
         return orderedFields;
     }
-    getAssociatedFieldsConfig(modelName) {
-        const resolvedModelName = this.adminizer.modelHandler.resolveModelName(modelName);
-        const model = this.adminizer.modelHandler.model.get(resolvedModelName);
-        const modelConfig = this.getModelConfig(resolvedModelName);
+    getAssociatedFieldsConfig(resourceName) {
+        const model = this.adminizer.modelHandler.getResource(resourceName);
+        const modelConfig = this.getModelConfig(resourceName);
         if (!model || !modelConfig) {
             return undefined;
         }
         // Check if user has access to the associated model
-        const tokenId = `read-${resolvedModelName}-${MODEL_TOKEN_SUFFIX}`;
+        const tokenId = `read-${resourceName}-${MODEL_TOKEN_SUFFIX}`;
         if (!this.adminizer.accessRightsHelper.hasPermission(tokenId, this.user)) {
-            Adminizer.log.debug(`getAssociatedFieldsConfig > No access rights to ${this.actionVerb} model: ${resolvedModelName}`);
+            Adminizer.log.debug(`getAssociatedFieldsConfig > No access rights to ${this.actionVerb} model: ${resourceName}`);
             return undefined;
         }
         const associatedFields = {};
@@ -379,7 +377,7 @@ export class DataAccessor {
     async sanitizeUserRelationAccess(criteria = {}) {
         let sanitizedCriteria = {};
         // Retrieve model configuration from adminpanel config
-        const modelName = this.modelResource.model.modelname;
+        const modelName = this.modelResource.name;
         const modelConfig = this.modelResource.config;
         // Check if the model has `userAccessRelation` configured
         if (!this.user.isAdministrator && modelConfig && modelConfig.userAccessRelation) {
@@ -392,18 +390,18 @@ export class DataAccessor {
                 // Check if the relation points to `User` or `Group` in the model's attributes
                 const modelAttributes = this.modelResource.model.attributes;
                 const relation = modelAttributes[accessField];
-                const relationModel = this.resolveRelationTarget(relation?.model);
-                const relationCollection = this.resolveRelationTarget(relation?.collection);
-                if (!relation || !['user', 'group'].includes(relationModel ?? relationCollection ?? "")) {
+                const relationModel = this.resolveRelationTarget(relation?.model, relation?.resourceName);
+                const relationCollection = this.resolveRelationTarget(relation?.collection, relation?.resourceName);
+                if (!relation || !['User', 'Group'].includes(relationModel ?? relationCollection ?? "")) {
                     throw new Error(`Invalid userAccessRelation configuration for model ${modelName}`);
                 }
                 // Determine if the current user matches the access criteria
                 if (relationModel) {
-                    if (relationModel === 'user') {
+                    if (relationModel === 'User') {
                         // Filter by the user's ID if related to User as a model
                         sanitizedCriteria = { ...sanitizedCriteria, [accessField]: this.user.id };
                     }
-                    else if (relationModel === 'group') {
+                    else if (relationModel === 'Group') {
                         // Filter by user's group membership if related to Group as a model
                         const userGroups = this.user.groups?.map((group) => group.id);
                         sanitizedCriteria = { ...sanitizedCriteria, [accessField]: { in: userGroups } };
@@ -412,11 +410,11 @@ export class DataAccessor {
                 /** Warning: collection relation access is not supported and needs adapter-level processing */
                 if (relationCollection) {
                     Adminizer.log.warn(`Collection relation is not supported and was not tested. You may have an error here: ${JSON.stringify(relation, null, 2)}`);
-                    if (relationCollection === 'user') {
+                    if (relationCollection === 'User') {
                         // Ensure user's ID is part of the associated collection to User
                         sanitizedCriteria = { ...sanitizedCriteria, [accessField]: { contains: this.user.id } };
                     }
-                    else if (relationCollection === 'group') {
+                    else if (relationCollection === 'Group') {
                         // Ensure user's groups intersect with the collection to Group
                         const userGroups = this.user.groups?.map((group) => group.id);
                         sanitizedCriteria = { ...sanitizedCriteria, [accessField]: { intersects: userGroups } };
@@ -433,19 +431,19 @@ export class DataAccessor {
                     throw new Error(`Invalid intermediate relation configuration for field "${field}" in model ${modelName}`);
                 }
                 // Retrieve the intermediate model
-                const intermediateModel = this.adminizer.modelHandler.model.get(intermediateRelation.model.toLowerCase());
+                const intermediateModel = this.getRelationModel(intermediateRelation.model, intermediateRelation.resourceName);
                 if (!intermediateModel) {
                     throw new Error(`Intermediate model "${intermediateRelation.model}" not found`);
                 }
                 // Validate the `via` field in the intermediate model
                 const intermediateAttributes = intermediateModel.attributes;
                 const viaRelation = intermediateAttributes[via];
-                if (!viaRelation || this.resolveRelationTarget(viaRelation.model) !== 'user') {
+                if (!viaRelation || this.resolveRelationTarget(viaRelation.model, viaRelation.resourceName) !== 'User') {
                     throw new Error(`Unsupported or invalid via field "${via}" in intermediate model "${intermediateRelation.model}". ` +
                         `Currently, only relations to "User" are supported`);
                 }
                 // Fetch all intermediate records associated with the user
-                const intermediateRecords = await this.accessRelationModel(intermediateRelation.model).find({ where: { [via]: this.user.id } });
+                const intermediateRecords = await this.accessRelationModel(intermediateRelation.model, intermediateRelation.resourceName).find({ where: { [via]: this.user.id } });
                 const intermediateIds = (intermediateRecords || []).map((r) => r.id);
                 // Filter main model by all matching intermediate record IDs
                 sanitizedCriteria = { ...sanitizedCriteria, [field]: { in: intermediateIds } };
@@ -471,14 +469,14 @@ export class DataAccessor {
                 // Check if the relation points to `User` or `Group` in the model's attributes
                 const modelAttributes = this.modelResource.model.attributes;
                 const relation = modelAttributes[accessField];
-                const relationModel = this.resolveRelationTarget(relation?.model);
-                if (relation && ['user', 'group'].includes(relationModel ?? "")) {
-                    if (relationModel === 'user') {
+                const relationModel = this.resolveRelationTarget(relation?.model, relation?.resourceName);
+                if (relation && ['User', 'Group'].includes(relationModel ?? "")) {
+                    if (relationModel === 'User') {
                         if (!this.user.isAdministrator) {
                             updatedRecord[accessField] = this.user.id;
                         }
                     }
-                    else if (relationModel === 'group') {
+                    else if (relationModel === 'Group') {
                         const userGroups = this.user.groups || [];
                         if (userGroups.length === 1) {
                             updatedRecord[accessField] = userGroups[0].id;
@@ -500,16 +498,16 @@ export class DataAccessor {
                     const modelAttributes = this.modelResource.model.attributes;
                     const intermediateRelation = modelAttributes[field];
                     if (!intermediateRelation || !intermediateRelation.model) {
-                        throw new Error(`Invalid intermediate relation configuration for field "${field}" in model ${this.modelResource.model.modelname}`);
+                        throw new Error(`Invalid intermediate relation configuration for field "${field}" in model ${this.modelResource.name}`);
                     }
-                    const intermediateModel = this.adminizer.modelHandler.model.get(intermediateRelation.model.toLowerCase());
+                    const intermediateModel = this.getRelationModel(intermediateRelation.model, intermediateRelation.resourceName);
                     if (!intermediateModel) {
                         throw new Error(`Intermediate model "${intermediateRelation.model}" not found`);
                     }
                     // Validate the `via` field in the intermediate model
                     const intermediateAttributes = intermediateModel.attributes;
                     const viaRelation = intermediateAttributes[via];
-                    if (!viaRelation || this.resolveRelationTarget(viaRelation.model) !== 'user') {
+                    if (!viaRelation || this.resolveRelationTarget(viaRelation.model, viaRelation.resourceName) !== 'User') {
                         throw new Error(`Unsupported or invalid via field "${via}" in intermediate model "${intermediateRelation.model}". ` +
                             `Currently, only relations to "User" are supported`);
                     }
@@ -517,7 +515,7 @@ export class DataAccessor {
                     const chosenId = typeof updatedRecord[field] === 'object'
                         ? updatedRecord[field][intermediatePk]
                         : updatedRecord[field];
-                    const record = await this.accessRelationModel(intermediateRelation.model).findOne({ where: { [intermediatePk]: chosenId, [via]: this.user.id } });
+                    const record = await this.accessRelationModel(intermediateRelation.model, intermediateRelation.resourceName).findOne({ where: { [intermediatePk]: chosenId, [via]: this.user.id } });
                     if (!record) {
                         throw new Error(`Access denied: "${field}" does not belong to the current user`);
                     }

package/lib/filters/FilterService.js

@@ -25,8 +25,9 @@ export class FilterService {
         if (!models) {
             return null;
         }
-        // Find config (case-insensitive)
-        const foundKey = Object.keys(models).find(key => key.toLowerCase() === modelName.toLowerCase());
+        const foundKey = Object.prototype.hasOwnProperty.call(models, modelName)
+            ? modelName
+            : Object.keys(models).find(key => key.toLowerCase() === modelName.toLowerCase());
         if (!foundKey) {
             return null;
         }
@@ -35,7 +36,7 @@ export class FilterService {
             return null;
         }
         // Get AbstractModel
-        const model = this.adminizer.modelHandler.model.get(config.model);
+        const model = this.adminizer.modelHandler.getResource(foundKey);
         if (!model) {
             return null;
         }

package/lib/history-actions/AbstractHistoryAdapter.js

@@ -86,9 +86,9 @@ export class AbstractHistoryAdapter {
      * @returns Array of model names (in lowercase) the user can access.
      */
     getModels(user) {
-        const models = this.adminizer.modelHandler.all
-            .filter(model => !this.excludedModels.has(model.modelname))
-            .map(model => model.modelname.toLowerCase());
+        const models = Array.from(this.adminizer.modelHandler.model.entries())
+            .filter(([, model]) => !this.excludedModels.has(model.modelname))
+            .map(([resourceName]) => resourceName);
         const accessModels = [];
         for (const model of models) {
             const access = this.adminizer.accessRightsHelper.enoughPermissions([
@@ -304,14 +304,15 @@ export class AbstractHistoryAdapter {
      * @protected
      */
     findModelResource(history) {
-        const modelResourceName = history.modelName;
+        const modelResourceName = this.adminizer.modelHandler.getResourceRecord(history.modelName)?.name
+            ?? history.modelName;
         const modelResourceUri = `${this.adminizer.config.routePrefix}/model/${modelResourceName}`;
         const models = this.adminizer.config.models;
         const foundKey = Object.keys(models).find(key => key.toLowerCase() === modelResourceName.toLowerCase());
         const modelResource = {
             name: modelResourceName,
             uri: modelResourceUri,
-            model: this.adminizer.modelHandler.model.get(history.modelName),
+            model: this.adminizer.modelHandler.getResource(modelResourceName),
             config: models[foundKey]
         };
         return modelResource;
@@ -341,8 +342,9 @@ export class AbstractHistoryAdapter {
                 Adminizer.log.error('No model found for field: ', fields[key]);
                 return;
             }
-            let Model = this.adminizer.modelHandler.model.get(modelName);
-            if (!Model) {
+            const resourceName = this.adminizer.modelHandler.resolveAssociationResource(modelName, fields[key].model.resourceName);
+            let Model = resourceName ? this.adminizer.modelHandler.getResource(resourceName) : undefined;
+            if (!Model || !resourceName) {
                 return;
             }
             let list;
@@ -351,8 +353,8 @@ export class AbstractHistoryAdapter {
                 Adminizer.log.warn("Warning: executing malicious job trying to add a huge amount of records in field config," +
                     " please rewrite this part of code in the nearest future");
                 let modelResource = {
-                    name: modelName, config: this.adminizer.config.models[modelName],
-                    model: Model, uri: `${this.adminizer.config.routePrefix}/model/${modelName}`
+                    name: resourceName, config: this.adminizer.config.models[resourceName],
+                    model: Model, uri: `${this.adminizer.config.routePrefix}/model/${resourceName}`
                 };
                 let dataAccessor = new DataAccessor(this.adminizer, user, modelResource, "view");
                 list = await Model.find({}, dataAccessor);

package/lib/model/AbstractModel.d.ts

@@ -14,6 +14,8 @@ export interface Attribute {
     columnName?: string;
     model?: string;
     collection?: string;
+    /** Canonical Adminizer resource target for a system-model association. */
+    resourceName?: string;
     via?: string;
     allowNull?: boolean;
     /**

package/lib/model/ModelHandler.d.ts

@@ -9,10 +9,26 @@ export interface AppModelAccessRecord {
 export interface ModelRecord {
     id: string;
     name: string;
+    hostModelName: string;
+    primaryHostModel: boolean;
     model: AbstractModel<any>;
     ownerApp?: string;
     enabled: boolean;
 }
+export interface ModelRegistrationOptions {
+    /** Physical ORM model name. It is intentionally independent from the Adminizer resource name. */
+    hostModelName?: string;
+    /**
+     * Selects this resource as the association target when multiple resources use the same host model.
+     * Exactly one resource must be primary for every shared host model.
+     */
+    primary?: boolean;
+    /**
+     * @deprecated Register and use the canonical Adminizer resource name instead.
+     * Kept only for compatibility with existing integrations. Host model names must not be used as aliases.
+     */
+    aliases?: string[];
+}
 export declare class AppModelAccess {
     private readonly getModel;
     private readonly appName;
@@ -33,9 +49,12 @@ export declare class AppModelAccess {
 export declare class ModelHandler {
     private models;
     private modelAliases;
+    private hostModelResources;
     private internalAccess?;
     private appAccessRecords;
-    add<T>(modelName: string, modelInstance: AbstractModel<T>, aliases?: string[]): void;
+    add<T>(resourceName: string, modelInstance: AbstractModel<T>, options?: ModelRegistrationOptions): void;
+    /** @deprecated Pass `{ aliases }` in ModelRegistrationOptions, or preferably use the canonical resource name. */
+    add<T>(resourceName: string, modelInstance: AbstractModel<T>, aliases?: string[]): void;
     register<T>(appName: string, modelName: string, modelInstance: AbstractModel<T>): string;
     unregister(id: string): void;
     disable(id: string): void;
@@ -45,7 +64,10 @@ export declare class ModelHandler {
     unregisterAppAccess(id: string): void;
     getAppAccessRecords(appName: string): AppModelAccessRecord[];
     createAppAccess(appName: string): AppModelAccess;
-    /** Improved model getter with case-insensitive lookup and configured alias support. */
+    /**
+     * Improved model getter with case-insensitive lookup and configured alias support.
+     * @deprecated New code should use getResource() and getByHostModel() explicitly.
+     */
     get model(): {
         get: (modelName: string) => AbstractModel<any>;
         has: (modelName: string) => boolean;
@@ -53,6 +75,26 @@ export declare class ModelHandler {
         keys: () => IterableIterator<string>;
         values: () => IterableIterator<AbstractModel<any>>;
     };
+    /**
+     * Returns a model by its Adminizer resource name or an explicit deprecated compatibility alias.
+     * New code must use canonical resource names.
+     */
+    getResource(resourceName: string): AbstractModel<any> | undefined;
+    getResourceRecord(resourceName: string): ModelRecord | undefined;
+    /**
+     * Resolves a physical ORM model name to its Adminizer resource.
+     * This lookup is deliberately separate from getResource(): a host model may have the
+     * same name as a system resource while being exposed under a project resource alias.
+     */
+    resolveResourceByHostModel(hostModelName: string): string | undefined;
+    getByHostModel(hostModelName: string): AbstractModel<any> | undefined;
+    /**
+     * Resolves an ORM association target. Adapter-provided host model names take precedence;
+     * system-model relations may pass their explicit canonical resource name instead.
+     */
+    resolveAssociationResource(targetName: string, resourceName?: string): string | undefined;
+    /** Validates that every host ORM model used by multiple resources has one primary resource. */
+    validateHostModelMappings(): void;
     resolveModelName(modelName: string): string;
     configureInternalAccess(accessMap?: InternalModelAccessMap): void;
     internal(scopeName: string): InternalModelScope;
@@ -63,6 +105,9 @@ export declare class ModelHandler {
     get all(): AbstractModel<any>[];
     private getAllowedAppModels;
     private registerAliases;
+    private registerHostModel;
+    private unregisterHostModel;
+    private getSharedHostModelError;
     private resolveName;
     private enabledModelEntries;
     private enabledModelKeys;