@maiyunnet/kebab 2.0.4 → 2.0.5

package/lib/net.d.ts

@@ -0,0 +1,65 @@
+import * as stream from 'stream';
+import * as http from 'http';
+import * as http2 from 'http2';
+import * as ctr from '~/sys/ctr';
+import * as types from '~/types';
+import * as fd from './net/formdata';
+import * as lRequest from './net/request';
+import * as response from './net/response';
+export interface IRequestOptions {
+    'method'?: 'GET' | 'POST' | 'OPTIONS';
+    'type'?: 'form' | 'json';
+    'timeout'?: number;
+    'follow'?: number;
+    'hosts'?: Record<string, string>;
+    'save'?: string;
+    'local'?: string;
+    'headers'?: types.THttpHeaders;
+    'mproxy'?: {
+        'url': string;
+        'auth': string;
+        'data'?: any;
+    };
+    'reuse'?: string;
+    'cookie'?: Record<string, types.ICookie>;
+}
+export interface IMproxyOptions {
+    'timeout'?: number;
+    'follow'?: number;
+    'hosts'?: Record<string, string>;
+    'local'?: string;
+    'headers'?: types.THttpHeaders;
+    'reuse'?: string;
+}
+export interface IRproxyOptions {
+    'timeout'?: number;
+    'follow'?: number;
+    'hosts'?: Record<string, string>;
+    'local'?: string;
+    'headers'?: types.THttpHeaders;
+    'mproxy'?: {
+        'url': string;
+        'auth': string;
+        'data'?: any;
+    };
+    'reuse'?: string;
+}
+export declare function getCa(): Promise<string>;
+export declare function open(u: string): lRequest.Request;
+export declare function get(u: string, opt?: IRequestOptions): Promise<response.Response>;
+export declare function post(u: string, data: Record<string, types.Json> | Buffer | string | stream.Readable, opt?: IRequestOptions): Promise<response.Response>;
+export declare function postJson(u: string, data: types.Json[] | Record<string, types.Json>, opt?: IRequestOptions): Promise<response.Response>;
+export declare function request(u: string, data?: Record<string, types.Json> | Buffer | string | stream.Readable, opt?: IRequestOptions): Promise<response.Response>;
+export declare function setCookie(cookie: Record<string, types.ICookie>, name: string, value: string, domain: string, opt?: {
+    'ttl'?: number;
+    'path'?: string;
+    'ssl'?: boolean;
+    'httponly'?: boolean;
+}): void;
+export declare function buildCookieQuery(cookie: Record<string, types.ICookie>, uri: types.IUrlParse): string;
+export declare function resetCookieSession(cookie: Record<string, types.ICookie>): void;
+export declare function getFormData(): fd.FormData;
+export declare function filterProxyHeaders(headers: http.IncomingHttpHeaders | http2.IncomingHttpHeaders | types.THttpHeaders, res?: http2.Http2ServerResponse | http.ServerResponse): Record<string, string | string[]>;
+export declare function mproxy(ctr: ctr.Ctr, auth: string, opt?: IMproxyOptions): Promise<number>;
+export declare function mproxyData(ctr: ctr.Ctr): any;
+export declare function rproxy(ctr: ctr.Ctr, route: Record<string, string>, opt?: IRproxyOptions): Promise<boolean>;

package/lib/s3.d.ts

@@ -0,0 +1,35 @@
+import * as s3 from '@aws-sdk/client-s3';
+import * as stream from 'stream';
+import * as sCtr from '~/sys/ctr';
+export declare enum ESERVICE {
+    'AMAZON' = 0,
+    'TENCENT' = 1,
+    'ALIBABA' = 2,
+    'CF' = 3
+}
+export interface IOptions {
+    'service': ESERVICE;
+    'account'?: string;
+    'secretId'?: string;
+    'secretKey'?: string;
+    'region'?: string;
+    'bucket'?: string;
+}
+export declare class S3 {
+    private readonly _link;
+    private _bucket;
+    private readonly _ctr;
+    constructor(ctr: sCtr.Ctr, opt: IOptions);
+    setBucket(bucket: string): void;
+    putObject(key: string, content: string | Buffer | stream.Readable, length?: number | {
+        'length'?: number;
+        'type'?: string;
+        'disposition'?: string;
+        'bucket'?: string;
+    }, bucket?: string): Promise<s3.CompleteMultipartUploadCommandOutput | false>;
+    getObject(key: string, bucket?: string): Promise<false | (stream.Readable & import("@smithy/types").SdkStreamMixin) | (Blob & import("@smithy/types").SdkStreamMixin) | (ReadableStream<any> & import("@smithy/types").SdkStreamMixin) | undefined>;
+    deleteObject(key: string, bucket?: string): Promise<boolean>;
+    deleteObjects(keys: string[], bucket?: string): Promise<boolean>;
+    headObject(key: string, bucket?: string): Promise<s3.HeadObjectCommandOutput | false>;
+}
+export declare function get(ctr: sCtr.Ctr, opt: IOptions): S3;

package/lib/scan.d.ts

@@ -0,0 +1,31 @@
+import * as lDb from '~/lib/db';
+import * as lKv from '~/lib/kv';
+import * as sCtr from '~/sys/ctr';
+export interface IOptions {
+    'ttl'?: number;
+    'sqlPre'?: sCtr.Ctr | string;
+    'name'?: string;
+}
+export interface IStaticOptions {
+    'sqlPre'?: sCtr.Ctr | string;
+    'name'?: string;
+}
+export declare class Scan {
+    private readonly _link;
+    private readonly _sql;
+    private readonly _name;
+    private _token;
+    private _ttl;
+    constructor(link: lDb.Pool | lKv.Pool, token?: string, opt?: IOptions);
+    private _timeLeft;
+    poll(): Promise<any>;
+    createToken(): Promise<boolean>;
+    getToken(): string | null;
+    setTTL(ttl: number): void;
+    getTTL(): number;
+    getTimeLeft(): number | null;
+    private _gc;
+}
+export declare function get(link: lDb.Pool | lKv.Pool, token?: string, opt?: IOptions): Promise<Scan>;
+export declare function scanned(link: lDb.Pool | lKv.Pool, token: string, opt?: IStaticOptions): Promise<boolean>;
+export declare function setData(link: lDb.Pool | lKv.Pool, token: string, data: Record<string, any> | string | number, opt?: IStaticOptions): Promise<boolean>;

package/lib/session.d.ts

@@ -0,0 +1,22 @@
+import * as db from '~/lib/db';
+import * as kv from '~/lib/kv';
+import * as ctr from '~/sys/ctr';
+export interface IOptions {
+    'name'?: string;
+    'ttl'?: number;
+    'ssl'?: boolean;
+    'sqlPre'?: string;
+}
+export declare class Session {
+    private _link;
+    private _sql;
+    private _name;
+    private _token;
+    private _ttl;
+    private _ctr;
+    init(ctr: ctr.Ctr, link: db.Pool | kv.Pool, auth?: boolean, opt?: IOptions): Promise<boolean>;
+    getToken(): string;
+    getName(): string;
+    update(): Promise<void>;
+    private _gc;
+}

package/lib/sql.d.ts

@@ -0,0 +1,57 @@
+import * as ctr from '~/sys/ctr';
+import * as types from '~/types';
+export declare class Sql {
+    private readonly _pre;
+    private _sql;
+    private _data;
+    constructor(pre?: string, opt?: {
+        'data'?: types.DbValue[];
+        'sql'?: string[];
+    });
+    insert(table: string): this;
+    replace(table: string): this;
+    values(cs: string[] | Record<string, types.DbValue>, vs?: types.DbValue[] | types.DbValue[][]): this;
+    notExists(table: string, insert: Record<string, types.DbValue>, where: string | types.Json): this;
+    duplicate(s: types.Json): this;
+    select(c: string | Array<string | Array<string | string[]>>, f: string | string[]): this;
+    update(f: string, s: types.Json): this;
+    private _updateSub;
+    delete(f: string): this;
+    union(lsql: Sql, type?: string): this;
+    unionAll(lsql: Sql): this;
+    join(f: string, s?: types.Json, type?: string, suf?: string, pre?: string): this;
+    leftJoin(f: string, s?: types.Json, suf?: string, pre?: string): this;
+    rightJoin(f: string, s?: types.Json, suf?: string, pre?: string): this;
+    innerJoin(f: string, s?: types.Json, suf?: string, pre?: string): this;
+    fullJoin(f: string, s?: types.Json, suf?: string, pre?: string): this;
+    crossJoin(f: string, s?: types.Json, suf?: string, pre?: string): this;
+    having(s?: string | types.Json): this;
+    private _whereDataPosition;
+    where(s: string | types.Json): this;
+    private _whereSub;
+    by(c: string | Array<string | string[]>, d?: 'DESC' | 'ASC'): this;
+    group(c: string | string[]): this;
+    limit(a: number, b?: number): this;
+    lock(): this;
+    copy(f?: string | string[], opt?: {
+        'where'?: string | types.Json;
+    }): Sql;
+    getSql(): string;
+    getData(): types.DbValue[];
+    getPre(): string;
+    format(sql?: string, data?: types.DbValue[]): string;
+    append(sql: string): this;
+    field(str: string | number | Array<string | string[]>, pre?: string, suf?: string): string;
+    private _isField;
+}
+export declare function get(ctrPre?: ctr.Ctr | string, opt?: {
+    'data'?: types.DbValue[];
+    'sql'?: string[];
+}): Sql;
+export declare function format(sql: string, data: types.DbValue[]): string;
+export declare function aoMix(arr: types.Json): Record<string, string | number | types.Json>;
+export declare function column(field: string): {
+    'type': 'column';
+    'token': string;
+    'value': string;
+};

package/lib/ssh/sftp.d.ts

@@ -0,0 +1,40 @@
+import * as stream from 'stream';
+import * as ssh2 from 'ssh2';
+export declare class Connection {
+    private readonly _client;
+    private _path;
+    constructor(sftp: ssh2.SFTPWrapper, path: string);
+    getContent(path: string, options?: {
+        'start'?: number;
+        'end'?: number;
+    }): Promise<Buffer | null>;
+    getContent(path: string, options: BufferEncoding | {
+        'encoding': BufferEncoding;
+        'start'?: number;
+        'end'?: number;
+    }): Promise<string | null>;
+    putContent(path: string, data: string | Buffer, options?: ssh2.WriteFileOptions): Promise<boolean>;
+    readLink(path: string): Promise<string | null>;
+    symlink(filePath: string, linkPath: string): Promise<boolean>;
+    unlink(path: string): Promise<boolean>;
+    private _unlink;
+    stats(path: string): Promise<ssh2.Stats | null>;
+    isDir(path: string): Promise<ssh2.Stats | false>;
+    isFile(path: string): Promise<ssh2.Stats | false>;
+    mkdir(path: string, mode?: number): Promise<boolean>;
+    rmdir(path: string): Promise<boolean>;
+    rmdirDeep(path: string): Promise<boolean>;
+    chmod(path: string, mode: string | number): Promise<boolean>;
+    rename(oldPath: string, newPath: string): Promise<boolean>;
+    readDir(path: string): Promise<ssh2.FileEntry[]>;
+    createReadStream(path: string, options?: ssh2.ReadStreamOptions): stream.Readable;
+    pipe<T extends NodeJS.WritableStream>(path: string, destination: T, options?: {
+        'end'?: boolean;
+    }): Promise<boolean>;
+    createWriteStream(path: string, options?: BufferEncoding | ssh2.WriteStreamOptions): stream.Writable;
+    pwd(): string;
+    downloadFile(remoteFile: string, localFile: string, options?: ssh2.TransferOptions): Promise<boolean>;
+    uploadFile(localFile: string, remoteFile: string, options?: ssh2.TransferOptions): Promise<boolean>;
+    cd(dir: string): string;
+    close(): void;
+}

package/lib/ssh/shell.d.ts

@@ -0,0 +1,13 @@
+import * as ssh2 from 'ssh2';
+export declare class Connection {
+    private readonly _client;
+    constructor(stream: ssh2.ClientChannel);
+    send(cmd: string | Buffer, encoding?: BufferEncoding): Promise<boolean>;
+    sendLine(cmd: string, encoding?: BufferEncoding): Promise<boolean>;
+    sendEnter(): Promise<boolean>;
+    sendTab(): Promise<boolean>;
+    sendCtrlC(): Promise<boolean>;
+    close(cmd?: string | Buffer, encoding?: BufferEncoding): Promise<void>;
+    getContent(tryCount?: number): Promise<Buffer>;
+    getStream(): ssh2.ClientChannel;
+}

package/lib/ssh.d.ts

@@ -0,0 +1,24 @@
+import * as ssh2 from 'ssh2';
+import * as shell from './ssh/shell';
+import * as sftp from './ssh/sftp';
+interface IExtOptions {
+    'mproxy'?: {
+        'host': string;
+        'port': number;
+        'username': string;
+        'password': string;
+    };
+}
+export declare class Connection {
+    private readonly _client;
+    private _mclient?;
+    constructor();
+    connect(opt: ssh2.ConnectConfig & IExtOptions): Promise<boolean>;
+    disconnect(): void;
+    exec(command: string): Promise<Buffer | false>;
+    getShell(): Promise<shell.Connection | null>;
+    getSftp(): Promise<sftp.Connection | null>;
+    getStream(): Promise<ssh2.ClientChannel | null>;
+}
+export declare function get(opt: ssh2.ConnectConfig & IExtOptions): Promise<Connection | null>;
+export {};

package/lib/text.d.ts

@@ -0,0 +1,40 @@
+import * as types from '~/types';
+export declare function sizeFormat(size: number, spliter?: string): string;
+export declare function parseUrl(url: string): types.IUrlParse;
+export declare function urlResolve(from: string, to: string): string;
+export declare function urlAtom(url: string): string;
+export declare const REGEXP_EMAIL: RegExp;
+export declare function isEMail(email: string): boolean;
+export declare const REGEXP_IPV4: RegExp;
+export declare function isIPv4(ip: string): boolean;
+export declare const REGEXP_IPV6: RegExp;
+export declare function isIPv6(ip: string): boolean;
+export declare const REGEXP_DOMAIN: RegExp;
+export declare function isDomain(domain: string): boolean;
+export declare const REGEXP_ASCII: RegExp;
+export declare function isAscii(text: string): boolean;
+export declare function nlReplace(str: string, to?: string): string;
+export interface IDomain {
+    tld: string | null;
+    sld: string | null;
+    domain: string | null;
+    sub: string | null;
+}
+export declare function parseDomain(domain: string): Promise<IDomain>;
+export declare function match(str: string, regs: RegExp[]): boolean;
+export declare function isPhoneCN(p: string): boolean;
+export declare function isIdCardCN(idcard: string): boolean;
+export declare function queryStringify(query: Record<string, any>, encode?: boolean): string;
+export declare function queryParse(query: string): Record<string, string | string[]>;
+export declare function htmlescape(html: string): string;
+export declare function isRealPath(path: string): boolean;
+export declare function getFilename(path: string): string;
+export declare function stringifyResult(rtn: types.Json): string;
+export declare function parseJson(str: string): any;
+export declare function stringifyJson(obj: types.Json, space?: string | number): string;
+type TFalsy = false | '' | 0 | null | undefined | typeof NaN;
+export declare function isFalsy(val: any): val is TFalsy;
+export declare function logicalOr<T, T2>(v1: T, v2: T2): [T] extends [TFalsy] ? T2 : T;
+export declare function str2int(str: string, digits?: number): number;
+export declare function int2str(int: number, digits?: number, decimal?: number): string;
+export {};

package/lib/time.d.ts

@@ -0,0 +1,22 @@
+import * as sCtr from '~/sys/ctr';
+export interface IOptions {
+    'zone'?: number;
+    'data'?: string | number;
+}
+export declare const HOUR = 3600;
+export declare const DAY = 86400;
+export declare const YEAR = 31536000;
+export declare class Time {
+    private readonly _date;
+    private _zone;
+    constructor(ctr: sCtr.Ctr, opt: IOptions);
+    setZone(zone: number): void;
+    getZone(): number;
+    toUTCString(): string;
+    format(f: string, zone?: number): string;
+    stamp(): number;
+}
+export declare function get(ctr: sCtr.Ctr, opt?: IOptions): Time;
+export declare function stamp(date?: Date | string, zone?: number | sCtr.Ctr | null): number;
+export declare function isMs(time: number): boolean;
+export declare function format(zone: number | sCtr.Ctr | null, f: string, date?: Date | number): string;

package/lib/ws.d.ts

@@ -0,0 +1,87 @@
+import * as http from 'http';
+import * as net from 'net';
+import * as types from '~/types';
+import * as sCtr from '~/sys/ctr';
+export declare enum EFrameReceiveMode {
+    STANDARD = 0,
+    LITE = 1,
+    SIMPLE = 2
+}
+export declare enum EOpcode {
+    CONTINUATION = 0,
+    TEXT = 1,
+    BINARY = 2,
+    CLOSE = 8,
+    PING = 9,
+    PONG = 10
+}
+export interface IConnectOptions {
+    'timeout'?: number;
+    'hosts'?: Record<string, string>;
+    'local'?: string;
+    'headers'?: types.THttpHeaders;
+    'cookie'?: Record<string, types.ICookie>;
+    'mode'?: EFrameReceiveMode;
+    'masking'?: boolean;
+    'mproxy'?: {
+        'url': string;
+        'auth': string;
+    };
+}
+export interface IMproxyOptions {
+    'timeout'?: number;
+    'hosts'?: Record<string, string>;
+    'local'?: string;
+    'headers'?: types.THttpHeaders;
+    'mode'?: EFrameReceiveMode;
+    'masking'?: boolean;
+}
+export interface IRproxyOptions {
+    'timeout'?: number;
+    'hosts'?: Record<string, string>;
+    'local'?: string;
+    'headers'?: types.THttpHeaders;
+    'mode'?: EFrameReceiveMode;
+    'masking'?: boolean;
+    'mproxy'?: {
+        'url': string;
+        'auth': string;
+    };
+}
+export declare class Socket {
+    private _ws;
+    constructor(request?: http.IncomingMessage, socket?: net.Socket, options?: {
+        'headers'?: http.OutgoingHttpHeaders;
+        'timeout'?: number;
+    });
+    connect(u: string, opt?: IConnectOptions): Promise<this | null>;
+    private _bindEvent;
+    private readonly _waitMsg;
+    private _error;
+    private _close;
+    private _on;
+    on(event: 'message', cb: (msg: {
+        'opcode': EOpcode;
+        'data': Buffer | string;
+    }) => void | Promise<void>): this;
+    on(event: 'error', cb: (error: any) => void | Promise<void>): this;
+    on(event: 'drain' | 'close' | 'end', cb: () => void | Promise<void>): this;
+    end(): void;
+    destroy(): void;
+    writeText(data: string): boolean;
+    writeResult(data: types.Json): boolean;
+    writeBinary(data: string | Buffer | Array<string | Buffer>): boolean;
+    get writable(): boolean;
+    get ended(): boolean;
+    get finished(): boolean;
+    get isServer(): boolean;
+    ping(data?: Buffer | string): boolean;
+    pong(data?: Buffer | string): boolean;
+}
+export declare function connect(u: string, opt?: IConnectOptions): Promise<Socket | null>;
+export declare function createServer(request: http.IncomingMessage, socket: net.Socket, options?: {
+    'headers'?: http.OutgoingHttpHeaders;
+    'timeout'?: number;
+}): Socket;
+export declare function mproxy(ctr: sCtr.Ctr, auth: string, opt?: IMproxyOptions): Promise<number>;
+export declare function rproxy(ctr: sCtr.Ctr, url: string, opt?: IRproxyOptions): Promise<boolean>;

package/lib/zip.d.ts

@@ -0,0 +1,40 @@
+import jszip from 'jszip';
+import * as types from '~/types';
+export declare class Zip {
+    private readonly _zip;
+    private _path;
+    constructor(zip: jszip);
+    getContent(path: string): Promise<string | null>;
+    getContent<T extends types.TZipOutputType>(path: string, type: T): Promise<types.IZipOutputByType[T] | null>;
+    putContent<T extends types.TZipInputType>(path: string, data: types.IZipInputByType[T], options?: {
+        'base64'?: boolean;
+        'binary'?: boolean;
+        'date'?: Date;
+    }): void;
+    unlink(path: string): void;
+    stats(path: string): types.IZipStats | null;
+    isDir(path: string): types.IZipStats | false;
+    isFile(path: string): types.IZipStats | false;
+    readDir(path?: string, opt?: {
+        'hasChildren'?: boolean;
+        'hasDir'?: boolean;
+        'pathAsKey'?: false;
+    }): types.IZipItem[];
+    readDir(path?: string, opt?: {
+        'hasChildren'?: boolean;
+        'hasDir'?: boolean;
+        'pathAsKey': true;
+    }): Record<string, types.IZipItem>;
+    private _readDir;
+    private _list;
+    private _refreshList;
+    pwd(): string;
+    cd(dir: string): string;
+    generate<T extends types.TZipOutputType>(options?: {
+        'type'?: T;
+        'level'?: number;
+        'onUpdate'?: (percent: number, currentFile: string | null) => void;
+    }): Promise<types.IZipOutputByType[T]>;
+    getList(): Promise<Record<string, Buffer | string>>;
+}
+export declare function get(data?: types.TZipInputFileFormat): Promise<Zip | null>;

package/lib/zlib.d.ts

@@ -0,0 +1,25 @@
+import * as zlib from 'zlib';
+export interface ICompress {
+    readonly type: string;
+    readonly compress: zlib.Deflate | zlib.Gzip | zlib.BrotliCompress | zlib.Inflate | zlib.Gunzip | zlib.BrotliDecompress;
+}
+export interface ICompressBuffer {
+    readonly type: string;
+    readonly buffer: Buffer;
+}
+export declare function createGzip(options?: zlib.ZlibOptions): zlib.Gzip;
+export declare function createGunzip(): zlib.Gunzip;
+export declare function createDeflate(options?: zlib.ZlibOptions): zlib.Deflate;
+export declare function createInflate(): zlib.Inflate;
+export declare function createBrotliCompress(options?: zlib.ZlibOptions): zlib.BrotliCompress;
+export declare function createBrotliDecompress(): zlib.BrotliDecompress;
+export declare function createCompress(types: string, options?: zlib.ZlibOptions): ICompress | null;
+export declare function createDecompress(types: string): ICompress | null;
+export declare function gzip(buffer: zlib.InputType, options?: zlib.ZlibOptions): Promise<Buffer | null>;
+export declare function gunzip(buffer: zlib.InputType): Promise<Buffer | null>;
+export declare function deflate(buffer: zlib.InputType, options?: zlib.ZlibOptions): Promise<Buffer | null>;
+export declare function inflate(buffer: zlib.InputType): Promise<Buffer | null>;
+export declare function brotliCompress(buffer: zlib.InputType, options?: zlib.ZlibOptions): Promise<Buffer | null>;
+export declare function brotliDecompress(buffer: zlib.InputType): Promise<Buffer | null>;
+export declare function compress(types: string, buffer: zlib.InputType | null, options?: zlib.ZlibOptions): Promise<ICompressBuffer | null>;
+export declare function decompress(types: string, buffer: zlib.InputType | null): Promise<ICompressBuffer | null>;

package/main.d.ts

@@ -0,0 +1 @@
+import 'ts-alias-loader';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maiyunnet/kebab",
-  "version": "2.0.4",
+  "version": "2.0.5",
   "description": "Simple, easy-to-use, and fully-featured Node.js framework that is ready-to-use out of the box.",
   "keywords": [
     "kebab",

package/sys/child.d.ts

@@ -0,0 +1 @@
+export {};

package/sys/cmd.d.ts

@@ -0,0 +1 @@
+export {};

package/sys/ctr.d.ts

@@ -0,0 +1,96 @@
+import * as http from 'http';
+import * as http2 from 'http2';
+import * as session from '../lib/session';
+import * as db from '../lib/db';
+import * as kv from '../lib/kv';
+import * as lWs from '../lib/ws';
+import * as types from '../types';
+export declare function clearLocaleData(): void;
+export declare class Ctr {
+    protected _param: string[];
+    protected _action: string;
+    protected _headers: http.IncomingHttpHeaders;
+    protected _get: Record<string, string>;
+    protected _rawPost: Record<string, types.Json>;
+    protected _post: Record<string, types.Json>;
+    protected _input: string;
+    protected _files: Record<string, types.IPostFile | types.IPostFile[]>;
+    protected _cookie: Record<string, string>;
+    protected _jwt: Record<string, types.Json>;
+    protected _session: Record<string, types.Json>;
+    protected _sess: session.Session | null;
+    protected _cacheTTL: number;
+    protected _xsrf: string;
+    protected _httpCode: number;
+    protected _locale: string;
+    protected readonly _config: types.IConfig;
+    protected readonly _req: http2.Http2ServerRequest | http.IncomingMessage;
+    protected readonly _res: http2.Http2ServerResponse | http.ServerResponse;
+    protected readonly _socket: lWs.Socket;
+    protected _localeFiles: string[];
+    protected _localeData: Record<string, Record<string, string>>;
+    constructor(config: types.IConfig, req: http2.Http2ServerRequest | http.IncomingMessage, res?: http2.Http2ServerResponse | http.ServerResponse);
+    get isAvail(): boolean;
+    protected _timer?: {
+        'timer': NodeJS.Timeout;
+        'timeout': number;
+        'callback': () => void;
+    };
+    get timeout(): number;
+    set timeout(num: number);
+    private readonly _waitInfo;
+    protected _asyncTask(func: () => void | Promise<void>): void;
+    getPrototype(name: '_config'): types.IConfig;
+    getPrototype(name: '_sess'): session.Session | null;
+    getPrototype(name: '_headers'): http.IncomingHttpHeaders;
+    getPrototype(name: '_req'): http2.Http2ServerRequest | http.IncomingMessage;
+    getPrototype(name: '_res'): http2.Http2ServerResponse | http.ServerResponse;
+    getPrototype(name: '_socket'): lWs.Socket;
+    getPrototype(name: '_rawPost' | '_post' | '_get' | '_session'): Record<string, types.Json>;
+    getPrototype(name: '_input'): string;
+    getPrototype(name: string): types.Json;
+    setPrototype(name: string, val: string | string[] | http.IncomingHttpHeaders | Record<string, types.Json> | session.Session | lWs.Socket | null): void;
+    onLoad(): boolean | string | types.DbValue[] | Promise<boolean | string | types.DbValue[]>;
+    onUnload(rtn: boolean | string | types.DbValue[]): boolean | string | types.DbValue[] | Promise<boolean | string | types.DbValue[]>;
+    onUpgrade(): {
+        'headers'?: http.OutgoingHttpHeaders;
+        'timeout'?: number;
+    };
+    onData(data: Buffer | string, opcode: lWs.EOpcode): types.Json;
+    onMessage(data: Buffer | string, opcode: lWs.EOpcode): undefined | boolean | Promise<undefined | boolean>;
+    onDrain(): void | Promise<void>;
+    onClose(): void | Promise<void>;
+    protected _getRunTime(ms?: boolean): number;
+    protected _getMemoryUsage(): number;
+    protected _loadView(path: string, data?: types.Json): Promise<string>;
+    protected _checkInput(input: Record<string, types.Json>, rule: Record<string, types.Json[]>, rtn: types.Json[]): boolean;
+    protected _checkXInput(input: Record<string, types.Json>, rule: Record<string, types.Json[]>, rtn: types.Json[]): boolean;
+    protected _enabledXsrf(): void;
+    protected _getBasicAuth(user: string, pwd: string): string;
+    protected _device(): 'android' | 'windows' | 'linux' | 'macintosh' | 'ipad' | 'unknown';
+    private _authorization;
+    getAuthorization(): {
+        'user': string;
+        'pwd': string;
+    } | false | string;
+    protected _loadData(path: string): Promise<Record<string, string> | null>;
+    protected _location(location: string): false;
+    protected _startSession(link: db.Pool | kv.Pool, auth?: boolean, opt?: session.IOptions): Promise<void>;
+    protected _loadLocale(loc: string, pkg?: string): Promise<boolean>;
+    private _loadLocaleDeep;
+    protected _getLocaleJsonString(): string;
+    protected _getLocale(): string;
+    protected _cross(): boolean;
+    _l(key: string, data?: string[]): string;
+    protected _writeText(data: string): boolean;
+    protected _writeResult(data: types.Json): boolean;
+    protected _writeBinary(data: Buffer | string | Array<Buffer | string>): boolean;
+    protected _ping(): boolean;
+    protected _pong(): boolean;
+    protected _end(): void;
+    protected _handleFormData(events?: {
+        onfilestart?: (name: string) => boolean | undefined;
+        onfiledata?: (chunk: Buffer) => void;
+        onfileend?: () => void;
+    }): Promise<boolean>;
+}

package/sys/master.d.ts

@@ -0,0 +1 @@
+export {};