@radatek/microserver 2.3.10 → 3.0.1

package/microserver.d.ts

@@ -1,6 +1,6 @@
 /**
  * MicroServer
- * @version 2.3.10
+ * @version 3.0.0
  * @package @radatek/microserver
  * @copyright Darius Kisonas 2022
  * @license MIT
@@ -32,25 +32,31 @@ export declare class WebSocketError extends Error {
     statusCode: number;
     constructor(text?: string, code?: number);
 }
-export type Routes = () => Record<string, Array<any>> | Array<Array<any>>;
+type DeferPromise<T = void> = Promise<T> & {
+    resolve: (res?: T | Error) => void;
+};
+/** Middleware */
+export interface Middleware {
+    (req: ServerRequest, res: ServerResponse, next: Function): any;
+    /** @default 0 */
+    priority?: number;
+    plugin?: Plugin;
+}
 export declare abstract class Plugin {
     name?: string;
     priority?: number;
     handler?(req: ServerRequest, res: ServerResponse, next: Function): Promise<string | object | void> | string | object | void;
-    routes?(): Promise<Routes> | Routes;
-    initialise?(): Promise<void> | void;
-    constructor(router: Router, ...args: any);
+    routes?(): Promise<RoutesSet | void> | RoutesSet | void;
+    constructor();
 }
 interface PluginClass {
-    new (router: Router, ...args: any): Plugin;
+    new (options?: any, server?: MicroServer): Plugin;
 }
 export type ServerRequestBody<T = any> = T extends Model<infer U extends ModelSchema> ? ModelDocument<U> : Record<string, any>;
 /** Extended http.IncomingMessage */
 export declare class ServerRequest<T = any> extends http.IncomingMessage {
-    /** Request protocol: http or https */
-    protocol: string;
     /** Request client IP */
-    ip?: string;
+    ip: string;
     /** Request from local network */
     localip?: boolean;
     /** Request is secure (https) */
@@ -70,7 +76,7 @@ export declare class ServerRequest<T = any> extends http.IncomingMessage {
     /** Router named parameters list */
     paramsList: string[];
     /** Router */
-    router: Router;
+    server: MicroServer;
     /** Authentication object */
     auth?: Auth;
     /** Authenticated user info */
@@ -83,9 +89,14 @@ export declare class ServerRequest<T = any> extends http.IncomingMessage {
     rawBody: Buffer[];
     /** Request raw body size */
     rawBodySize: number;
+    _body?: ServerRequestBody<T>;
+    _isReady: DeferPromise | undefined;
     private constructor();
+    static extend(req: http.IncomingMessage, server: MicroServer): ServerRequest;
+    get isReady(): boolean;
+    waitReady(): Promise<void>;
     /** Update request url */
-    updateUrl(url: string): void;
+    updateUrl(url: string): this;
     /** Rewrite request url */
     rewrite(url: string): void;
     /** Request body: JSON or POST parameters */
@@ -95,17 +106,15 @@ export declare class ServerRequest<T = any> extends http.IncomingMessage {
     /** Get websocket */
     get websocket(): WebSocket;
     /** get files list in request */
-    files(): Promise<any[] | undefined>;
-    /** Decode request body */
-    bodyDecode(res: ServerResponse, options: any, next: () => void): void;
+    files(): Promise<UploadFile[] | undefined>;
 }
 /** Extends http.ServerResponse */
 export declare class ServerResponse<T = any> extends http.ServerResponse {
-    req: ServerRequest<T>;
-    router: Router;
+    readonly req: ServerRequest<T>;
     isJson: boolean;
     headersOnly: boolean;
     private constructor();
+    static extend(res: http.ServerResponse): void;
     /** Send error reponse */
     error(error: string | number | Error): void;
     /** Sets Content-Type acording to data and sends response */
@@ -118,179 +127,104 @@ export declare class ServerResponse<T = any> extends http.ServerResponse {
     jsonSuccess(data?: object | string): void;
     /** Send redirect response to specified URL with optional status code (default: 302) */
     redirect(code: number | string, url?: string): void;
+    /** Rewrite URL */
+    rewrite(url: string): void;
     /** Set status code */
     status(code: number): this;
-    file(path: string, filename?: string): void;
-}
-/** WebSocket options */
-export interface WebSocketOptions {
-    maxPayload?: number;
-    autoPong?: boolean;
-    permessageDeflate?: boolean;
-    maxWindowBits?: number;
-    timeout?: number;
-    deflate?: boolean;
-}
-/** WebSocket class */
-export declare class WebSocket extends EventEmitter {
-    ready: boolean;
-    constructor(req: ServerRequest, options?: WebSocketOptions);
-    /** Close connection */
-    close(reason?: number, data?: Buffer): void;
-    /** Generate WebSocket frame from data */
-    static getFrame(data: number | string | Buffer | undefined, options?: any): Buffer;
-    /** Send data */
-    send(data: string | Buffer): void;
-    /** Send ping frame */
-    ping(buffer?: Buffer): void;
-    /** Send pong frame */
-    pong(buffer?: Buffer): void;
-    protected _sendFrame(opcode: number, data: Buffer, cb?: () => void): void;
-}
-/**
- * Controller for dynamic routes
- *
- * @example
- * ```js
- * class MyController extends Controller {
- *   static model = MyModel;
- *   static acl = 'auth';
- *
- *   static 'acl:index' = '';
- *   static 'url:index' = 'GET /index';
- *   async index (req, res) {
- *     res.send('Hello World')
- *   }
- *
- *   //function name prefixes translated to HTTP methods:
- *   //  all => GET, get => GET, insert => POST, post => POST,
- *   //  update => PUT, put => PUT, delete => DELETE,
- *   //  modify => PATCH, patch => PATCH,
- *   //  websocket => internal WebSocket
- *   // automatic acl will be: class_name + '/' + function_name_prefix
- *   // automatic url will be: method + ' /' + class_name + '/' + function_name_without_prefix
- *
- *   //static 'acl:allUsers' = 'MyController/all';
- *   //static 'url:allUsers' = 'GET /MyController/Users';
- *   async allUsers () {
- *     return ['usr1', 'usr2', 'usr3']
- *   }
- *
- *   //static 'acl:getOrder' = 'MyController/get';
- *   //static 'url:getOrder' = 'GET /Users/:id/:id1';
- *   static 'group:getOrder' = 'orders';
- *   static 'model:getOrder' = OrderModel;
- *   async getOrder (id: string, id1: string) {
- *     return {id, extras: id1, type: 'order'}
- *   }
- *
- *   //static 'acl:insertOrder' = 'MyController/insert';
- *   //static 'url:insertOrder' = 'POST /Users/:id';
- *   static 'model:insertOrder' = OrderModel;
- *   async insertOrder (id: string, id1: string) {
- *     return {id, extras: id1, type: 'order'}
- *   }
- *
- *   static 'acl:POST /login' = '';
- *   async 'POST /login' () {
- *     return {id, extras: id1, type: 'order'}
- *   }
- * }
- * ```
-*/
-export declare class Controller<T extends Model<any> = any> {
-    req: ServerRequest<T>;
-    res: ServerResponse<T>;
-    get model(): T | undefined;
-    constructor(req: ServerRequest<T>, res: ServerResponse<T>);
-    /** Generate routes for this controller */
-    static routes(): any[];
-}
-/** Middleware */
-export interface Middleware {
-    (req: ServerRequest, res: ServerResponse, next: Function): any;
-    /** @default 0 */
-    priority?: number;
-    plugin?: Plugin;
+    /** Send file */
+    file(path: string | ServeFileOptions): void;
+}
+type RouteURL = `${Uppercase<string>} /${string}` | `/${string}`;
+type StringMiddleware = `response:json` | `response:html` | `response:end` | `redirect:${string}` | `error:${number}` | `param:${string}=${string}` | `acl:${string}` | `user:${string}` | `group:${string}` | `model:${string}` | `${string}=${string}`;
+type RoutesMiddleware = Middleware | Plugin | StringMiddleware | Promise<Middleware | Plugin>;
+type RoutesList = [RouteURL, ...Array<RoutesMiddleware>] | [RouteURL, ControllerClass | Promise<ControllerClass>];
+type RoutesSet = Array<RoutesList | ControllerClass | Promise<ControllerClass>> | Record<RouteURL, RoutesList | ControllerClass | Promise<ControllerClass> | Middleware>;
+export interface MicroServerConfig extends ListenConfig {
+    /** Auth options */
+    auth?: AuthOptions;
+    /** routes to add */
+    routes?: RoutesSet;
+    /** Static file options */
+    static?: StaticFilesOptions;
+    /** max body size (default: 5MB) */
+    body?: BodyOptions;
+    /** allowed HTTP methods */
+    methods?: string;
+    /** trust proxy */
+    trustproxy?: string[];
+    /** cors options */
+    cors?: string | CorsOptions | boolean;
+    /** upload dir */
+    upload?: UploadOptions;
+    /** websocket options */
+    websocket?: WebSocketOptions;
+    /** extra options for plugins */
+    [key: string]: any;
 }
-declare class Waiter {
-    isBusy(id?: string): boolean;
-    startJob(id?: string): void;
-    endJob(id?: string): void;
-    get nextId(): string;
-    wait(id?: string): Promise<void>;
+interface MicroServerEvents {
+    ready: () => void;
+    close: () => void;
+    listen: (port: number, address: string, server: http.Server) => void;
+    error: (err: Error) => void;
+    [key: `plugin:${string}`]: (plugin: Plugin) => void;
 }
-/** Router */
-export declare class Router extends EventEmitter {
-    server: MicroServer;
+/** Lighweight HTTP server */
+export declare class MicroServer extends EventEmitter {
+    config: MicroServerConfig;
     auth?: Auth;
-    plugins: Record<string, Plugin>;
-    _waiter: Waiter;
-    /** @param {MicroServer} server  */
-    constructor(server: MicroServer);
+    /** all sockets */
+    sockets: Set<net.Socket> | undefined;
+    /** server instances */
+    servers: Set<net.Server> | undefined;
+    /** @param {MicroServerConfig} [config] MicroServer configuration  */
+    constructor(config?: MicroServerConfig);
+    on<K extends keyof MicroServerEvents>(event: K, listener: MicroServerEvents[K]): this;
+    addListener<K extends keyof MicroServerEvents>(event: K, listener: MicroServerEvents[K]): this;
+    once<K extends keyof MicroServerEvents>(event: K, listener: MicroServerEvents[K]): this;
+    off<K extends keyof MicroServerEvents>(event: K, listener: MicroServerEvents[K]): this;
+    removeListener<K extends keyof MicroServerEvents>(event: K, listener: MicroServerEvents[K]): this;
+    get isReady(): boolean;
+    waitReady(): Promise<void>;
+    /** Listen server, should be used only if config.listen is not set */
+    listen(config: ListenConfig): Promise<void>;
     /** bind middleware or create one from string like: 'redirect:302,https://redirect.to', 'error:422', 'param:name=value', 'acl:users/get', 'model:User', 'group:Users', 'user:admin' */
-    bind(fn: string | Function | object): Function;
-    /** Handler */
-    handler(req: ServerRequest, res: ServerResponse, next: Function, method?: string): void;
+    _bind(fn: string | Function | object): Function;
+    /** Default server handler */
+    handler(req: ServerRequest, res: ServerResponse): void;
+    /** Last request handler */
+    handlerLast(req: ServerRequest, res: ServerResponse, next?: Function): any;
     /** Clear routes and middlewares */
     clear(): this;
     /**
      * Add middleware route.
      * Middlewares may return promises for res.jsonSuccess(...), throw errors for res.error(...), return string or {} for res.send(...)
-     *
-     * @signature add(plugin: Plugin)
-     * @param {Plugin} plugin plugin module instance
-     * @return {Promise<>}
-     *
-     * @signature add(pluginid: string, ...args: any)
-     * @param {string} pluginid pluginid module
-     * @param {...any} args arguments passed to constructor
-     * @return {Promise<>}
-     *
-     * @signature add(pluginClass: typeof Plugin, ...args: any)
-     * @param {typeof Plugin} pluginClass plugin class
-     * @param {...any} args arguments passed to constructor
-     * @return {Promise<>}
-     *
-     * @signature add(middleware: Middleware)
-     * @param {Middleware} middleware
-     * @return {Promise<>}
-     *
-     * @signature add(methodUrl: string, ...middlewares: any)
-     * @param {string} methodUrl 'METHOD /url' or '/url'
-     * @param {...any} middlewares
-     * @return {Promise<>}
-     *
-     * @signature add(methodUrl: string, controllerClass: typeof Controller)
-     * @param {string} methodUrl 'METHOD /url' or '/url'
-     * @param {typeof Controller} controllerClass
-     * @return {Promise<>}
-     *
-     * @signature add(methodUrl: string, routes: Array<Array<any>>)
-     * @param {string} methodUrl 'METHOD /url' or '/url'
-     * @param {Array<Array<any>>} routes list with subroutes: ['METHOD /suburl', ...middlewares]
-     * @return {Promise<>}
-     *
-     * @signature add(methodUrl: string, routes: Array<Array<any>>)
-     * @param {string} methodUrl 'METHOD /url' or '/url'
-     * @param {Array<Array<any>>} routes list with subroutes: ['METHOD /suburl', ...middlewares]
-     * @return {Promise<>}
-     *
-     * @signature add(routes: { [key: string]: Array<any> })
-     * @param { {[key: string]: Array<any>} } routes list with subroutes: 'METHOD /suburl': [...middlewares]
-     * @return {Promise<>}
-     *
-     * @signature add(methodUrl: string, routes: { [key: string]: Array<any> })
-     * @param {string} methodUrl 'METHOD /url' or '/url'
-     * @param { {[key: string]: Array<any>} } routes list with subroutes: 'METHOD /suburl': [...middlewares]
-     * @return {Promise<>}
+     * RouteURL: 'METHOD /suburl', 'METHOD', '* /suburl'
      */
-    use(...args: any): Promise<void>;
+    use(...args: [
+        Middleware | Plugin | ControllerClass | RoutesSet
+    ] | [Promise<Middleware | Plugin | ControllerClass | RoutesSet>] | RoutesList | [RouteURL, RoutesSet] | [PluginClass | Promise<PluginClass>, options?: any]): Promise<void>;
+    addStack(middleware: Middleware): void;
+    getPlugin(id: string): Plugin | undefined;
     waitPlugin(id: string): Promise<Plugin>;
-    /** Add hook */
-    hook(url: string, ...mid: Middleware[]): void;
+    /** Add route, alias to `server.router.use(url, ...args)` */
+    all(url: `/${string}`, ...args: RoutesMiddleware[]): MicroServer;
+    /** Add route, alias to `server.router.use('GET ' + url, ...args)` */
+    get(url: `/${string}`, ...args: RoutesMiddleware[]): MicroServer;
+    /** Add route, alias to `server.router.use('POST ' + url, ...args)` */
+    post(url: `/${string}`, ...args: RoutesMiddleware[]): MicroServer;
+    /** Add route, alias to `server.router.use('PUT ' + url, ...args)` */
+    put(url: `/${string}`, ...args: RoutesMiddleware[]): MicroServer;
+    /** Add route, alias to `server.router.use('PATCH ' + url, ...args)` */
+    patch(url: `/${string}`, ...args: RoutesMiddleware[]): MicroServer;
+    /** Add route, alias to `server.router.use('DELETE ' + url, ...args)` */
+    delete(url: `/${string}`, ...args: RoutesMiddleware[]): MicroServer;
+    /** Add websocket handler, alias to `server.router.use('WEBSOCKET ' + url, ...args)` */
+    websocket(url: `/${string}`, ...args: RoutesMiddleware[]): MicroServer;
+    /** Add router hook, alias to `server.router.hook(url, ...args)` */
+    hook(url: RouteURL, ...args: RoutesMiddleware[]): MicroServer;
     /** Check if middleware allready added */
     has(mid: Middleware): boolean;
+    close(): Promise<void>;
 }
 export interface HttpHandler {
     (req: ServerRequest, res: ServerResponse): void;
@@ -322,94 +256,120 @@ export interface CorsOptions {
     /** Max age */
     maxAge?: number;
 }
-/** MicroServer configuration */
-export interface MicroServerConfig extends ListenConfig {
-    /** server instance root path */
-    root?: string;
-    /** Auth options */
-    auth?: AuthOptions;
-    /** routes to add */
-    routes?: any;
-    /** Static file options */
-    static?: StaticOptions;
-    /** max body size (default: 5MB) */
+export declare class CorsPlugin extends Plugin {
+    priority: number;
+    name: string;
+    options?: CorsOptions;
+    constructor(options?: CorsOptions | string | true);
+    handler?(req: ServerRequest, res: ServerResponse, next: Function): Promise<string | object | void> | string | object | void;
+}
+export declare class MethodsPlugin extends Plugin {
+    priority: number;
+    name: string;
+    _methods: string;
+    _methodsIdx: Record<string, boolean>;
+    constructor(methods?: string);
+    handler(req: ServerRequest, res: ServerResponse, next: Function): any;
+}
+export interface BodyOptions {
     maxBodySize?: number;
-    /** allowed HTTP methods */
-    methods?: string;
-    /** trust proxy */
-    trustProxy?: string[];
-    /** cors options */
-    cors?: string | CorsOptions | boolean;
-    /** upload dir (default: './upload') */
+}
+export declare class BodyPlugin extends Plugin {
+    priority: number;
+    name: string;
+    _maxBodySize: number;
+    constructor(options?: BodyOptions);
+    handler(req: ServerRequest, res: ServerResponse, next: () => void): void;
+}
+export interface UploadOptions {
     uploadDir?: string;
-    /** allow websocket deflate compression (default: false) */
-    websocketCompress?: boolean;
+    maxFileSize?: number;
+}
+export interface UploadFile {
+    name: string;
+    fileName?: string;
+    contentType?: string;
+    size: number;
+    filePath?: string;
+}
+export declare class UploadPlugin extends Plugin {
+    priority: number;
+    name: string;
+    _maxFileSize: number;
+    _uploadDir?: string;
+    constructor(options?: UploadOptions);
+    handler(req: ServerRequest, res: ServerResponse, next: () => void): void;
+}
+/** WebSocket options */
+export interface WebSocketOptions {
     /** max websocket payload (default: 1MB) */
-    websocketMaxPayload?: number;
-    /** websocket max window bits 8-15 for deflate (default: 10) */
-    websocketMaxWindowBits?: number;
-    /** extra options for plugins */
-    [key: string]: any;
+    maxPayload?: number;
+    /** automatically send pong frame (default: true) */
+    autoPong?: boolean;
+    /** allow websocket per message deflate compression (default: false) */
+    permessageDeflate?: boolean;
+    /** websocket deflate compression max window bits 8-15 for deflate (default: 10) */
+    maxWindowBits?: number;
+    /** timeout for idle websocket connection (default: 120s) */
+    timeout?: number;
+    /** allow websocket deflate compression (default: false) */
+    deflate?: boolean;
 }
-export declare class MicroServer extends EventEmitter {
-    /** server configuration */
-    config: MicroServerConfig;
-    /** main router */
-    router: Router;
-    /** virtual host routers */
-    vhosts?: {
-        [key: string]: Router;
-    };
-    /** all sockets */
-    sockets: Set<net.Socket>;
-    /** server instances */
-    servers: Set<net.Server>;
-    _waiter: Waiter;
-    static plugins: {
-        [key: string]: PluginClass;
-    };
-    constructor(config: MicroServerConfig);
-    /** Add one time listener or call immediatelly for 'ready' */
-    once(name: string, cb: Function): this;
-    /** Add listener and call immediatelly for 'ready'  */
-    on(name: string, cb: Function): this;
-    get isReady(): boolean;
-    waitReady(): Promise<void>;
-    waitPlugin(id: string): Promise<void>;
-    /** Listen server, should be used only if config.listen is not set */
-    listen(config?: ListenConfig): Promise<void>;
-    /** Add middleware, routes, etc.. see {router.use} */
-    use(...args: any): Promise<void>;
-    /** Default server handler */
-    handler(req: ServerRequest, res: ServerResponse): void;
-    protected requestInit(req: ServerRequest, res?: ServerResponse): void;
-    /** Preprocess request, used by {MicroServer.handler} */
-    handlerInit(req: ServerRequest, res: ServerResponse, next: Function): void;
-    /** Last request handler */
-    handlerLast(req: ServerRequest, res: ServerResponse, next?: Function): any;
-    /** Default upgrade handler, used for WebSockets */
-    handlerUpgrade(req: ServerRequest, socket: net.Socket, head: any): void;
-    /** Close server instance */
-    close(): Promise<void>;
-    /** Add route, alias to `server.router.use(url, ...args)` */
-    all(url: string, ...args: any): MicroServer;
-    /** Add route, alias to `server.router.use('GET ' + url, ...args)` */
-    get(url: string, ...args: any): MicroServer;
-    /** Add route, alias to `server.router.use('POST ' + url, ...args)` */
-    post(url: string, ...args: any): MicroServer;
-    /** Add route, alias to `server.router.use('PUT ' + url, ...args)` */
-    put(url: string, ...args: any): MicroServer;
-    /** Add route, alias to `server.router.use('PATCH ' + url, ...args)` */
-    patch(url: string, ...args: any): MicroServer;
-    /** Add route, alias to `server.router.use('DELETE ' + url, ...args)` */
-    delete(url: string, ...args: any): MicroServer;
-    /** Add websocket handler, alias to `server.router.use('WEBSOCKET ' + url, ...args)` */
-    websocket(url: string, ...args: any): MicroServer;
-    /** Add router hook, alias to `server.router.hook(url, ...args)` */
-    hook(url: string, ...args: any): MicroServer;
+interface WebSocketEvents {
+    close: (code: number, reason: string) => void;
+    end: () => void;
+    error: (error: Error) => void;
+    ping: (data: Buffer) => void;
+    pong: (data: Buffer) => void;
+    message: (data: string | Buffer | ArrayBuffer | Blob) => void;
+    open: () => void;
+}
+/** WebSocket class */
+export declare class WebSocket extends EventEmitter {
+    ready: boolean;
+    constructor(req: ServerRequest, options?: WebSocketOptions);
+    /** Close connection */
+    close(reason?: number, data?: Buffer): void;
+    /** Generate WebSocket frame from data */
+    static getFrame(data: number | string | Buffer | undefined, options?: any): Buffer;
+    /** Send data */
+    send(data: string | Buffer): void;
+    /** Send ping frame */
+    ping(buffer?: Buffer): void;
+    /** Send pong frame */
+    pong(buffer?: Buffer): void;
+    protected _sendFrame(opcode: number, data: Buffer, cb?: () => void): void;
+    on<K extends keyof WebSocketEvents>(event: K, listener: WebSocketEvents[K]): this;
+    addListener<K extends keyof WebSocketEvents>(event: K, listener: WebSocketEvents[K]): this;
+    once<K extends keyof WebSocketEvents>(event: K, listener: WebSocketEvents[K]): this;
+    off<K extends keyof WebSocketEvents>(event: K, listener: WebSocketEvents[K]): this;
+    removeListener<K extends keyof WebSocketEvents>(event: K, listener: WebSocketEvents[K]): this;
+}
+export declare class WebSocketPlugin extends Plugin {
+    name: string;
+    _handler: (req: ServerRequest, socket: net.Socket, head: any) => void;
+    constructor(options?: any, server?: MicroServer);
+    addUpgradeHandler(srv: http.Server): void;
+    upgradeHandler(server: MicroServer, req: ServerRequest, socket: net.Socket, head: any): void;
+    static create(req: ServerRequest, options?: WebSocketOptions): WebSocket;
+}
+/** Trust proxy plugin, adds `req.ip` and `req.localip` */
+export declare class TrustProxyPlugin extends Plugin {
+    priority: number;
+    name: string;
+    constructor(options?: string[]);
+    isLocal(ip: string): boolean;
+    handler(req: ServerRequest, res: ServerResponse, next: Function): void;
+}
+/** Virtual host plugin */
+export declare class VHostPlugin extends Plugin {
+    priority: number;
+    vhosts?: Record<string, MicroServer>;
+    constructor(options: Record<string, RoutesSet | MicroServer>, server?: MicroServer);
+    handler?(req: ServerRequest, res: ServerResponse, next: Function): void;
 }
 /** Static files options */
-export interface StaticOptions {
+export interface StaticFilesOptions {
     /** files root directory */
     root?: string;
     /** url path */
@@ -439,7 +399,7 @@ export interface ServeFileOptions {
     /** root */
     root?: string;
     /** file name */
-    filename?: string;
+    filename?: string | true;
     /** file mime type */
     mimeType?: string;
     /** last modified date */
@@ -453,8 +413,45 @@ export interface ServeFileOptions {
     /** stat */
     stats?: fs.Stats;
 }
+/**
+ * Static files middleware plugin
+ * Usage: server.use('static', '/public')
+ * Usage: server.use('static', { root: 'public', path: '/static' })
+ */
+export declare class StaticFilesPlugin extends Plugin {
+    priority: number;
+    /** Default mime types */
+    static mimeTypes: {
+        [key: string]: string;
+    };
+    /** Custom mime types */
+    mimeTypes: {
+        [key: string]: string;
+    };
+    /** File extension handlers */
+    handlers?: {
+        [key: string]: Middleware;
+    };
+    /** Files root directory */
+    root: string;
+    /** Ignore prefixes */
+    ignore: string[];
+    /** Index file. default: 'index.html' */
+    index: string;
+    /** Update Last-Modified header. default: true */
+    lastModified: boolean;
+    /** Update ETag header. default: true */
+    etag: boolean;
+    /** Max file age in seconds (default: 31536000) */
+    maxAge?: number;
+    prefix: string;
+    constructor(options?: StaticFilesOptions | string, server?: MicroServer);
+    /** Default static files handler */
+    handler(req: ServerRequest, res: ServerResponse, next: Function): any;
+    serveFile(req: ServerRequest, res: ServerResponse, options: ServeFileOptions): void;
+}
 /** Proxy plugin options */
-export interface ProxyPluginOptions {
+export interface ProxyOptions {
     /** Base path */
     path?: string;
     /** Remote url */
@@ -471,6 +468,8 @@ export interface ProxyPluginOptions {
     };
 }
 export declare class ProxyPlugin extends Plugin {
+    priority: number;
+    name: string;
     /** Default valid headers */
     static validHeaders: {
         [key: string]: boolean;
@@ -487,7 +486,7 @@ export declare class ProxyPlugin extends Plugin {
     remoteUrl: URL;
     /** Match regex filter */
     regex?: RegExp;
-    constructor(router: Router, options?: ProxyPluginOptions | string);
+    constructor(options?: ProxyOptions | string, server?: MicroServer);
     /** Default proxy handler */
     proxyHandler(req: ServerRequest, res: ServerResponse, next: Function): any;
     /** Proxy plugin handler as middleware */
@@ -618,8 +617,80 @@ export declare class Auth {
     /** Clear user cache if users setting where changed */
     clearCache(): void;
 }
-/** Create microserver */
-export declare function create(config: MicroServerConfig): MicroServer;
+/** Authentication plugin */
+export declare class AuthPlugin extends Plugin {
+    priority: number;
+    name: string;
+    options: AuthOptions;
+    constructor(options?: AuthOptions, server?: MicroServer);
+    /** Authentication middleware */
+    handler(req: ServerRequest, res: ServerResponse, next: Function): Promise<any>;
+}
+export declare class StandardPlugins extends Plugin {
+    constructor(options?: any, server?: MicroServer);
+}
+interface ControllerClass {
+    new (req: ServerRequest<any>, res: ServerResponse<any>): Controller<any>;
+}
+/**
+ * Controller for dynamic routes
+ *
+ * @example
+ * ```js
+ * class MyController extends Controller {
+ *   static model = MyModel;
+ *   static acl = 'auth';
+ *
+ *   static 'acl:index' = '';
+ *   static 'url:index' = 'GET /index';
+ *   async index (req, res) {
+ *     res.send('Hello World')
+ *   }
+ *
+ *   //function name prefixes translated to HTTP methods:
+ *   //  all => GET, get => GET, insert => POST, post => POST,
+ *   //  update => PUT, put => PUT, delete => DELETE,
+ *   //  modify => PATCH, patch => PATCH,
+ *   //  websocket => internal WebSocket
+ *   // automatic acl will be: class_name + '/' + function_name_prefix
+ *   // automatic url will be: method + ' /' + class_name + '/' + function_name_without_prefix
+ *
+ *   //static 'acl:allUsers' = 'MyController/all';
+ *   //static 'url:allUsers' = 'GET /MyController/Users';
+ *   async allUsers () {
+ *     return ['usr1', 'usr2', 'usr3']
+ *   }
+ *
+ *   //static 'acl:getOrder' = 'MyController/get';
+ *   //static 'url:getOrder' = 'GET /Users/:id/:id1';
+ *   static 'group:getOrder' = 'orders';
+ *   static 'model:getOrder' = OrderModel;
+ *   async getOrder (id: string, id1: string) {
+ *     return {id, extras: id1, type: 'order'}
+ *   }
+ *
+ *   //static 'acl:insertOrder' = 'MyController/insert';
+ *   //static 'url:insertOrder' = 'POST /Users/:id';
+ *   static 'model:insertOrder' = OrderModel;
+ *   async insertOrder (id: string, id1: string) {
+ *     return {id, extras: id1, type: 'order'}
+ *   }
+ *
+ *   static 'acl:POST /login' = '';
+ *   async 'POST /login' () {
+ *     return {id, extras: id1, type: 'order'}
+ *   }
+ * }
+ * ```
+*/
+export declare class Controller<T extends Model<any> = any> {
+    req: ServerRequest<T>;
+    res: ServerResponse<T>;
+    get model(): T | undefined;
+    constructor(req: ServerRequest<T>, res: ServerResponse<T>);
+    /** Generate routes for this controller */
+    static routes(): any[];
+}
 export interface FileStoreOptions {
     /** Base directory */
     dir?: string;