@andrewcaires/api 4.5.2 → 5.0.1

package/dist/index.d.ts

@@ -1,178 +1,179 @@
 /*!
- * @andrewcaires/api v4.5.2
+ * @andrewcaires/api v5.0.1
  * Simple api for small applications using express, jsonwebtoken, sequelize and websocket
  * (c) 2026 Andrew Caires
  * @license: MIT
  */
-import { EventEmitter, TypeAnyObject, TypeObjectString, TypeObject, ValidationBase, TypeAnyFunction } from '@andrewcaires/utils.js';
-import { Application as Application$1, Context, IStore, IUpload, IFile } from '@andrewcaires/express';
-import { WhereOptions, Model as Model$1, CreateOptions, Attributes, FindOptions, UpdateOptions, FindAttributeOptions, ModelStatic } from 'sequelize';
-import { Model, Sequelize } from '@andrewcaires/sequelize';
+import { Context, Application as Application$1, IOptions, IStore } from '@andrewcaires/express';
 import { Hash, Env as Env$1 } from '@andrewcaires/node';
+import { Model, Sequelize } from '@andrewcaires/sequelize';
+import { TypeAnyObject, TypeObjectString, TypeAnyFunction, TypeAnyConstructor, EventEmitter, TypeObject, ValidationBase } from '@andrewcaires/utils.js';
 import { WebSocketServer } from 'ws';
-import { Store as Store$1, SessionData } from 'express-session';
-
-declare abstract class Controller extends EventEmitter {
-    static readonly ATTRIBUTES: unique symbol;
-    static readonly PERMISSIONS: unique symbol;
-}
+import { Model as Model$1, FindOptions, Attributes, CreateOptions, UpdateOptions, FindAttributeOptions, ModelStatic } from 'sequelize';
+import { Store, SessionData } from 'express-session';
 
-declare class Auth extends Model {
-    readonly id: number;
+declare class RegisterModel extends Model {
+    readonly id: string;
     secret: string;
-    logout: Date | null;
-    user_agent: string;
+    expired_at: number;
+    state: boolean;
     readonly created_at: Date;
     readonly updated_at: Date;
     readonly deleted_at: Date | null;
-    user_id: number;
-    user: User;
+    user_id: string;
+    user: UserModel;
 }
 
-declare class Register extends Model {
-    readonly id: number;
-    token: string;
-    state: boolean;
+declare class UserAuthModel extends Model {
+    readonly id: string;
+    secret: string;
+    ip_address: string;
+    user_agent: string;
+    revoked_at: Date | null;
     readonly created_at: Date;
     readonly updated_at: Date;
     readonly deleted_at: Date | null;
-    user_id: number;
-    user: User;
+    user_id: string;
+    user: UserModel;
 }
 
-declare class Permission extends Model {
-    readonly id: number;
+declare class PermissionModel extends Model {
+    readonly id: string;
     name: string;
-    route: string;
-    tag: string;
+    key: string;
+    tags: string;
     description: string;
     state: boolean;
     readonly created_at: Date;
     readonly updated_at: Date;
     readonly deleted_at: Date | null;
-    groups_permissions: Array<GroupPermission>;
+    groups_permissions: Array<GroupPermissionModel>;
 }
 
-declare class GroupPermission extends Model {
+declare class GroupPermissionModel extends Model {
     readonly created_at: Date;
-    group_id: number;
-    group: Group;
-    permission_id: number;
-    permission: Permission;
+    group_id: string;
+    group: GroupModel;
+    permission_id: string;
+    permission: PermissionModel;
 }
 
-declare class Group extends Model {
-    readonly id: number;
+declare class GroupModel extends Model {
+    readonly id: string;
     name: string;
+    key: string;
+    tags: string;
     description: string;
     state: boolean;
     readonly created_at: Date;
     readonly updated_at: Date;
     readonly deleted_at: Date | null;
-    groups_routes: Array<GroupPermission>;
-    users_groups: Array<UserGroup>;
+    users_groups: Array<UserGroupModel>;
+    groups_Permission: Array<GroupPermissionModel>;
 }
 
-declare class UserGroup extends Model {
+declare class UserGroupModel extends Model {
     readonly created_at: Date;
-    group_id: number;
-    group: Group;
-    user_id: number;
-    user: User;
+    group_id: string;
+    group: GroupModel;
+    user_id: string;
+    user: UserModel;
 }
 
-declare class UserHistory extends Model {
-    password: string;
+declare class UserPasswordModel extends Model {
+    readonly id: string;
+    value: string;
+    state: boolean;
     readonly created_at: Date;
-    user_id: number;
-    user: User;
+    readonly updated_at: Date;
+    readonly deleted_at: Date | null;
+    user_id: string;
+    user: UserModel;
+}
+
+declare class UserProfileModel extends Model {
+    readonly id: string;
+    data: TypeAnyObject;
+    readonly created_at: Date;
+    readonly updated_at: Date;
+    readonly deleted_at: Date | null;
+    user_id: string;
+    user: UserModel;
 }
 
-declare class User extends Model {
-    readonly id: number;
+declare class UserModel extends Model {
+    readonly id: string;
     name: string;
     email: string;
     username: string;
-    password: string;
-    salt: string;
-    token: string;
-    avatar: string;
-    date: string;
     description: string;
     state: boolean;
     readonly created_at: Date;
     readonly updated_at: Date;
     readonly deleted_at: Date | null;
-    audits: Array<Audit>;
-    auths: Array<Auth>;
-    registers: Array<Register>;
-    users_groups: Array<UserGroup>;
-    users_histories: Array<UserHistory>;
+    audits: Array<AuditModel>;
+    users_auths: Array<UserAuthModel>;
+    registers: Array<RegisterModel>;
+    users_groups: Array<UserGroupModel>;
+    users_passwords: Array<UserPasswordModel>;
+    users_profiles: Array<UserProfileModel>;
 }
 
-declare class Audit extends Model {
-    readonly id: number;
-    type: string;
+declare class AuditModel extends Model {
+    readonly id: string;
+    type: "CREATE" | "DELETE" | "UPDATE";
     model: string;
     record: string;
     data: TypeAnyObject;
     previously: TypeAnyObject;
-    client: string;
-    href: string;
+    full_url: string;
+    ip_address: string;
     user_agent: string;
+    app_name: string;
     state: boolean;
     readonly created_at: Date;
     readonly updated_at: Date;
     readonly deleted_at: Date | null;
-    user_id: number;
-    user: User;
+    user_id: string;
+    user: UserModel;
 }
 
-declare class Config extends Model {
+declare class ConfigModel extends Model {
+    readonly id: string;
     key: string;
     value: string;
     readonly created_at: Date;
     readonly updated_at: Date;
-    static all(): Promise<TypeObjectString>;
-    static del(key: string, user?: User): Promise<boolean>;
-    static get(key: string, value?: string): Promise<string>;
-    static set(key: string, value: string, user?: User): Promise<void>;
 }
 
-declare class Forgot extends Model {
-    readonly id: number;
-    token: string;
-    timestamp: number;
+declare class ForgotModel extends Model {
+    readonly id: string;
+    secret: string;
+    expired_at: number;
     state: boolean;
     readonly created_at: Date;
     readonly updated_at: Date;
     readonly deleted_at: Date | null;
-    user_id: number;
-    user: User;
+    user_id: string;
+    user: UserModel;
 }
 
-declare class Log extends Model {
-    readonly id: number;
-    type: string;
-    source: string;
+declare class LogModel extends Model {
+    readonly id: string;
+    level: "info" | "warn" | "error";
     message: string;
+    source: string;
     readonly created_at: Date;
-    static write(message: string, source?: string, show?: boolean): Promise<void>;
-    static error(message: string, source?: string, show?: boolean): Promise<void>;
-    static info(message: string, source?: string, show?: boolean): Promise<void>;
-    static success(message: string, source?: string, show?: boolean): Promise<void>;
-    static warning(message: string, source?: string, show?: boolean): Promise<void>;
-    private static writeRaw;
 }
 
-declare class Migration extends Model {
+declare class MigrationModel extends Model {
     model: string;
     version: string;
     readonly created_at: Date;
     readonly updated_at: Date;
 }
 
-declare class Session extends Model {
+declare class SessionModel extends Model {
     session: string;
     json: string;
     expired: number;
@@ -180,328 +181,472 @@ declare class Session extends Model {
     readonly updated_at: Date;
 }
 
-declare class Application extends Application$1 {
-    readonly hash: Hash;
-    private _webSocket?;
-    constructor(controllers: Array<Controller>);
-    error(error: any, source?: string): void;
-    log(message: string, source?: string): void;
-    listen(): Promise<void>;
-    migrations(database: Sequelize): Promise<void>;
-    websocket(): WebSocketServer | undefined;
+declare class UserMetadataModel extends Model {
+    readonly id: string;
+    data: TypeAnyObject;
+    readonly created_at: Date;
+    readonly updated_at: Date;
+    readonly deleted_at: Date | null;
+    user_id: string;
+    user: UserModel;
 }
 
-declare abstract class ControllerBase extends Controller {
-    protected [Controller.PERMISSIONS]: Array<string>;
-    auth(ctx: Context, key_header: string, token_header: string, token_cookie: string, key_query: string, user_agent: string, app: Application): Promise<void>;
-    canCreate(ctx: Context, name: string, user: User): Promise<void>;
-    canDelete(ctx: Context, name: string, user: User): Promise<void>;
-    canRead(ctx: Context, name: string, user: User): Promise<void>;
-    canUpdate(ctx: Context, name: string, user: User): Promise<void>;
-    error(error: any): void;
-    name(): string;
-    permission(ctx: Context, route: string, user: User): Promise<void>;
-    permissions(user: User, where?: WhereOptions): Promise<Array<Permission>>;
-    session(ctx: Context, user_agent: string, store: IStore): Promise<void>;
-    sync(): Promise<void>;
-    upload(ctx: Context, options: IUpload): void;
-    validation(ctx: Context, options: TypeObject<ValidationBase>): Promise<void>;
+interface IAuthParameters {
+    auth?: UserAuthModel;
+    decode?: TypeAnyObject;
+    forgot?: ForgotModel;
+    token?: string;
+    user?: UserModel;
+}
+
+interface AuthEvents {
+    "auth.activation": {
+        ctx: Context;
+        register: RegisterModel;
+        user: UserModel;
+    };
+    "auth.failure": {
+        ctx: Context;
+        user?: UserModel;
+    };
+    "auth.login": {
+        ctx: Context;
+        auth: UserAuthModel;
+        user: UserModel;
+    };
+    "auth.logout": {
+        ctx: Context;
+        auth: UserAuthModel;
+        user: UserModel;
+    };
+    "auth.renew": {
+        ctx: Context;
+        auth: UserAuthModel;
+    };
+}
+
+interface ForgotEvents {
+    "forgot.reset": {
+        ctx: Context;
+        user?: UserModel;
+    };
+    "forgot.send": {
+        ctx: Context;
+        forgot: ForgotModel;
+        user: UserModel;
+    };
+}
+
+interface RegisterEvents {
+    "register.confirm": {
+        ctx: Context;
+        register: RegisterModel;
+        user?: UserModel;
+    };
+    "register.send": {
+        ctx: Context;
+        register: RegisterModel;
+        user?: UserModel;
+    };
+    "register.user": {
+        ctx: Context;
+        register: RegisterModel;
+        user?: UserModel;
+    };
+}
+
+interface ApplicationEvents extends AuthEvents, ForgotEvents, RegisterEvents {
+}
+
+declare module "express-serve-static-core" {
+    interface Request {
+        auth?: UserAuthModel;
+    }
+}
+
+declare module "express-serve-static-core" {
+    interface Request {
+        groups?: Array<string>;
+    }
+}
+
+declare module "express-serve-static-core" {
+    interface Request {
+        permissions?: Array<string>;
+    }
+}
+
+declare module "express-serve-static-core" {
+    interface Request {
+        profile?: TypeObjectString;
+    }
+}
+
+declare module "express-serve-static-core" {
+    interface Request {
+        user?: UserModel;
+    }
+}
+
+interface ModelArgumentsBase<M extends Model$1<M>> {
+    ctx?: Context;
 }
 
-interface ArgumentsModel<M extends Model$1<M>> {
-    ctx: Context;
+interface ModelArgumentsCount<M extends Model$1<any>> extends ModelArgumentsBase<M> {
+    options?: FindOptions<Attributes<M>>;
 }
 
-interface ArgumentsModelCreate<M extends Model$1<M>> extends ArgumentsModel<M> {
+interface ModelArgumentsCreate<M extends Model$1<M>> extends ModelArgumentsBase<M> {
     options?: CreateOptions<Attributes<M>>;
     body?: TypeAnyObject;
 }
 
-interface ArgumentsModelDelete<M extends Model$1<M>> extends ArgumentsModel<M> {
+interface ModelArgumentsDelete<M extends Model$1<M>> extends ModelArgumentsBase<M> {
+    id?: string | number;
     options?: FindOptions<Attributes<M>>;
 }
 
-type CallbackModelAll<M> = (_records: Array<M>) => Array<any> | Promise<Array<any>>;
+type ModelCallbackFindAll<M> = (_records: Array<M>) => Array<any> | Promise<Array<any>>;
 
-interface ArgumentsModelFindAll<M extends Model$1<any>> extends ArgumentsModel<M> {
+interface ModelArgumentsFindAll<M extends Model$1<any>> extends ModelArgumentsBase<M> {
     options?: FindOptions<Attributes<M>>;
-    callback?: CallbackModelAll<M>;
-    scope?: string;
-    advanced?: boolean;
-    attributes?: Array<string>;
+    callback?: ModelCallbackFindAll<M>;
     limited?: boolean;
 }
 
-type CallbackModelGet<M> = (_records: M) => any | Promise<any>;
+type ModelCallbackFindOne<M> = (_records: M) => any | Promise<any>;
 
-interface ArgumentsModelFindOne<M extends Model$1<M>> extends ArgumentsModel<M> {
+interface ModelArgumentsFindOne<M extends Model$1<M>> extends ModelArgumentsBase<M> {
     options?: FindOptions<Attributes<M>>;
-    callback?: CallbackModelGet<M>;
-    scope?: string;
+    callback?: ModelCallbackFindOne<M>;
 }
 
-interface ArgumentsModelUpdate<M extends Model$1<M>> extends ArgumentsModel<M> {
+interface ModelArgumentsUpdate<M extends Model$1<M>> extends ModelArgumentsBase<M> {
+    id?: string | number;
     options?: UpdateOptions<Attributes<M>>;
     body?: TypeAnyObject;
 }
 
-interface IAuthParameters {
-    auth?: Auth;
-    decode?: TypeAnyObject;
-    error?: string;
-    forgot?: Forgot;
-    token?: string;
-    user?: User;
+interface ModelOptions {
+    attributes?: FindAttributeOptions;
+    permissions?: Array<string>;
 }
 
-interface ResultModelAll<M extends Model$1<M>> {
+interface ModelResultFindAll<M extends Model<M>> {
     count: number;
     records: Array<M>;
 }
 
-declare abstract class ControllerModel<M extends Model$1<any>> extends ControllerBase {
-    protected [ControllerBase.ATTRIBUTES]: Array<string>;
-    protected [ControllerBase.PERMISSIONS]: Array<string>;
-    protected attributes(options: FindAttributeOptions): Array<string>;
-    protected create({ ctx, options, body }: ArgumentsModelCreate<M>): Promise<M | void>;
-    protected delete({ ctx, options }: ArgumentsModelDelete<M>): Promise<number>;
-    error(error: any): void;
-    protected findAll({ ctx, options, callback, scope, advanced, attributes, limited }: ArgumentsModelFindAll<M>): Promise<ResultModelAll<M>>;
-    protected findOne({ ctx, options, callback, scope }: ArgumentsModelFindOne<M>): Promise<M | void>;
-    abstract model(): ModelStatic<M>;
+declare class Loggable {
+    get log(): (message: string) => void;
+    static get log(): (message: string) => void;
+    get error(): (error: any) => void;
+    static get error(): (error: any) => void;
+    private static logError;
+    private static logInfo;
+    private static source;
+}
+
+declare class Config extends Loggable {
+    static all(keys?: Array<string>): Promise<TypeObjectString>;
+    static del(key: string): Promise<boolean>;
+    static get(key: string, value?: string): Promise<string>;
+    static set(key: string, value: string): Promise<void>;
+}
+
+declare class Log {
+    protected static colors: TypeAnyObject;
+    static error(message: string, source?: string, show?: boolean): Promise<void>;
+    static info(message: string, source?: string, show?: boolean): Promise<void>;
+    static warn(message: string, source?: string, show?: boolean): Promise<void>;
+    private static writeRaw;
+}
+
+declare class SessionStore extends Store {
+    private loop;
+    constructor();
+    all: (callback: TypeAnyFunction) => Promise<void>;
+    clear: (callback: TypeAnyFunction) => Promise<void>;
+    destroy: (session_id: string, callback: TypeAnyFunction) => Promise<void>;
+    expired: () => Promise<void>;
+    get: (session_id: string, callback: TypeAnyFunction) => Promise<void>;
+    length: (callback: TypeAnyFunction) => Promise<void>;
+    set: (session_id: any, session: SessionData, callback: TypeAnyFunction) => Promise<void>;
+}
+
+interface Service extends Loggable {
+}
+declare abstract class Service {
+}
+
+declare class AuthService extends Service {
+    create(user: UserModel): Promise<IAuthParameters>;
+    destroy(auth?: UserAuthModel): Promise<boolean>;
+    renew(token: string): Promise<IAuthParameters>;
+    user(token: string): Promise<IAuthParameters>;
+    private options;
+    private verify;
+    key(value: string): Promise<IAuthParameters>;
+}
+
+declare class ModelService<M extends Model$1<any>> extends Service {
+    protected model: ModelStatic<M>;
+    protected attributes: Array<string>;
+    protected filter: FindAttributeOptions;
+    protected permissions: Array<string>;
+    constructor(model: ModelStatic<M>, options?: ModelOptions);
+    countAll({ ctx, options }: ModelArgumentsCount<M>): Promise<number>;
+    create({ ctx, options, body }: ModelArgumentsCreate<M>): Promise<M | null>;
+    delete({ ctx, options, id: _id }: ModelArgumentsDelete<M>): Promise<number>;
+    private filterAttributes;
+    findAll({ ctx, options, callback, limited }: ModelArgumentsFindAll<M>): Promise<ModelResultFindAll<M>>;
+    findOne({ ctx, options, callback }: ModelArgumentsFindOne<M>): Promise<M | null>;
+    getAttributes(options: FindAttributeOptions): Array<string>;
     sync(): Promise<void>;
-    protected update({ ctx, options, body }: ArgumentsModelUpdate<M>): Promise<boolean>;
-    key(): string;
+    update({ ctx, options, body, id: _id }: ModelArgumentsUpdate<M>): Promise<boolean>;
     name(): string;
-    scope(name?: string): ModelStatic<M>;
 }
 
-declare abstract class ControllerCrud<M extends Model$1<any>> extends ControllerModel<M> {
-    private _crud;
-    CrudArgumentsCreate(ctx: Context): ArgumentsModelUpdate<M>;
-    CrudArgumentsFindAll(ctx: Context): ArgumentsModelFindAll<M>;
-    CrudArgumentsFindOne(ctx: Context): ArgumentsModelFindOne<M>;
-    CrudArgumentsDelete(ctx: Context): ArgumentsModelDelete<M>;
-    CrudArgumentsUpdate(ctx: Context): ArgumentsModelUpdate<M>;
-    CrudValidationCreate(): TypeObject<ValidationBase>;
-    CrudValidationUpdate(): TypeObject<ValidationBase>;
-    protected add(ctx: Context): Promise<void>;
-    protected all(ctx: Context): Promise<void>;
-    protected del(ctx: Context): Promise<void>;
-    protected get(ctx: Context): Promise<void>;
-    protected set(ctx: Context): Promise<void>;
-    protected validationCreate(ctx: Context): Promise<void>;
-    protected validationUpdate(ctx: Context): Promise<void>;
+declare class UserService extends Service {
+    getMetadata(user_id: string): Promise<TypeObjectString>;
+    getProfile(user_id: string): Promise<TypeObjectString>;
+    getGroups(user_id: string): Promise<Array<string>>;
+    getPermissions(user_id: string): Promise<Array<string>>;
 }
 
-declare class Env extends Env$1 {
-    static readonly API_BASE_NAME: string;
-    static readonly API_BODYPARSER_STRICT: boolean;
-    static readonly API_BODYPARSER_INFLATE: boolean;
-    static readonly API_BODYPARSER_LIMIT: string;
-    static readonly API_BODYPARSER_TYPE: string;
-    static readonly API_CONSOLE_ERROR: boolean;
-    static readonly API_DATABASE_URL: string;
-    static readonly API_DATABASE_LOG: boolean;
-    static readonly API_DATABASE_AUDIT: boolean;
-    static readonly API_DATABASE_PREFIX: string;
-    static readonly API_DATABASE_TIMEZONE: string;
-    static readonly API_HTTP_CRT: string;
-    static readonly API_HTTP_KEY: string;
-    static readonly API_HTTP_PORT: number;
-    static readonly API_HTTP_PUBLIC: string;
-    static readonly API_HTTP_CROSS: boolean;
-    static readonly API_HTTP_HYBRID: boolean;
-    static readonly API_HTTP_NOTFOUND: string;
-    static readonly API_HTTP_PATH: string;
-    static readonly API_HTTP_REDIRECT: string;
-    static readonly API_KEY_HASH: string;
-    static readonly API_KEY_HEADER: string;
-    static readonly API_MODEL_LIMIT: number;
-    static readonly API_MODEL_LIMIT_MAX: number;
-    static readonly API_SLEEP_AUTH: number;
-    static readonly API_SLEEP_FORGOT: number;
-    static readonly API_SLEEP_REGISTRY: number;
-    static readonly API_SESSION_NAME: string;
-    static readonly API_SESSION_LIFETIME: number;
-    static readonly API_SESSION_SECRET: string;
-    static readonly API_TOKEN_COOKIE: string;
-    static readonly API_TOKEN_COOKIE_SET: boolean;
-    static readonly API_TOKEN_CRT: string;
-    static readonly API_TOKEN_KEY: string;
-    static readonly API_TOKEN_FORGOT: number;
-    static readonly API_TOKEN_HEADER: string;
-    static readonly API_TOKEN_HEADER_KEY: string;
-    static readonly API_TOKEN_LIFETIME: number;
-    static readonly API_TOKEN_RENEW: number;
-    static readonly API_UPLOAD_COUNT: number;
-    static readonly API_UPLOAD_FIELD: string;
-    static readonly API_UPLOAD_SIZE: number;
-    static readonly API_UPLOAD_TEMP: string;
-    static readonly API_USER_HISTORY: boolean;
-    static readonly API_WEBSOCKET_START: boolean;
+declare class Application<T extends TypeAnyObject = ApplicationEvents> extends Application$1<T> {
+    readonly hash: Hash;
+    authService: AuthService;
+    userService: UserService;
+    private _webSocket?;
+    constructor(controllers: Array<object | TypeAnyConstructor<object>>, options?: IOptions);
+    error(error: any, source?: string): void;
+    log(message: string, source?: string): void;
+    listen(): Promise<void>;
+    migrations(database: Sequelize): Promise<void>;
+    websocket(): WebSocketServer | undefined;
+}
+
+interface BaseController extends Loggable {
+}
+declare abstract class BaseController<T extends TypeAnyObject = TypeAnyObject> extends EventEmitter<T> {
+    protected readonly permissions: Array<string>;
+    name(): string;
+    session(ctx: Context, user_agent: string, store: IStore): Promise<void>;
+    sync(): Promise<void>;
 }
 
-declare class AuditsController extends ControllerModel<Audit> {
-    model(): typeof Audit;
+declare abstract class ModelController<M extends Model$1<any>, T extends TypeAnyObject = TypeAnyObject> extends BaseController<T> {
+    protected readonly attributes: Array<string>;
+    protected abstract readonly model: ModelStatic<M>;
+    protected readonly permissions: Array<string>;
+    private service;
+    protected countAll(options: ModelArgumentsCount<M>): Promise<number>;
+    protected create(options: ModelArgumentsCreate<M>): Promise<M | null>;
+    protected delete(options: ModelArgumentsDelete<M>): Promise<number>;
+    protected findAll(options: ModelArgumentsFindAll<M>): Promise<ModelResultFindAll<M>>;
+    protected findOne(options: ModelArgumentsFindOne<M>): Promise<M | null>;
+    sync(): Promise<void>;
+    protected update(options: ModelArgumentsUpdate<M>): Promise<boolean>;
+    name(): string;
+}
+
+declare class AuditsController extends ModelController<AuditModel> {
+    protected readonly model: typeof AuditModel;
+    protected readonly permissions: string[];
     protected all(ctx: Context, type: string, table: string): Promise<void>;
     protected get(ctx: Context): Promise<void>;
 }
 
-declare class AuthController extends ControllerBase {
+declare class AuthController extends BaseController<AuthEvents> {
+    protected readonly authService: AuthService;
+    constructor(authService: AuthService);
     protected login(ctx: Context, user_agent: string, username: string, password: string, remember: boolean, app: Application): Promise<void>;
-    protected logout(ctx: Context, auth: Auth, user: User, app: Application): Promise<void>;
+    protected logout(ctx: Context, auth: UserAuthModel, user: UserModel, app: Application): Promise<void>;
     protected renew(ctx: Context, user_agent: string, old: string, app: Application): Promise<void>;
-    protected user(ctx: Context, user: User): Promise<void>;
+    protected user(ctx: Context, user: UserModel): Promise<void>;
+}
+
+declare abstract class CrudController<M extends Model$1<any>, T extends TypeAnyObject = TypeAnyObject> extends ModelController<M, T> {
+    private _crud;
+    CrudArgumentscountAll(ctx: Context): ModelArgumentsUpdate<M>;
+    CrudArgumentsCreate(ctx: Context): ModelArgumentsUpdate<M>;
+    CrudArgumentsFindAll(ctx: Context): ModelArgumentsFindAll<M>;
+    CrudArgumentsFindOne(ctx: Context): ModelArgumentsFindOne<M>;
+    CrudArgumentsDelete(ctx: Context): ModelArgumentsDelete<M>;
+    CrudArgumentsUpdate(ctx: Context): ModelArgumentsUpdate<M>;
+    CrudValidationCreate(): TypeObject<ValidationBase>;
+    CrudValidationUpdate(): TypeObject<ValidationBase>;
+    protected add(ctx: Context): Promise<void>;
+    protected all(ctx: Context): Promise<void>;
+    protected number(ctx: Context): Promise<void>;
+    protected del(ctx: Context): Promise<void>;
+    protected get(ctx: Context): Promise<void>;
+    protected set(ctx: Context): Promise<void>;
+    protected validationCreate(ctx: Context): Promise<void>;
+    protected validationUpdate(ctx: Context): Promise<void>;
 }
 
-declare class FilesController extends ControllerBase {
-    protected [ControllerBase.PERMISSIONS]: Array<string>;
-    directory(): string;
+declare class FilesController extends BaseController {
+    protected readonly directory: string;
+    protected readonly permissions: Array<string>;
     protected files(ctx: Context): Promise<TypeAnyObject | void>;
-    protected access(ctx: Context, name: string, user: User): Promise<void>;
     private info;
     name(): string;
     sync(): Promise<void>;
 }
 
-declare class ForgotController extends ControllerBase {
+declare class ForgotController extends BaseController<ForgotEvents> {
     protected check(ctx: Context, token: string): Promise<void>;
     protected forgot(ctx: Context, username: string, app: Application): Promise<void>;
     protected reset(ctx: Context, token: string, password: string, app: Application): Promise<void>;
     private find;
 }
 
-declare class GroupsController extends ControllerCrud<Group> {
+declare class GroupsController extends CrudController<GroupModel> {
+    protected readonly model: typeof GroupModel;
     private schemaCreate;
     private schemaUpdate;
-    model(): typeof Group;
-    CrudArgumentsFindAll(ctx: Context): ArgumentsModelFindAll<Group>;
     CrudValidationCreate(): TypeObject<ValidationBase>;
     CrudValidationUpdate(): TypeObject<ValidationBase>;
 }
 
-declare class GroupsPermissionsController extends ControllerModel<GroupPermission> {
-    model(): typeof GroupPermission;
+declare class GroupsPermissionsController extends ModelController<GroupPermissionModel> {
+    protected readonly model: typeof GroupPermissionModel;
+    protected readonly permissions: never[];
     protected all(ctx: Context, group_id: string): Promise<void>;
-    protected me(ctx: Context, user: User): Promise<void>;
-    protected set(ctx: Context, id: string, permissions: Array<number>, audit: TypeAnyObject): Promise<void>;
+    protected set(ctx: Context, id: string, permissions: Array<string>): Promise<void>;
 }
 
-declare class LogsController extends ControllerModel<Log> {
-    protected [ControllerModel.PERMISSIONS]: Array<string>;
-    model(): typeof Log;
-    protected all(ctx: Context, type: string, source: string): Promise<void>;
+declare class LogsController extends ModelController<LogModel> {
+    protected readonly model: typeof LogModel;
+    protected readonly permissions: Array<string>;
+    protected all(ctx: Context): Promise<void>;
 }
 
-declare class PermissionsController extends ControllerCrud<Permission> {
+declare class PermissionsController extends CrudController<PermissionModel> {
+    protected readonly model: typeof PermissionModel;
     private schemaCreate;
     private schemaUpdate;
-    model(): typeof Permission;
-    CrudArgumentsFindAll(ctx: Context): ArgumentsModelFindAll<Permission>;
     CrudValidationCreate(): TypeObject<ValidationBase>;
     CrudValidationUpdate(): TypeObject<ValidationBase>;
 }
 
-declare class RegisterController extends ControllerBase {
+declare class RegisterController extends BaseController<RegisterEvents> {
     protected register(ctx: Context, body: TypeAnyObject, app: Application): Promise<void>;
     protected confirm(ctx: Context, token: string, app: Application): Promise<void>;
     protected send(ctx: Context, username: string, app: Application): Promise<void>;
     private getId;
 }
 
-declare class SetupController extends ControllerBase {
-    protected setup(ctx: Context, audit: TypeAnyObject): Promise<void>;
+declare class SetupController extends BaseController {
+    protected setup(ctx: Context): Promise<void>;
 }
 
-declare class UsersController extends ControllerModel<User> {
+declare class UsersController extends ModelController<UserModel> {
+    protected readonly model: typeof UserModel;
     path: string;
-    model(): typeof User;
     constructor();
-    protected avatar(ctx: Context, files: Array<IFile>, user: User, audit: TypeAnyObject): Promise<void>;
-    protected avatar_del(ctx: Context, user: User, audit: TypeAnyObject): Promise<void>;
-    protected password(ctx: Context, oldPassword: string, newPassword: string, user: User, audit: TypeAnyObject): Promise<void>;
-    protected token(ctx: Context, user: User, app: Application): Promise<void>;
-    protected token_del(ctx: Context, id: string, audit: TypeAnyObject): Promise<void>;
-    protected token_get(ctx: Context, id: string, app: Application): Promise<void>;
-    protected token_renew(ctx: Context, id: string, audit: TypeAnyObject, app: Application): Promise<void>;
+    protected avatar(ctx: Context, user: UserModel): Promise<void>;
     private token_new;
-    protected add(ctx: Context, password: string): Promise<void>;
+    protected add(ctx: Context): Promise<void>;
     protected all(ctx: Context): Promise<void>;
-    protected del(ctx: Context, id: string, user: User): Promise<void>;
+    protected number(ctx: Context): Promise<void>;
+    protected del(ctx: Context, id: string, user: UserModel): Promise<void>;
     protected get(ctx: Context): Promise<void>;
-    protected set(ctx: Context, id: string, password: string): Promise<void>;
+    protected set(ctx: Context): Promise<void>;
 }
 
-declare class UsersGroupsController extends ControllerModel<UserGroup> {
-    model(): typeof UserGroup;
+declare class UsersGroupsController extends ModelController<UserGroupModel> {
+    protected readonly model: typeof UserGroupModel;
+    protected readonly permissions: never[];
     protected all(ctx: Context, user_id: string): Promise<void>;
-    protected me(ctx: Context, user: User): Promise<void>;
-    protected set(ctx: Context, id: string, groups: Array<number>, audit: TypeAnyObject): Promise<void>;
+    protected set(ctx: Context, id: string, groups: Array<string>): Promise<void>;
 }
 
-declare const database: Sequelize;
+declare class UsersProfilesController extends ModelController<UserProfileModel> {
+    protected readonly model: typeof UserProfileModel;
+    protected readonly permissions: never[];
+    protected all(ctx: Context): Promise<void>;
+    protected get(ctx: Context, user_id: string): Promise<void>;
+    protected set(ctx: Context, id: string, body: TypeAnyObject): Promise<void>;
+}
 
-declare const ReqAudit: (key?: string) => ParameterDecorator;
+declare const sequelize: Sequelize;
 
-declare const ReqAuth: (key?: string) => ParameterDecorator;
+declare const CanCreate: (name?: string) => MethodDecorator;
 
-declare const ReqUser: (key?: string) => ParameterDecorator;
+declare const CanDelete: (name?: string) => MethodDecorator;
 
-declare global {
-    export namespace Express {
-        interface Request {
-            auth?: Auth;
-            user?: User;
-        }
-    }
-}
+declare const canFactory: (key: string) => (name?: string) => MethodDecorator;
 
-declare class AuthBase {
-    protected static error(error: any): void;
-}
+declare const CanRead: (name?: string) => MethodDecorator;
 
-declare class AuthKey extends AuthBase {
-    static user(key: string, app: Application): Promise<IAuthParameters>;
-}
+declare const CanUpdate: (name?: string) => MethodDecorator;
 
-declare class AuthToken extends AuthBase {
-    private static options;
-    static create(user: User): Promise<IAuthParameters>;
-    static destroy(auth?: Auth): Promise<boolean>;
-    static renew(token: string): Promise<IAuthParameters>;
-    static user(token: string): Promise<IAuthParameters>;
-    private static verify;
-}
+declare const HasGroups: (...groups: Array<string>) => MethodDecorator;
 
-declare const audit: (ctx: Context) => TypeAnyObject;
+declare const HasPermissions: (...permissions: Array<string>) => MethodDecorator;
 
-declare const hooks: {
-    afterCreate: (record: Model, options: TypeAnyObject) => Promise<void>;
-    afterUpdate: (record: Model, options: TypeAnyObject) => Promise<void>;
-    afterDestroy: (record: Model, options: TypeAnyObject) => Promise<void>;
-};
+declare const IsAuthenticated: () => MethodDecorator;
 
-declare const crt: {
-    http: Buffer<ArrayBufferLike> | undefined;
-    token: Buffer<ArrayBufferLike> | undefined;
-};
-declare const key: {
-    http: Buffer<ArrayBufferLike> | undefined;
-    token: Buffer<ArrayBufferLike> | undefined;
-};
+declare const ReqAuth: (key?: string) => ParameterDecorator;
 
-declare class Store extends Store$1 {
-    private loop;
-    constructor();
-    all: (callback: TypeAnyFunction) => Promise<void>;
-    clear: (callback: TypeAnyFunction) => Promise<void>;
-    destroy: (session_id: string, callback: TypeAnyFunction) => Promise<void>;
-    expired: () => Promise<void>;
-    get: (session_id: string, callback: TypeAnyFunction) => Promise<void>;
-    length: (callback: TypeAnyFunction) => Promise<void>;
-    set: (session_id: any, session: SessionData, callback: TypeAnyFunction) => Promise<void>;
+declare const ReqGroup: (key?: string) => ParameterDecorator;
+
+declare const ReqGroups: (key?: string) => ParameterDecorator;
+
+declare const ReqPermission: (key?: string) => ParameterDecorator;
+
+declare const ReqPermissions: (key?: string) => ParameterDecorator;
+
+declare const ReqUser: (key?: string) => ParameterDecorator;
+
+declare const Audit: (active?: boolean) => ClassDecorator;
+
+declare class Env extends Env$1 {
+    static readonly BASE_NAME: string;
+    static readonly CONSOLE_ERROR: boolean;
+    static readonly DATABASE_URI: string;
+    static readonly DATABASE_LOG: boolean;
+    static readonly DATABASE_AUDIT: boolean;
+    static readonly DATABASE_PREFIX: string;
+    static readonly DATABASE_TIMEZONE: string;
+    static readonly HTTP_CRT: Buffer<ArrayBufferLike> | null;
+    static readonly HTTP_KEY: Buffer<ArrayBufferLike> | null;
+    static readonly SLEEP_AUTH: number;
+    static readonly SLEEP_FORGOT: number;
+    static readonly SLEEP_REGISTRY: number;
+    static readonly TOKEN_CRT: Buffer<ArrayBufferLike> | null;
+    static readonly TOKEN_KEY: Buffer<ArrayBufferLike> | null;
+    static readonly TOKEN_TTL: number;
+    static readonly API_BODYPARSER_STRICT: boolean;
+    static readonly API_BODYPARSER_INFLATE: boolean;
+    static readonly API_BODYPARSER_LIMIT: string;
+    static readonly API_BODYPARSER_TYPE: string;
+    static readonly API_HTTP_PORT: number;
+    static readonly API_HTTP_PUBLIC: string;
+    static readonly API_HTTP_CROSS: boolean;
+    static readonly API_HTTP_HYBRID: boolean;
+    static readonly API_HTTP_NOTFOUND: string;
+    static readonly API_HTTP_PATH: string;
+    static readonly API_HTTP_REDIRECT: string;
+    static readonly API_KEY_HASH: string;
+    static readonly API_KEY_HEADER: string;
+    static readonly API_MODEL_LIMIT: number;
+    static readonly API_MODEL_LIMIT_MAX: number;
+    static readonly API_SESSION_NAME: string;
+    static readonly API_SESSION_LIFETIME: number;
+    static readonly API_SESSION_SECRET: string;
+    static readonly API_TOKEN_COOKIE: string;
+    static readonly API_TOKEN_COOKIE_SET: boolean;
+    static readonly API_TOKEN_FORGOT: number;
+    static readonly API_TOKEN_HEADER: string;
+    static readonly API_TOKEN_HEADER_KEY: string;
+    static readonly API_TOKEN_RENEW: number;
+    static readonly API_USER_HISTORY: boolean;
+    static readonly API_WEBSOCKET_START: boolean;
 }
 
-export { Application, Audit, AuditsController, Auth, AuthBase, AuthController, AuthKey, AuthToken, Config, Controller, ControllerBase, ControllerCrud, ControllerModel, Env, FilesController, Forgot, ForgotController, Group, GroupPermission, GroupsController, GroupsPermissionsController, Log, LogsController, Migration, Permission, PermissionsController, Register, RegisterController, ReqAudit, ReqAuth, ReqUser, Session, SetupController, Store, User, UserGroup, UserHistory, UsersController, UsersGroupsController, audit, crt, database, hooks, key };
-export type { ArgumentsModel, ArgumentsModelCreate, ArgumentsModelDelete, ArgumentsModelFindAll, ArgumentsModelFindOne, ArgumentsModelUpdate, CallbackModelAll, CallbackModelGet, IAuthParameters, ResultModelAll };
+export { Application, Audit, AuditModel, AuditsController, AuthController, AuthService, BaseController, CanCreate, CanDelete, CanRead, CanUpdate, Config, ConfigModel, CrudController, Env, FilesController, ForgotController, ForgotModel, GroupModel, GroupPermissionModel, GroupsController, GroupsPermissionsController, HasGroups, HasPermissions, IsAuthenticated, Log, LogModel, Loggable, LogsController, MigrationModel, ModelController, ModelService, PermissionModel, PermissionsController, RegisterController, RegisterModel, ReqAuth, ReqGroup, ReqGroups, ReqPermission, ReqPermissions, ReqUser, Service, SessionModel, SessionStore, SetupController, UserAuthModel, UserGroupModel, UserMetadataModel, UserModel, UserPasswordModel, UserProfileModel, UserService, UsersController, UsersGroupsController, UsersProfilesController, canFactory, sequelize };
+export type { ApplicationEvents, AuthEvents, ForgotEvents, IAuthParameters, ModelArgumentsBase, ModelArgumentsCount, ModelArgumentsCreate, ModelArgumentsDelete, ModelArgumentsFindAll, ModelArgumentsFindOne, ModelArgumentsUpdate, ModelCallbackFindAll, ModelCallbackFindOne, ModelOptions, ModelResultFindAll, RegisterEvents };