adminizer 5.0.0-build.2 → 5.0.0-build.21

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/filters/index.d.ts

@@ -1,6 +1,6 @@
-export { FilterService, default as FilterServiceDefault } from './FilterService';
-export { CustomFilterHandler, default as CustomFilterHandlerDefault } from './CustomFilterHandler';
-export { AbstractCustomFilter } from './CustomFilterHandler';
-export type { FilterCustomFieldCondition, RegisterOptions, FilterCustomFieldInputConfig, FilterCustomFieldInputDefinition, FilterCustomFieldInputType } from './CustomFilterHandler';
-export { ConditionValidator, default as ConditionValidatorDefault } from './ConditionValidator';
-export type { ValidationResult, ValidationError, FieldConfig, SecurityEvent, SecurityEventType } from './ConditionValidator';
+export { FilterService, default as FilterServiceDefault } from './FilterService.js';
+export { CustomFilterHandler, default as CustomFilterHandlerDefault } from './CustomFilterHandler.js';
+export { AbstractCustomFilter } from './CustomFilterHandler.js';
+export type { FilterCustomFieldCondition, RegisterOptions, FilterCustomFieldInputConfig, FilterCustomFieldInputDefinition, FilterCustomFieldInputType } from './CustomFilterHandler.js';
+export { ConditionValidator, default as ConditionValidatorDefault } from './ConditionValidator.js';
+export type { ValidationResult, ValidationError, FieldConfig, SecurityEvent, SecurityEventType } from './ConditionValidator.js';

package/lib/history-actions/AbstractHistoryAdapter.d.ts

@@ -1,9 +1,9 @@
-import { HistoryActions } from "../../models/HistoryActions";
-import { User } from "../../models/User";
-import { Adminizer } from "../Adminizer";
-import { Fields } from "../../helpers/fieldsHelper";
-import { ActionType } from "../../interfaces/adminpanelConfig";
-import { ModelResource } from "../../interfaces/types";
+import { HistoryActions } from "../../models/HistoryActions.js";
+import { User } from "../../models/User.js";
+import { Adminizer } from "../Adminizer.js";
+import { Fields } from "../../helpers/fieldsHelper.js";
+import { ActionType } from "../../interfaces/adminpanelConfig.js";
+import { ModelResource } from "../../interfaces/types.js";
 /**
  * Abstract base class for handling history operations in the AdminPanel.
  * Provides common methods and structure for retrieving, filtering, and formatting historical data.

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/history-actions/DefaultHistoryAdapter.d.ts

@@ -1,7 +1,7 @@
-import { HistoryActions } from "../../models/HistoryActions";
-import { User } from "../../models/User";
-import { Adminizer } from "../Adminizer";
-import { AbstractHistoryAdapter } from "./AbstractHistoryAdapter";
+import { HistoryActions } from "../../models/HistoryActions.js";
+import { User } from "../../models/User.js";
+import { Adminizer } from "../Adminizer.js";
+import { AbstractHistoryAdapter } from "./AbstractHistoryAdapter.js";
 export declare class DefaultHistoryAdapter extends AbstractHistoryAdapter {
     id: string;
     model: string;

package/lib/history-actions/HistoryHandler.d.ts

@@ -1,4 +1,4 @@
-import { AbstractHistoryAdapter } from "./AbstractHistoryAdapter";
+import { AbstractHistoryAdapter } from "./AbstractHistoryAdapter.js";
 export declare class HistoryHandler {
     private adapters;
     add(adapter: AbstractHistoryAdapter): void;

package/lib/list-query-builder/ListQueryBuilder.d.ts

@@ -1,10 +1,10 @@
-import { Fields } from '../../helpers/fieldsHelper';
-import { AbstractModel } from '../model/AbstractModel';
-import { DataAccessor } from '../DataAccessor';
-import { FilterOperator } from '../../models/Filter';
-import { CustomFilterHandler } from '../filters/CustomFilterHandler';
-import { ListQueryBuilderParams, ListQueryBuilderResult } from '../../interfaces/listQueryBuilder';
-import { CriteriaWhere } from '../../interfaces/queryCriteria';
+import { Fields } from '../../helpers/fieldsHelper.js';
+import { AbstractModel } from '../model/AbstractModel.js';
+import { DataAccessor } from '../DataAccessor.js';
+import { FilterOperator } from '../../models/Filter.js';
+import { CustomFilterHandler } from '../filters/CustomFilterHandler.js';
+import { ListQueryBuilderParams, ListQueryBuilderResult } from '../../interfaces/listQueryBuilder.js';
+import { CriteriaWhere } from '../../interfaces/queryCriteria.js';
 /**
  * Security limits for filter conditions
  */

package/lib/media-manager/AbstractMediaManager.d.ts

@@ -1,5 +1,5 @@
-import type { MediaManagerMetaAP } from "../../models/MediaManagerMetaAP";
-import { Adminizer } from "../Adminizer";
+import type { MediaManagerMetaAP } from "../../models/MediaManagerMetaAP.js";
+import { Adminizer } from "../Adminizer.js";
 export interface MediaManagerItem {
     id?: string;
     parent: string | null;

package/lib/media-manager/MediaManagerHandler.d.ts

@@ -1,4 +1,4 @@
-import { AbstractMediaManager } from "./AbstractMediaManager";
+import { AbstractMediaManager } from "./AbstractMediaManager.js";
 export declare class MediaManagerHandler {
     private managers;
     add(manager: AbstractMediaManager): void;

package/lib/media-manager/Thumb.d.ts

@@ -1,4 +1,4 @@
-import { Adminizer } from "../Adminizer";
+import { Adminizer } from "../Adminizer.js";
 export declare class MediaManagerThumb {
     static getThumb(id: string, managerId: string, adminizer: Adminizer): Promise<NonSharedBuffer>;
 }

package/lib/media-manager/helpers/MediaManagerHelper.d.ts

@@ -1,8 +1,8 @@
-import { Fields } from "../../../helpers/fieldsHelper";
-import { MediaManagerWidgetData, MediaManagerItem, MediaManagerWidgetItem, MediaManagerWidgetJSON } from "../AbstractMediaManager";
-import { BaseFieldConfig } from "../../../interfaces/adminpanelConfig";
-import { Adminizer } from "../../Adminizer";
-import type { AppRuntime } from "../../app-manager/AdminizerApp";
+import { Fields } from "../../../helpers/fieldsHelper.js";
+import { MediaManagerWidgetData, MediaManagerItem, MediaManagerWidgetItem, MediaManagerWidgetJSON } from "../AbstractMediaManager.js";
+import { BaseFieldConfig } from "../../../interfaces/adminpanelConfig.js";
+import { Adminizer } from "../../Adminizer.js";
+import type { AppRuntime } from "../../app-manager/AdminizerApp.js";
 type PostParams = Record<string, string | number | boolean | object | string[] | number[] | null>;
 export declare function isMediaManagerFieldConfig(fieldConfig: BaseFieldConfig): boolean;
 export declare function normalizeMediaManagerWidgetData(value: PostParams[string] | undefined, prop: string): MediaManagerWidgetData[];

package/lib/model/AbstractModel.d.ts

@@ -1,14 +1,21 @@
-import { DataAccessor } from "../DataAccessor";
-import { QueryCriteria } from "../../interfaces/queryCriteria";
-import { InternalModelRepository } from "../../interfaces/internalModelAccess";
+import { DataAccessor } from "../DataAccessor.js";
+import { QueryCriteria } from "../../interfaces/queryCriteria.js";
+import { InternalModelRepository } from "../../interfaces/internalModelAccess.js";
 export interface Attribute {
-    type: 'association' | 'association-many' | 'number' | 'json' | 'string' | 'boolean' | 'ref';
+    /**
+     * `date` covers every temporal column (date, time, timestamp). It is deliberately
+     * separate from `string`: dates must not take part in LIKE search, and the UI
+     * renders them with date controls.
+     */
+    type: 'association' | 'association-many' | 'number' | 'json' | 'string' | 'boolean' | 'date' | 'ref';
     required?: boolean;
     unique?: boolean;
     defaultsTo?: any;
     columnName?: string;
     model?: string;
     collection?: string;
+    /** Canonical Adminizer resource target for a system-model association. */
+    resourceName?: string;
     via?: string;
     allowNull?: boolean;
     /**

package/lib/model/InternalModelAccessFactory.d.ts

@@ -1,5 +1,5 @@
-import { InternalModelAccessMap, InternalModelRepository } from "../../interfaces/internalModelAccess";
-import { AbstractModel } from "./AbstractModel";
+import { InternalModelAccessMap, InternalModelRepository } from "../../interfaces/internalModelAccess.js";
+import { AbstractModel } from "./AbstractModel.js";
 export declare const DEFAULT_INTERNAL_MODEL_ACCESS: InternalModelAccessMap;
 export declare class InternalModelScope {
     private readonly getModel;

package/lib/model/ModelHandler.d.ts

@@ -1,6 +1,6 @@
-import { AbstractModel } from "./AbstractModel";
-import { InternalModelAccessMap, InternalModelRepository } from "../../interfaces/internalModelAccess";
-import { InternalModelScope } from "./InternalModelAccessFactory";
+import { AbstractModel } from "./AbstractModel.js";
+import { InternalModelAccessMap, InternalModelRepository } from "../../interfaces/internalModelAccess.js";
+import { InternalModelScope } from "./InternalModelAccessFactory.js";
 export interface AppModelAccessRecord {
     id: string;
     appName: string;
@@ -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;

package/lib/model/ModelHandler.js

@@ -40,18 +40,27 @@ export class AppModelAccess {
 export class ModelHandler {
     models = new Map();
     modelAliases = new Map();
+    hostModelResources = new Map();
     internalAccess;
     appAccessRecords = new Map();
-    add(modelName, modelInstance, aliases = []) {
-        const modelname = modelName.toLowerCase();
-        this.models.set(modelname, {
-            id: modelname,
-            name: modelName,
+    add(resourceName, modelInstance, options = {}) {
+        const resourceId = normalizeName(resourceName);
+        if (this.models.has(resourceId)) {
+            throw new Error(`Model resource "${resourceName}" is already registered`);
+        }
+        const normalizedOptions = Array.isArray(options) ? { aliases: options } : options;
+        const hostModelName = normalizedOptions.hostModelName ?? resourceName;
+        this.registerHostModel(resourceName, hostModelName, true);
+        this.models.set(resourceId, {
+            id: resourceId,
+            name: resourceName,
+            hostModelName,
+            primaryHostModel: normalizedOptions.primary === true,
             model: modelInstance,
             enabled: true,
         });
-        this.registerAliases(modelName, aliases);
-        Adminizer.log.debug(`Model with name [${modelname}] was registered`);
+        this.registerAliases(resourceName, normalizedOptions.aliases ?? []);
+        Adminizer.log.debug(`Model resource [${resourceName}] was registered for host model [${hostModelName}]`);
     }
     register(appName, modelName, modelInstance) {
         const normalizedModelName = normalizeName(modelName);
@@ -61,10 +70,13 @@ export class ModelHandler {
         this.models.set(normalizedModelName, {
             id: normalizedModelName,
             name: modelName,
+            hostModelName: modelName,
+            primaryHostModel: true,
             model: modelInstance,
             ownerApp: appName,
             enabled: true,
         });
+        this.registerHostModel(modelName, modelName, false);
         Adminizer.log.debug(`Model with name [${normalizedModelName}] was registered by app [${appName}]`);
         return normalizedModelName;
     }
@@ -74,6 +86,7 @@ export class ModelHandler {
             return;
         }
         this.models.delete(normalizeName(id));
+        this.unregisterHostModel(record.hostModelName, record.name);
     }
     disable(id) {
         const record = this.models.get(normalizeName(id));
@@ -118,7 +131,10 @@ export class ModelHandler {
         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. */
+    /**
+     * Improved model getter with case-insensitive lookup and configured alias support.
+     * @deprecated New code should use getResource() and getByHostModel() explicitly.
+     */
     get model() {
         return {
             get: (modelName) => this.models.get(this.resolveName(modelName))?.enabled
@@ -130,6 +146,65 @@ export class ModelHandler {
             values: () => this.enabledModelValues(),
         };
     }
+    /**
+     * Returns a model by its Adminizer resource name or an explicit deprecated compatibility alias.
+     * New code must use canonical resource names.
+     */
+    getResource(resourceName) {
+        return this.model.get(resourceName);
+    }
+    getResourceRecord(resourceName) {
+        const record = this.models.get(this.resolveName(resourceName));
+        return record?.enabled ? record : 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) {
+        const resourceIds = this.hostModelResources.get(normalizeName(hostModelName));
+        const records = Array.from(resourceIds ?? [])
+            .map((resourceId) => this.models.get(resourceId))
+            .filter((record) => Boolean(record?.enabled));
+        if (records.length === 1) {
+            return records[0].name;
+        }
+        const primaryRecords = records.filter((record) => record.primaryHostModel);
+        if (primaryRecords.length === 1) {
+            return primaryRecords[0].name;
+        }
+        if (records.length > 1) {
+            throw new Error(this.getSharedHostModelError(hostModelName, records));
+        }
+        return undefined;
+    }
+    getByHostModel(hostModelName) {
+        const resourceName = this.resolveResourceByHostModel(hostModelName);
+        return resourceName ? this.getResource(resourceName) : 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, resourceName) {
+        if (resourceName) {
+            return this.getResourceRecord(resourceName)?.name;
+        }
+        return this.resolveResourceByHostModel(targetName)
+            ?? this.getResourceRecord(targetName)?.name;
+    }
+    /** Validates that every host ORM model used by multiple resources has one primary resource. */
+    validateHostModelMappings() {
+        for (const [normalizedHostModelName, resourceIds] of this.hostModelResources) {
+            const records = Array.from(resourceIds)
+                .map((resourceId) => this.models.get(resourceId))
+                .filter((record) => Boolean(record?.enabled));
+            if (records.length > 1 && records.filter((record) => record.primaryHostModel).length !== 1) {
+                throw new Error(this.getSharedHostModelError(records[0]?.hostModelName ?? normalizedHostModelName, records));
+            }
+        }
+    }
     resolveModelName(modelName) {
         const resolvedName = this.resolveName(modelName);
         return this.models.get(resolvedName)?.name ?? modelName;
@@ -184,6 +259,30 @@ export class ModelHandler {
             this.modelAliases.set(normalizedAlias, normalizedModelName);
         }
     }
+    registerHostModel(resourceName, hostModelName, allowMultipleResources) {
+        const normalizedHostModelName = normalizeName(hostModelName);
+        const resourceId = normalizeName(resourceName);
+        const resourceIds = this.hostModelResources.get(normalizedHostModelName) ?? new Set();
+        if (!allowMultipleResources && resourceIds.size && !resourceIds.has(resourceId)) {
+            const existingResourceId = resourceIds.values().next().value;
+            const existingResource = this.models.get(existingResourceId)?.name ?? existingResourceId;
+            throw new Error(`Host model "${hostModelName}" is already registered for Adminizer resource "${existingResource}"`);
+        }
+        resourceIds.add(resourceId);
+        this.hostModelResources.set(normalizedHostModelName, resourceIds);
+    }
+    unregisterHostModel(hostModelName, resourceName) {
+        const normalizedHostModelName = normalizeName(hostModelName);
+        const resourceIds = this.hostModelResources.get(normalizedHostModelName);
+        resourceIds?.delete(normalizeName(resourceName));
+        if (!resourceIds?.size) {
+            this.hostModelResources.delete(normalizedHostModelName);
+        }
+    }
+    getSharedHostModelError(hostModelName, records) {
+        return (`Host model "${hostModelName}" is mapped to multiple Adminizer resources: ` +
+            `${records.map((record) => record.name).join(", ")}. Configure exactly one with primary: true.`);
+    }
     resolveName(modelName) {
         const normalizedModelName = normalizeName(modelName);
         return this.modelAliases.get(normalizedModelName) ?? normalizedModelName;

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

@@ -1,9 +1,11 @@
-import { Sequelize, ModelStatic } from "sequelize";
-import { AbstractAdapter, AbstractAdapterOptions, AbstractModel, Attribute } from "../AbstractModel";
-import { QueryCriteria } from "../../../interfaces/queryCriteria";
+import type { ModelStatic, Sequelize as SequelizeType } from "sequelize";
+import { AbstractAdapter, AbstractAdapterOptions, AbstractModel, Attribute } from "../AbstractModel.js";
+import { QueryCriteria } from "../../../interfaces/queryCriteria.js";
 export declare function mapSequelizeToAdminizerAttributes(model: ModelStatic<any>): Record<string, Attribute>;
 export declare class SequelizeModel<T> extends AbstractModel<T> {
     private model;
+    private _init;
+    private _ensure;
     constructor(modelName: string, model: ModelStatic<any>);
     private _buildJsonContainsCondition;
     _convertCriteriaToSequelize(criteria: any): any;
@@ -45,9 +47,9 @@ export declare class SequelizeModel<T> extends AbstractModel<T> {
     private _buildCriteriaIncludes;
 }
 export declare class SequelizeAdapter extends AbstractAdapter {
-    sequelize: Sequelize;
+    sequelize: SequelizeType;
     Model: typeof SequelizeModel;
-    constructor(sequelize: Sequelize, options?: AbstractAdapterOptions);
+    constructor(sequelize: SequelizeType, options?: AbstractAdapterOptions);
     get models(): Record<string, any>;
     getModel(modelName: string): any;
     getAttributes(modelName: string): any;