@jwn-js/common 2.0.20 → 2.0.21

package/index.d.ts

@@ -5,943 +5,942 @@ import * as uWebSockets_js from 'uWebSockets.js';
 import { RecognizedString, HttpResponse, HttpRequest, WebSocketBehavior, AppOptions, TemplatedApp } from 'uWebSockets.js';
 import { Client } from 'memjs';
 import { Query } from 'buildmsql';
-import * as __ from '..';
 export { Context as ContextSsr } from 'vite-ssr-vue';
 
-/**
- * Input params of error
- */
-interface ApiErrorMessage {
-    message?: string;
-    code?: number;
-    statusCode?: number;
-    data?: Record<string, unknown>;
-    headers?: Record<string, string>;
-}
-/**
- * @class Api Error
- * @description Base error class for @jwn-js
- */
-declare class ApiError extends Error {
-    statusCode: number;
-    code: number;
-    data: Record<string, unknown>;
-    headers: Record<string, string>;
-    /**
-     * @constructor
-     * @param message
-     * @param code
-     * @param statusCode
-     */
-    constructor(message?: string, code?: number, statusCode?: number);
-    constructor(params: ApiErrorMessage | string, code?: number, statusCode?: number);
-    /**
-     * Get error message
-     */
-    getMessage(): string;
-    /**
-     * Get internal status code
-     */
-    getStatusCode(): number;
-    /**
-     * Get internal error code
-     */
-    getCode(): number;
-    /**
-     * Get error data
-     */
-    getData(): Record<string, unknown>;
-    /**
-     * Get error headers
-     */
-    getHeaders(): Record<string, string>;
+/**
+ * Input params of error
+ */
+interface ApiErrorMessage {
+    message?: string;
+    code?: number;
+    statusCode?: number;
+    data?: Record<string, unknown>;
+    headers?: Record<string, string>;
+}
+/**
+ * @class Api Error
+ * @description Base error class for @jwn-js
+ */
+declare class ApiError extends Error {
+    statusCode: number;
+    code: number;
+    data: Record<string, unknown>;
+    headers: Record<string, string>;
+    /**
+     * @constructor
+     * @param message
+     * @param code
+     * @param statusCode
+     */
+    constructor(message?: string, code?: number, statusCode?: number);
+    constructor(params: ApiErrorMessage | string, code?: number, statusCode?: number);
+    /**
+     * Get error message
+     */
+    getMessage(): string;
+    /**
+     * Get internal status code
+     */
+    getStatusCode(): number;
+    /**
+     * Get internal error code
+     */
+    getCode(): number;
+    /**
+     * Get error data
+     */
+    getData(): Record<string, unknown>;
+    /**
+     * Get error headers
+     */
+    getHeaders(): Record<string, string>;
 }
 
-declare module 'uWebSockets.js' {
-    interface HttpRequest {
-        cookies: Record<string, any>;
-    }
-}
-interface Handler {
-    method?: 'any' | 'connect' | 'del' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
-    pattern?: RecognizedString;
-    handler: (res: HttpResponse, req: HttpRequest, next: CallableFunction) => void | Promise<void | boolean | Error | string>;
-}
-interface WebSocket {
-    method: 'ws';
-    pattern?: RecognizedString;
-    behavior: WebSocketBehavior;
-}
-declare type Routes = Array<Handler | WebSocket | CallableFunction>;
-interface Options {
-    routes: Routes;
-    host?: string;
-    port?: number;
-    timeout?: number;
-    mode?: "development" | "production";
-    appOptions?: AppOptions;
-    logLevel?: "info" | "warn" | "error" | "silent";
-}
-/**
- * Status code to string
- */
-declare const codeToStatus: (code: number) => any;
-/**
- * Create server
- */
-declare class Server {
-    private _logLevel;
-    /**
-     * Listen socket
-     * @private
-     */
-    private _socket;
-    /**
-     * Request timeout
-     * @private
-     */
-    private readonly _timeout;
-    private readonly _routes;
-    private _host;
-    private _port;
-    private readonly _mode;
-    private readonly _appOptions;
-    private _app;
-    private _protocol;
-    /**
-     *Timeout identification
-     * @private
-     */
-    private _timeoutId;
-    /**
-     * Default route options
-     * @private
-     */
-    private _defaultRoute;
-    /**
-     * @constructor
-     * @param options
-     */
-    constructor(options: Options);
-    /**
-     * Get TemplatedApp instance
-     */
-    getApp(): TemplatedApp;
-    /**
-     * Create app (server http)
-     * @returns this
-     */
-    app(): this;
-    /**
-     * Create sslApp
-     * @returns this
-     */
-    sslApp(): this;
-    /**
-     * Push route
-     * @param route
-     * @returns this
-     */
-    push(route: Handler | WebSocket | CallableFunction): this;
-    /**
-     * unshift route
-     * @param route
-     * @returns this
-     */
-    unshift(route: Handler | WebSocket | CallableFunction): this;
-    /**
-     * Create server listener
-     * @param host - host or port
-     * @param port
-     * @param fn
-     * @returns this
-     */
-    listen(host: string, port: number, fn?: CallableFunction): this;
-    listen(port: number, fn?: CallableFunction): this;
-    listen(fn?: CallableFunction): this;
-    /**
-     * Closes a uSockets listen socket.
-     */
-    close(): Promise<this>;
-    /**
-     * Return socket port
-     */
-    socketPort(): Promise<number>;
-    /**
-     * Create decoration of handler
-     * @param res http response
-     * @param req http request
-     * @param fn handler
-     * @private
-     */
-    private _createHandler;
-    /**
-     * Redirect request
-     * @param res
-     * @param req
-     * @param url string of url
-     * @param code redirect status code
-     * @private
-     */
-    private static _redirect;
-    /**
-     * Abort request by timeout
-     * @private
-     */
-    private _abortTimeout;
-    /**
-     * lookup for host
-     * @param host
-     * @param resolve
-     * @private
-     */
-    private _lookup;
+declare module 'uWebSockets.js' {
+    interface HttpRequest {
+        cookies: Record<string, any>;
+    }
+}
+interface Handler {
+    method?: 'any' | 'connect' | 'del' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
+    pattern?: RecognizedString;
+    handler: (res: HttpResponse, req: HttpRequest, next: CallableFunction) => void | Promise<void | boolean | Error | string>;
+}
+interface WebSocket {
+    method: 'ws';
+    pattern?: RecognizedString;
+    behavior: WebSocketBehavior;
+}
+declare type Routes = Array<Handler | WebSocket | CallableFunction>;
+interface Options {
+    routes: Routes;
+    host?: string;
+    port?: number;
+    timeout?: number;
+    mode?: "development" | "production";
+    appOptions?: AppOptions;
+    logLevel?: "info" | "warn" | "error" | "silent";
+}
+/**
+ * Status code to string
+ */
+declare const codeToStatus: (code: number) => any;
+/**
+ * Create server
+ */
+declare class Server {
+    private _logLevel;
+    /**
+     * Listen socket
+     * @private
+     */
+    private _socket;
+    /**
+     * Request timeout
+     * @private
+     */
+    private readonly _timeout;
+    private readonly _routes;
+    private _host;
+    private _port;
+    private readonly _mode;
+    private readonly _appOptions;
+    private _app;
+    private _protocol;
+    /**
+     *Timeout identification
+     * @private
+     */
+    private _timeoutId;
+    /**
+     * Default route options
+     * @private
+     */
+    private _defaultRoute;
+    /**
+     * @constructor
+     * @param options
+     */
+    constructor(options: Options);
+    /**
+     * Get TemplatedApp instance
+     */
+    getApp(): TemplatedApp;
+    /**
+     * Create app (server http)
+     * @returns this
+     */
+    app(): this;
+    /**
+     * Create sslApp
+     * @returns this
+     */
+    sslApp(): this;
+    /**
+     * Push route
+     * @param route
+     * @returns this
+     */
+    push(route: Handler | WebSocket | CallableFunction): this;
+    /**
+     * unshift route
+     * @param route
+     * @returns this
+     */
+    unshift(route: Handler | WebSocket | CallableFunction): this;
+    /**
+     * Create server listener
+     * @param host - host or port
+     * @param port
+     * @param fn
+     * @returns this
+     */
+    listen(host: string, port: number, fn?: CallableFunction): this;
+    listen(port: number, fn?: CallableFunction): this;
+    listen(fn?: CallableFunction): this;
+    /**
+     * Closes a uSockets listen socket.
+     */
+    close(): Promise<this>;
+    /**
+     * Return socket port
+     */
+    socketPort(): Promise<number>;
+    /**
+     * Create decoration of handler
+     * @param res http response
+     * @param req http request
+     * @param fn handler
+     * @private
+     */
+    private _createHandler;
+    /**
+     * Redirect request
+     * @param res
+     * @param req
+     * @param url string of url
+     * @param code redirect status code
+     * @private
+     */
+    private static _redirect;
+    /**
+     * Abort request by timeout
+     * @private
+     */
+    private _abortTimeout;
+    /**
+     * lookup for host
+     * @param host
+     * @param resolve
+     * @private
+     */
+    private _lookup;
 }
 
-/**
- * @class Jwt
- * @description working with jwt tokens
- */
-declare class Jwt {
-    private readonly secret;
-    private readonly algorithm;
-    /**
-     * @constructor
-     * @param secret
-     * @param opt addition options
-     */
-    constructor(secret: string, opt?: {
-        algorithm: string;
-    });
-    /**
-     * Verify jwt token
-     * @param jwt token
-     * @returns is token valid
-     */
-    verify(jwt: string): boolean;
-    /**
-     * Get token
-     * @param data - user data
-     * @returns jwt
-     */
-    sign(data: any): string;
-    /**
-     * Decode token
-     * @param jwt - jwt token
-     * @returns {head, body}
-     */
-    decode(jwt: string): {
-        head: any;
-        body: any;
-    };
+/**
+ * @class Jwt
+ * @description working with jwt tokens
+ */
+declare class Jwt {
+    private readonly secret;
+    private readonly algorithm;
+    /**
+     * @constructor
+     * @param secret
+     * @param opt addition options
+     */
+    constructor(secret: string, opt?: {
+        algorithm: string;
+    });
+    /**
+     * Verify jwt token
+     * @param jwt token
+     * @returns is token valid
+     */
+    verify(jwt: string): boolean;
+    /**
+     * Get token
+     * @param data - user data
+     * @returns jwt
+     */
+    sign(data: any): string;
+    /**
+     * Decode token
+     * @param jwt - jwt token
+     * @returns {head, body}
+     */
+    decode(jwt: string): {
+        head: any;
+        body: any;
+    };
 }
 
-/**
- * @class Jwt
- * @description working with jwt tokens use webcrypto
- */
-declare class AsyncJwt {
-    private readonly secret;
-    private readonly algorithm;
-    /**
-     * @constructor
-     * @param secret
-     * @param opt addition options
-     */
-    constructor(secret: string, opt?: {
-        algorithm: string;
-    });
-    /**
-     * Verify jwt token
-     * @param jwt token
-     * @returns is token valid
-     */
-    verify(jwt: string): Promise<boolean>;
-    /**
-     * Get token
-     * @param data - user data
-     * @returns jwt
-     */
-    sign(data: any): Promise<string>;
-    /**
-     * Decode token
-     * @param jwt - jwt token
-     * @returns {head, body}
-     */
-    decode(jwt: string): {
-        head: any;
-        body: any;
-    };
-    /**
-     * Sign
-     * @param str input string
-     * @returns base64 sign
-     * @private
-     */
-    private signString;
+/**
+ * @class Jwt
+ * @description working with jwt tokens use webcrypto
+ */
+declare class AsyncJwt {
+    private readonly secret;
+    private readonly algorithm;
+    /**
+     * @constructor
+     * @param secret
+     * @param opt addition options
+     */
+    constructor(secret: string, opt?: {
+        algorithm: string;
+    });
+    /**
+     * Verify jwt token
+     * @param jwt token
+     * @returns is token valid
+     */
+    verify(jwt: string): Promise<boolean>;
+    /**
+     * Get token
+     * @param data - user data
+     * @returns jwt
+     */
+    sign(data: any): Promise<string>;
+    /**
+     * Decode token
+     * @param jwt - jwt token
+     * @returns {head, body}
+     */
+    decode(jwt: string): {
+        head: any;
+        body: any;
+    };
+    /**
+     * Sign
+     * @param str input string
+     * @returns base64 sign
+     * @private
+     */
+    private signString;
 }
 
-declare class Memcached {
-    memjs: Client | null;
-    specialHeaders: Record<string, any>;
-    maxKeyLength: number;
-    debug: number;
-    prefix: string;
-    /**
-     * @constructor
-     * @param memjs - memjs Client instance
-     * @param specialHeaders - special headers
-     * @param maxKeyLength - max key length
-     * @param debug
-     */
-    constructor(memjs: Client | null, specialHeaders?: {
-        'x-cache': string;
-    }, maxKeyLength?: number, debug?: number);
-    /**
-     * Is Client exists
-     */
-    isClient(): boolean;
-    /**
-     * Is in client is one or more conected servers
-     */
-    isConnectedServers(): boolean;
-    /**
-     * Set value to memcache
-     * @param key string key
-     * @param value value
-     * @param expires expiers in second
-     */
-    setValue(key: string, value: string | Buffer, expires: number | undefined | null): Promise<void>;
-    /**
-     * Get value from memory
-     * @param key string key
-     */
-    getValue(key: string): Promise<null | Buffer>;
-    /**
-     * Delete value
-     * @param key
-     */
-    deleteValue(key: string): Promise<boolean>;
-    /**
-     * Set page to cache
-     * @param url https://yur.site.net
-     * @param headers
-     * @param data eny data string or Buffer
-     * @param expires
-     */
-    setPage(url: string, headers: Record<string, any>, data: string | Buffer, expires: number | undefined | null): Promise<void>;
-    /**
-     * Get Page and headers
-     * @param url https://your.site.net
-     * @returns {data, headers}
-     */
-    getPage(url: string): Promise<null | {
-        data: Buffer;
-        headers: Record<string, any>;
-    }>;
-    /**
-     * Keys to lower case in Object
-     * @param o
-     * @private
-     */
-    private objectKeysToLower;
+declare class Memcached {
+    memjs: Client | null;
+    specialHeaders: Record<string, any>;
+    maxKeyLength: number;
+    debug: number;
+    prefix: string;
+    /**
+     * @constructor
+     * @param memjs - memjs Client instance
+     * @param specialHeaders - special headers
+     * @param maxKeyLength - max key length
+     * @param debug
+     */
+    constructor(memjs: Client | null, specialHeaders?: {
+        'x-cache': string;
+    }, maxKeyLength?: number, debug?: number);
+    /**
+     * Is Client exists
+     */
+    isClient(): boolean;
+    /**
+     * Is in client is one or more conected servers
+     */
+    isConnectedServers(): boolean;
+    /**
+     * Set value to memcache
+     * @param key string key
+     * @param value value
+     * @param expires expiers in second
+     */
+    setValue(key: string, value: string | Buffer, expires: number | undefined | null): Promise<void>;
+    /**
+     * Get value from memory
+     * @param key string key
+     */
+    getValue(key: string): Promise<null | Buffer>;
+    /**
+     * Delete value
+     * @param key
+     */
+    deleteValue(key: string): Promise<boolean>;
+    /**
+     * Set page to cache
+     * @param url https://yur.site.net
+     * @param headers
+     * @param data eny data string or Buffer
+     * @param expires
+     */
+    setPage(url: string, headers: Record<string, any>, data: string | Buffer, expires: number | undefined | null): Promise<void>;
+    /**
+     * Get Page and headers
+     * @param url https://your.site.net
+     * @returns {data, headers}
+     */
+    getPage(url: string): Promise<null | {
+        data: Buffer;
+        headers: Record<string, any>;
+    }>;
+    /**
+     * Keys to lower case in Object
+     * @param o
+     * @private
+     */
+    private objectKeysToLower;
 }
 
-/**
- * Reed static files
- * @param req
- * @param res
- * @param base
- */
+/**
+ * Reed static files
+ * @param req
+ * @param res
+ * @param base
+ */
 declare function staticBody(res: HttpResponse, req: HttpRequest, base: string): Promise<void>;
 
-interface OptionsSsr {
-    readonly manifest: Record<string, any>;
-    readonly memcached?: Memcached;
-    readonly [key: string]: any;
-}
-declare type EntryFunction = (url: string, opt: Record<string, any>) => Promise<any>;
-
-/**
- * Ssr handler for production
- */
-declare class Ssr {
-    res: HttpResponse;
-    req: HttpRequest;
-    context: OptionsSsr;
-    entry: EntryFunction | any;
-    /**
-     * @constructor
-     * @param res response
-     * @param req request
-     * @param context params
-     * @param entry - entry point function
-     */
-    constructor(res: HttpResponse, req: HttpRequest, context: OptionsSsr, entry: EntryFunction | any);
-    /**
-     * @param request addition request params
-     */
-    request(request?: Record<string, any>): Promise<void>;
+interface OptionsSsr {
+    readonly manifest: Record<string, any>;
+    readonly memcached?: Memcached;
+    readonly [key: string]: any;
 }
+declare type EntryFunction = (url: string, opt: Record<string, any>) => Promise<any>;
 
-declare type method$2 = 'any' | 'connect' | 'del' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
-declare module "uWebSockets.js" {
-    interface HttpRequest {
-        cookies: Record<string, any>;
-    }
-}
-interface Route$1 {
-    name: string;
-    method?: method$2 | Array<method$2>;
-    component: any;
-}
-interface Config$1 {
-    server: Record<string, any>;
-    db: Record<string, any>;
-    [key: string]: any;
+/**
+ * Ssr handler for production
+ */
+declare class Ssr {
+    res: HttpResponse;
+    req: HttpRequest;
+    context: OptionsSsr;
+    entry: EntryFunction | any;
+    /**
+     * @constructor
+     * @param res response
+     * @param req request
+     * @param context params
+     * @param entry - entry point function
+     */
+    constructor(res: HttpResponse, req: HttpRequest, context: OptionsSsr, entry: EntryFunction | any);
+    /**
+     * @param request addition request params
+     */
+    request(request?: Record<string, any>): Promise<void>;
 }
 
-/**
- * Select controller params from json file
- * And check permissions and method
- */
-
-interface Schema$1 {
-    controllers: Array<{
-        id?: number;
-        name: string;
-        isActive?: boolean;
-        isSitemap?: boolean;
-        subactions: Array<{
-            id?: number;
-            action: string;
-            name: string;
-            isPermission?: boolean;
-            isCheckMethod?: boolean;
-            isLog?: boolean;
-            isActive?: boolean;
-        }>;
-    }>;
-    actions: Array<{
-        id?: number;
-        name: string;
-        isActive?: boolean;
-        method?: method$2 | string;
-    }>;
+declare type method$2 = 'any' | 'connect' | 'del' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
+declare module "uWebSockets.js" {
+    interface HttpRequest {
+        cookies: Record<string, any>;
+    }
+}
+interface Route$1 {
+    name: string;
+    method?: method$2 | Array<method$2>;
+    component: any;
 }
+interface Config$1 {
+    server: Record<string, any>;
+    db: Record<string, any>;
+    [key: string]: any;
+}
+
+/**
+ * Select controller params from json file
+ * And check permissions and method
+ */
 
-declare type method$1 = 'any' | 'connect' | 'del' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
-declare module "uWebSockets.js" {
-    interface HttpRequest {
-        cookies: Record<string, any>;
-    }
-}
-interface Route {
-    name: string;
-    method?: method$1 | Array<method$1>;
-    component: any;
-}
-interface OptionsWeb {
-    readonly routes: Array<Route>;
-    readonly config: Config;
-    readonly db: Record<string, Query>;
-    readonly schema?: Schema$1;
-    readonly stack?: {
-        memcached?: Memcached;
-        memcachedPrefix?: string;
-        memcachedExpiry?: number;
-        redis?: any;
-        [key: string]: any;
-    };
-    readonly [key: string]: any;
-}
-interface Response$1 {
-    statusCode: number;
-    headers: Record<string, any>;
-    body: any;
-}
-interface Config {
-    server: Record<string, any>;
-    db: Record<string, any>;
-    [key: string]: any;
-}
-interface ActionsParmas {
-    controller: {
-        id?: number;
-        name: string;
-        isActive: boolean;
-        isSitemap: boolean;
-    };
-    subaction: {
-        id?: number;
-        name: string;
-        isPermission: boolean;
-        isCheckMethod: boolean;
-        isLog: boolean;
-        isActive: boolean;
-    };
-    action: {
-        id?: number;
-        name: string;
-        isActive: boolean;
-        method: method$1;
-    };
-}
-interface ContextWeb extends ActionsParmas {
-    readonly config: Config;
-    readonly db: Record<string, Query>;
-    readonly stack: {
-        memcached?: Memcached;
-        redis?: any;
-        [key: string]: any;
-    };
-    [key: string]: any;
-}
-interface ContextWebController extends ContextWeb {
-    method: string;
-    cookies: Record<string, any>;
-    hostname: string;
-    protocol: string;
-    url: string;
-    headers: Record<string, any>;
-    getRequest: () => Record<string, any>;
-    db: Record<string, Query>;
-    $stream?: Stream;
-    $body?: any;
-    $route?: Route;
-}
-/**
- * Entry point for /web api
- * handler for api request
- */
-declare class Web {
-    res: HttpResponse;
-    req: HttpRequest;
-    context: OptionsWeb;
-    defaultRequest: {
-        controller: string;
-        subaction: string;
-        lang: string;
-    };
-    defaultResponse: {
-        statusCode: number;
-        headers: {
-            "content-type": string;
-        };
-        body: {};
-    };
-    route: Route;
-    contextWeb: ContextWeb;
-    /**
-     * @constructor
-     * @param res response
-     * @param req request
-     * @param context params
-     */
-    constructor(res: HttpResponse, req: HttpRequest, context: OptionsWeb);
-    request(request?: Record<string, any>): Promise<void>;
-    /**
-     * Import controller class
-     * @param request params
-     * @private
-     */
-    private importController;
-    /**
-     * Find route in api routers
-     * @private
-     */
-    private findRoute;
-    /**
-     * Inject app context
-     * @param obj
-     * @private
-     */
-    private injectContext;
-    /**
-     * Initing component if init method exists
-     * @param obj
-     * @returns
-     * @private
-     */
-    private initComponent;
-    /**
-     * Success response
-     */
-    success(response: Response$1): void;
-    /**
-     * Error response
-     */
-    error(e: ApiError | Error): void;
+interface Schema$1 {
+    controllers: Array<{
+        id?: number;
+        name: string;
+        isActive?: boolean;
+        isSitemap?: boolean;
+        subactions: Array<{
+            id?: number;
+            action: string;
+            name: string;
+            isPermission?: boolean;
+            isCheckMethod?: boolean;
+            isLog?: boolean;
+            isActive?: boolean;
+        }>;
+    }>;
+    actions: Array<{
+        id?: number;
+        name: string;
+        isActive?: boolean;
+        method?: method$2 | string;
+    }>;
 }
 
-interface TestContext {
-    readonly config?: Config$1;
-    readonly db?: Record<string, Query>;
-    controller?: {
-        id: number;
-        name: string;
-        isActive: boolean;
-        isSitemap: boolean;
-    };
-    subaction?: {
-        id: number;
-        name: string;
-        isPermission: boolean;
-        isCheckMethod: boolean;
-        isLog: boolean;
-        isActive: boolean;
-    };
-    action?: {
-        id: number;
-        name: string;
-        isActive: boolean;
-        method: method$2;
-    };
-    method?: method$2;
-    cookies?: Record<string, any>;
-    hostname?: string;
-    protocol?: string;
-    url?: string;
-    headers?: Record<string, any>;
-    getRequest?: () => Record<string, any>;
-    $stream?: Stream;
-    $body?: any;
-    $route?: Route$1;
-    [key: string]: any;
-}
-/**
- * Create class with inject context
- */
+declare type method$1 = 'any' | 'connect' | 'del' | 'get' | 'head' | 'options' | 'patch' | 'post' | 'put' | 'trace';
+declare module "uWebSockets.js" {
+    interface HttpRequest {
+        cookies: Record<string, any>;
+    }
+}
+interface Route {
+    name: string;
+    method?: method$1 | Array<method$1>;
+    component: any;
+}
+interface OptionsWeb {
+    readonly routes: Array<Route>;
+    readonly config: Config;
+    readonly db: Record<string, Query>;
+    readonly schema?: Schema$1;
+    readonly stack?: {
+        memcached?: Memcached;
+        memcachedPrefix?: string;
+        memcachedExpiry?: number;
+        redis?: any;
+        [key: string]: any;
+    };
+    readonly [key: string]: any;
+}
+interface Response$1 {
+    statusCode: number;
+    headers: Record<string, any>;
+    body: any;
+}
+interface Config {
+    server: Record<string, any>;
+    db: Record<string, any>;
+    [key: string]: any;
+}
+interface ActionsParmas {
+    controller: {
+        id?: number;
+        name: string;
+        isActive: boolean;
+        isSitemap: boolean;
+    };
+    subaction: {
+        id?: number;
+        name: string;
+        isPermission: boolean;
+        isCheckMethod: boolean;
+        isLog: boolean;
+        isActive: boolean;
+    };
+    action: {
+        id?: number;
+        name: string;
+        isActive: boolean;
+        method: method$1;
+    };
+}
+interface ContextWeb extends ActionsParmas {
+    readonly config: Config;
+    readonly db: Record<string, Query>;
+    readonly stack: {
+        memcached?: Memcached;
+        redis?: any;
+        [key: string]: any;
+    };
+    [key: string]: any;
+}
+interface ContextWebController extends ContextWeb {
+    method: string;
+    cookies: Record<string, any>;
+    hostname: string;
+    protocol: string;
+    url: string;
+    headers: Record<string, any>;
+    getRequest: () => Record<string, any>;
+    db: Record<string, Query>;
+    $stream?: Stream;
+    $body?: any;
+    $route?: Route;
+}
+/**
+ * Entry point for /web api
+ * handler for api request
+ */
+declare class Web {
+    res: HttpResponse;
+    req: HttpRequest;
+    context: OptionsWeb;
+    defaultRequest: {
+        controller: string;
+        subaction: string;
+        lang: string;
+    };
+    defaultResponse: {
+        statusCode: number;
+        headers: {
+            "content-type": string;
+        };
+        body: {};
+    };
+    route: Route;
+    contextWeb: ContextWeb;
+    /**
+     * @constructor
+     * @param res response
+     * @param req request
+     * @param context params
+     */
+    constructor(res: HttpResponse, req: HttpRequest, context: OptionsWeb);
+    request(request?: Record<string, any>): Promise<void>;
+    /**
+     * Import controller class
+     * @param request params
+     * @private
+     */
+    private importController;
+    /**
+     * Find route in api routers
+     * @private
+     */
+    private findRoute;
+    /**
+     * Inject app context
+     * @param obj
+     * @private
+     */
+    private injectContext;
+    /**
+     * Initing component if init method exists
+     * @param obj
+     * @returns
+     * @private
+     */
+    private initComponent;
+    /**
+     * Success response
+     */
+    success(response: Response$1): void;
+    /**
+     * Error response
+     */
+    error(e: ApiError | Error): void;
+}
+
+interface TestContext {
+    readonly config?: Config$1;
+    readonly db?: Record<string, Query>;
+    controller?: {
+        id: number;
+        name: string;
+        isActive: boolean;
+        isSitemap: boolean;
+    };
+    subaction?: {
+        id: number;
+        name: string;
+        isPermission: boolean;
+        isCheckMethod: boolean;
+        isLog: boolean;
+        isActive: boolean;
+    };
+    action?: {
+        id: number;
+        name: string;
+        isActive: boolean;
+        method: method$2;
+    };
+    method?: method$2;
+    cookies?: Record<string, any>;
+    hostname?: string;
+    protocol?: string;
+    url?: string;
+    headers?: Record<string, any>;
+    getRequest?: () => Record<string, any>;
+    $stream?: Stream;
+    $body?: any;
+    $route?: Route$1;
+    [key: string]: any;
+}
+/**
+ * Create class with inject context
+ */
 declare const mountWithContext: <T>($class: new () => T, $context: TestContext, request?: Record<string, any>) => Promise<T>;
 
-interface Context extends ContextWeb {
-    method: string;
-    getRequest: () => Record<string, any>;
-    db: Record<string, any>;
-    headers: Record<string, any>;
-}
-/**
- * Base model
- */
-declare class Model {
-    protected $context: Context;
-    /**
-     * Create model
-     * @param model
-     * @param args
-     */
-    protected $create<T extends Model | Record<string, any>, A extends Array<any>>(model: {
-        new (...args: [...A]): T;
-    }, ...args: [...A]): Promise<T>;
-    /**
-     * Inject app context
-     * @param context
-     */
-    $inject(context: any): void;
-    getContext(): Context;
-    getRequest(): Record<string, any>;
-    getConfig(): Record<string, any>;
-    getMethod(): method$1;
-    getHeaders(): Record<string, any>;
-    getCookies(): Record<string, any>;
-    getController(): Context["controller"];
-    getAction(): Context["action"];
-    getSubaction(): Context["subaction"];
-    getDb(): Record<string, Query>;
-    getHome(): Query;
-    getPool(key?: string): Query;
-    setResponseHeader(key: string, value: string): any;
-    setCookieHeader(name: string, value: any, options?: Record<string, any>): any;
+interface Context extends ContextWeb {
+    method: string;
+    getRequest: () => Record<string, any>;
+    db: Record<string, any>;
+    headers: Record<string, any>;
+}
+/**
+ * Base model
+ */
+declare class Model {
+    protected $context: Context;
+    /**
+     * Create model
+     * @param model
+     * @param args
+     */
+    protected $create<T extends Model | Record<string, any>, A extends Array<any>>(model: {
+        new (...args: [...A]): T;
+    }, ...args: [...A]): Promise<T>;
+    /**
+     * Inject app context
+     * @param context
+     */
+    $inject(context: any): void;
+    getContext(): Context;
+    getRequest(): Record<string, any>;
+    getConfig(): Record<string, any>;
+    getMethod(): method$1;
+    getHeaders(): Record<string, any>;
+    getCookies(): Record<string, any>;
+    getController(): Context["controller"];
+    getAction(): Context["action"];
+    getSubaction(): Context["subaction"];
+    getDb(): Record<string, Query>;
+    getHome(): Query;
+    getPool(key?: string): Query;
+    setResponseHeader(key: string, value: string): any;
+    setCookieHeader(name: string, value: any, options?: Record<string, any>): any;
 }
 
-interface ResponseOptions {
-    memcache?: number | null;
-    headers?: Record<string, any>;
-    statusCode?: number;
-}
-/**
- * Base Controller
- */
-declare class Controller {
-    private responseHeaders;
-    $context: ContextWebController;
-    /**
-     * Set cookies
-     * @param name
-     * @param value
-     * @param options
-     */
-    setCookieHeader(name: string, value: any, options?: Record<string, any>): string;
-    /**
-     * Success request
-     * @param data response params
-     * @param options
-     * @returns
-     */
-    success(data?: {}, options?: ResponseOptions | any): {
-        headers: any;
-        body: {
-            isError: boolean;
-            data: {};
-        };
-        memcache: any;
-        statusCode: any;
-    };
-    /**
-     * Error response
-     * @param err
-     */
-    error(err: unknown | Error | ApiError): {
-        headers: {
-            "content-type": string;
-        } & Record<string, string>;
-        body: {
-            isError: boolean;
-            error: string;
-            code: number;
-            data: Record<string, unknown>;
-            stack: string | undefined;
-            response: {
-                status: any;
-                headers: any;
-                config: {
-                    url: any;
-                    method: any;
-                    params: any;
-                    headers: any;
-                };
-                data: any;
-            } | {
-                status?: undefined;
-                headers?: undefined;
-                config?: undefined;
-                data?: undefined;
-            };
-        };
-        statusCode: number;
-    };
-    /**
-     * Xml response
-     * @param data response params
-     * @param options addition options
-     */
-    successXml(data?: {}, options?: ResponseOptions): {
-        headers: {
-            "content-type": string;
-        } & Record<string, string | string[]> & Record<string, any>;
-        body: string;
-        memcache: any;
-    };
-    /**
-     * Error xml response
-     * @param err error object
-     */
-    errorXml(err: unknown | Error | ApiError): {
-        headers: {
-            "content-type": string;
-        } & Record<string, string>;
-        body: string;
-        statusCode: number;
-    };
-    /**
-     * Create model
-     * @param model
-     * @param args
-     */
-    $create<T extends Model | Record<string, any>, A extends Array<any>>(model: {
-        new (...args: [...A]): T;
-    }, ...args: [...A]): Promise<T>;
-    /**
-     * Inject app context
-     * @param context
-     */
-    $inject(context: ContextWebController): void;
-    getContext(): ContextWebController;
-    getRequest(): Record<string, any>;
-    getBody(): Buffer;
-    getStream(): Stream;
-    getConfig(): Record<string, any>;
-    getMethod(): method$1;
-    getCookies(): Record<string, any>;
-    getHostname(): string;
-    getUrl(): string;
-    getProtocol(): "http" | "https";
-    getDb(): Record<string, Query>;
-    getHeaders(): Record<string, any>;
-    getController(): ContextWebController["controller"];
-    getAction(): ContextWebController["action"];
-    getSubaction(): ContextWebController["subaction"];
-    getHome(): Query;
-    getPool(key?: string): Query;
-    getStack(): {
-        [key: string]: any;
-        memcached?: __.Memcached | undefined;
-        redis?: any;
-    };
-    setResponseHeader(key: string, value: string): void;
+interface ResponseOptions {
+    memcache?: number | null;
+    headers?: Record<string, any>;
+    statusCode?: number;
+}
+/**
+ * Base Controller
+ */
+declare class Controller {
+    private responseHeaders;
+    $context: ContextWebController;
+    /**
+     * Set cookies
+     * @param name
+     * @param value
+     * @param options
+     */
+    setCookieHeader(name: string, value: any, options?: Record<string, any>): string;
+    /**
+     * Success request
+     * @param data response params
+     * @param options
+     * @returns
+     */
+    success(data?: {}, options?: ResponseOptions | any): {
+        headers: any;
+        body: {
+            isError: boolean;
+            data: {};
+        };
+        memcache: any;
+        statusCode: any;
+    };
+    /**
+     * Error response
+     * @param err
+     */
+    error(err: unknown | Error | ApiError): {
+        headers: {
+            "content-type": string;
+        } & Record<string, string>;
+        body: {
+            isError: boolean;
+            error: string;
+            code: number;
+            data: Record<string, unknown>;
+            stack: string | undefined;
+            response: {
+                status: any;
+                headers: any;
+                config: {
+                    url: any;
+                    method: any;
+                    params: any;
+                    headers: any;
+                };
+                data: any;
+            } | {
+                status?: undefined;
+                headers?: undefined;
+                config?: undefined;
+                data?: undefined;
+            };
+        };
+        statusCode: number;
+    };
+    /**
+     * Xml response
+     * @param data response params
+     * @param options addition options
+     */
+    successXml(data?: {}, options?: ResponseOptions): {
+        headers: {
+            "content-type": string;
+        } & Record<string, string | string[]> & Record<string, any>;
+        body: string;
+        memcache: any;
+    };
+    /**
+     * Error xml response
+     * @param err error object
+     */
+    errorXml(err: unknown | Error | ApiError): {
+        headers: {
+            "content-type": string;
+        } & Record<string, string>;
+        body: string;
+        statusCode: number;
+    };
+    /**
+     * Create model
+     * @param model
+     * @param args
+     */
+    $create<T extends Model | Record<string, any>, A extends Array<any>>(model: {
+        new (...args: [...A]): T;
+    }, ...args: [...A]): Promise<T>;
+    /**
+     * Inject app context
+     * @param context
+     */
+    $inject(context: ContextWebController): void;
+    getContext(): ContextWebController;
+    getRequest(): Record<string, any>;
+    getBody(): Buffer;
+    getStream(): Stream;
+    getConfig(): Record<string, any>;
+    getMethod(): method$1;
+    getCookies(): Record<string, any>;
+    getHostname(): string;
+    getUrl(): string;
+    getProtocol(): "http" | "https";
+    getDb(): Record<string, Query>;
+    getHeaders(): Record<string, any>;
+    getController(): ContextWebController["controller"];
+    getAction(): ContextWebController["action"];
+    getSubaction(): ContextWebController["subaction"];
+    getHome(): Query;
+    getPool(key?: string): Query;
+    getStack(): {
+        [key: string]: any;
+        memcached?: Memcached | undefined;
+        redis?: any;
+    };
+    setResponseHeader(key: string, value: string): void;
 }
 
-/**
- * Select controller params from json file
- * And check permissions and method
- */
-
-interface Schema {
-    controllers: Array<{
-        id?: number;
-        name: string;
-        isActive?: boolean;
-        isSitemap?: boolean;
-        subactions: Array<{
-            id?: number;
-            action: string;
-            name: string;
-            isPermission?: boolean;
-            isCheckMethod?: boolean;
-            isLog?: boolean;
-            isActive?: boolean;
-        }>;
-    }>;
-    actions: Array<{
-        id?: number;
-        name: string;
-        isActive?: boolean;
-        method?: method$2 | string;
-    }>;
+/**
+ * Select controller params from json file
+ * And check permissions and method
+ */
+
+interface Schema {
+    controllers: Array<{
+        id?: number;
+        name: string;
+        isActive?: boolean;
+        isSitemap?: boolean;
+        subactions: Array<{
+            id?: number;
+            action: string;
+            name: string;
+            isPermission?: boolean;
+            isCheckMethod?: boolean;
+            isLog?: boolean;
+            isActive?: boolean;
+        }>;
+    }>;
+    actions: Array<{
+        id?: number;
+        name: string;
+        isActive?: boolean;
+        method?: method$2 | string;
+    }>;
 }
 
-/**
- * Response interface
- */
-interface Response {
-    memcache?: number | null;
-    headers?: Record<string, any>;
-    statusCode?: number;
-}
-declare type CallbackFunctionAny = (...args: any[]) => any;
-/**
- * Mixin helper for decorators
- * @param behaviour
- * @param sharedBehaviour
- * http://raganwald.com/2015/06/26/decorators-in-es7.html
- * http://raganwald.com/2015/06/17/functional-mixins.html
- * https://habr.com/ru/post/277021/
- */
-declare function mixin<T extends Record<string, any>>(behaviour: T, sharedBehaviour?: {}): (clazz: any) => any;
-/**
- * @request() decorator
- */
-declare function request(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
-/**
- * @context() decorator
- */
-declare function context(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
-/**
- * @config() decorator
- */
-declare function config(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
-/**
- * @method() decorator
- */
-declare function method(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
-/**
- * @cookies() decorator
- */
-declare function cookies(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
-/**
- * @hostname() decorator
- */
-declare function hostname(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
-/**
- * @url() decorator
- */
-declare function url(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
-/**
- * @protocol() decorator
- */
-declare function protocol(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
-/**
- * @db() decorator
- */
-declare function db(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
-/**
- * @headers() decorator
- */
-declare function headers(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
-/**
- * @controller() decorator
- */
-declare function controller(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
-/**
- * @action() decorator
- */
-declare function action(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
-/**
- * @subaction() decorator
- */
-declare function subaction(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
-/**
- * @body() decorator
- */
-declare function body(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
-/**
- * @stream() decorator
- */
-declare function stream(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
-/**
- * @home() decorator
- */
-declare function home(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
-/**
- * @pool() decorator
- */
-declare function pool(name?: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
-/**
- * @connection() decorator
- */
-declare function connection(name?: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
-/**
- * Json response
- * @param opt response options
- */
-declare function json(opt?: Response): (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<CallbackFunctionAny>) => void;
-/**
- * Xml response
- * @param opt response options
- */
-declare function xml(opt?: Response): (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<CallbackFunctionAny>) => void;
-/**
- * Logger
- * @param name logger name
- */
-declare function logerror(name: string): (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<CallbackFunctionAny>) => void;
-/**
- * Subaction method decorator
- * @http() decorator
- */
-declare function http(): (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<CallbackFunctionAny>) => void;
-/**
- * @init decorator
- */
+/**
+ * Response interface
+ */
+interface Response {
+    memcache?: number | null;
+    headers?: Record<string, any>;
+    statusCode?: number;
+}
+declare type CallbackFunctionAny = (...args: any[]) => any;
+/**
+ * Mixin helper for decorators
+ * @param behaviour
+ * @param sharedBehaviour
+ * http://raganwald.com/2015/06/26/decorators-in-es7.html
+ * http://raganwald.com/2015/06/17/functional-mixins.html
+ * https://habr.com/ru/post/277021/
+ */
+declare function mixin<T extends Record<string, any>>(behaviour: T, sharedBehaviour?: {}): (clazz: any) => any;
+/**
+ * @request() decorator
+ */
+declare function request(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @context() decorator
+ */
+declare function context(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @config() decorator
+ */
+declare function config(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @method() decorator
+ */
+declare function method(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @cookies() decorator
+ */
+declare function cookies(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @hostname() decorator
+ */
+declare function hostname(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @url() decorator
+ */
+declare function url(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @protocol() decorator
+ */
+declare function protocol(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @db() decorator
+ */
+declare function db(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @headers() decorator
+ */
+declare function headers(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @controller() decorator
+ */
+declare function controller(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @action() decorator
+ */
+declare function action(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @subaction() decorator
+ */
+declare function subaction(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @body() decorator
+ */
+declare function body(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @stream() decorator
+ */
+declare function stream(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @home() decorator
+ */
+declare function home(): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @pool() decorator
+ */
+declare function pool(name?: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * @connection() decorator
+ */
+declare function connection(name?: string): (target: any, propertyKey: string | symbol, parameterIndex: number) => void;
+/**
+ * Json response
+ * @param opt response options
+ */
+declare function json(opt?: Response): (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<CallbackFunctionAny>) => void;
+/**
+ * Xml response
+ * @param opt response options
+ */
+declare function xml(opt?: Response): (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<CallbackFunctionAny>) => void;
+/**
+ * Logger
+ * @param name logger name
+ */
+declare function logerror(name: string): (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<CallbackFunctionAny>) => void;
+/**
+ * Subaction method decorator
+ * @http() decorator
+ */
+declare function http(): (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<CallbackFunctionAny>) => void;
+/**
+ * @init decorator
+ */
 declare function init(): (target: any, propertyKey: string, descriptor: TypedPropertyDescriptor<CallbackFunctionAny>) => void;
 
-declare const helpers: {
-    cookieParse: (str: string) => Record<string, any>;
-    cookieString: (name: string, value: any, options?: Record<string, any>) => string;
-    jsonBody: (res: uWebSockets_js.HttpResponse, req: uWebSockets_js.HttpRequest) => Promise<any>;
-    rawBody: (res: uWebSockets_js.HttpResponse, req: uWebSockets_js.HttpRequest) => Promise<Buffer>;
-    streamBody: (res: uWebSockets_js.HttpResponse, req: uWebSockets_js.HttpRequest) => stream$1.Stream;
-    urlencodedBody: (res: uWebSockets_js.HttpResponse, req: uWebSockets_js.HttpRequest) => Promise<any>;
-    multipartBody: (res: uWebSockets_js.HttpResponse, req: uWebSockets_js.HttpRequest, options?: formidable.Options) => Promise<any>;
-    readConfig: (jsonfile: string) => Promise<any>;
-    readConfigSync: (jsonfile: string) => any;
-    staticBody: typeof staticBody;
-    extensions: string[];
-    getExt: (path: string) => string;
-    jwtDecode: (jwt: string) => {
-        head: any;
-        body: any;
-    };
+declare const helpers: {
+    cookieParse: (str: string) => Record<string, any>;
+    cookieString: (name: string, value: any, options?: Record<string, any>) => string;
+    jsonBody: (res: uWebSockets_js.HttpResponse, req: uWebSockets_js.HttpRequest) => Promise<any>;
+    rawBody: (res: uWebSockets_js.HttpResponse, req: uWebSockets_js.HttpRequest) => Promise<Buffer>;
+    streamBody: (res: uWebSockets_js.HttpResponse, req: uWebSockets_js.HttpRequest) => stream$1.Stream;
+    urlencodedBody: (res: uWebSockets_js.HttpResponse, req: uWebSockets_js.HttpRequest) => Promise<any>;
+    multipartBody: (res: uWebSockets_js.HttpResponse, req: uWebSockets_js.HttpRequest, options?: formidable.Options) => Promise<any>;
+    readConfig: (jsonfile: string) => Promise<any>;
+    readConfigSync: (jsonfile: string) => any;
+    staticBody: typeof staticBody;
+    extensions: string[];
+    getExt: (path: string) => string;
+    jwtDecode: (jwt: string) => {
+        head: any;
+        body: any;
+    };
 };
 
 export { ApiError, ApiErrorMessage, AsyncJwt, ContextWeb, Controller, Jwt, Memcached, Model, OptionsSsr, OptionsWeb, Route, Schema, Server, Handler as ServerHandler, Options as ServerOptions, Routes as ServerRoutes, WebSocket as ServerWebsocket, Ssr, Web, action, body, codeToStatus, config, connection, context, controller, cookies, db, headers, helpers, home, hostname, http, init, json, logerror, method, mixin, mountWithContext as mount, pool, protocol, request, stream, subaction, url, xml };