@maiyunnet/kebab 2.0.4 → 2.0.5

package/index.d.ts

@@ -0,0 +1,14 @@
+export declare const VER = "2.0.5";
+export declare const ROOT_PATH: string;
+export declare const LIB_PATH: string;
+export declare const SYS_PATH: string;
+export declare const ROOT_CWD: string;
+export declare const CONF_CWD: string;
+export declare const CERT_CWD: string;
+export declare const VHOST_CWD: string;
+export declare const LIB_CWD: string;
+export declare const LOG_CWD: string;
+export declare const WWW_CWD: string;
+export declare const IND_CWD: string;
+export declare const FTMP_CWD: string;
+export declare const MOD_CWD: string;

package/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MOD_CWD = exports.FTMP_CWD = exports.IND_CWD = exports.WWW_CWD = exports.LOG_CWD = exports.LIB_CWD = exports.VHOST_CWD = exports.CERT_CWD = exports.CONF_CWD = exports.ROOT_CWD = exports.SYS_PATH = exports.LIB_PATH = exports.ROOT_PATH = exports.VER = void 0;
-exports.VER = '2.0.4';
+exports.VER = '2.0.5';
 const dirname = __dirname.replace(/\\/g, '/');
 exports.ROOT_PATH = dirname + '/';
 exports.LIB_PATH = exports.ROOT_PATH + 'lib/';

package/lib/buffer.d.ts

@@ -0,0 +1,25 @@
+export declare class Reader {
+    private readonly _buffer;
+    private _offset;
+    constructor(buffer: Buffer);
+    readUInt8(): number;
+    readUInt16BE(): number;
+    readUInt32BE(): number;
+    readBCDString(length?: number): string;
+    readString(length?: number, encoding?: BufferEncoding): string;
+    readBuffer(length?: number): Buffer;
+    length(): number;
+}
+export declare class Writer {
+    private readonly _buffer;
+    private _offset;
+    constructor(size: number);
+    writeUInt8(value: number): void;
+    writeUInt16BE(value: number): void;
+    writeUInt32BE(value: number): void;
+    writeBCDString(value: string): void;
+    writeString(value: string, encoding?: BufferEncoding): number;
+    get(): Buffer;
+}
+export declare function getReader(buffer: Buffer): Reader;
+export declare function getWriter(size: number): Writer;

package/lib/captcha.d.ts

@@ -0,0 +1,12 @@
+export declare class Captcha {
+    private readonly _link;
+    constructor(opt: {
+        'width': number;
+        'height': number;
+        'length': number;
+    });
+    getBuffer(): string;
+    getBase64(): string;
+    getPhrase(): string;
+}
+export declare function get(width: number, height: number, length?: number): Captcha;

package/lib/consistent.d.ts

@@ -0,0 +1,20 @@
+export declare class Consistent {
+    private readonly _vcount;
+    private readonly _circle;
+    private _keys;
+    constructor(vcount: number);
+    getVcount(): number;
+    add(node: string | string[]): void;
+    remove(node: string | string[]): void;
+    find(key: string | number): string | null;
+    migration(keys: string | number | Array<string | number>, node: string | string[]): Record<string, {
+        'old': string;
+        'new': string;
+    }>;
+}
+export declare function get(vcount?: number): Consistent;
+export declare function fast(key: string | number, nodes: string | string[], vcount?: number): string | null;
+export declare function hash(val: string | number): number;
+export declare function getRange(min: number, max: number, pre?: string): string[];
+export declare function addToCircle(circle: Record<string, string>, node: string | string[], vcount?: number): void;
+export declare function findInCircle(circle: Record<string, string>, key: string | number, keys?: string[]): string | null;

package/lib/core.d.ts

@@ -0,0 +1,85 @@
+import * as http from 'http';
+import * as http2 from 'http2';
+import * as stream from 'stream';
+import * as lResponse from '~/lib/net/response';
+import * as sCtr from '~/sys/ctr';
+import * as types from '~/types';
+export declare const globalConfig: types.IConfig & {
+    'httpPort': number;
+    'httpsPort': number;
+    'rpcPort': number;
+    'rpcSecret': string;
+    'debug': boolean;
+    'max': number;
+};
+export interface ICookieOptions {
+    'ttl'?: number;
+    'path'?: string;
+    'domain'?: string;
+    'ssl'?: boolean;
+    'httponly'?: boolean;
+    'samesite'?: 'None' | 'Lax' | 'Strict';
+}
+export declare function setCookie(ctr: sCtr.Ctr, name: string, value: string, opt?: ICookieOptions): void;
+export declare function rand(min: number, max: number, prec?: number): number;
+export declare const RANDOM_N = "0123456789";
+export declare const RANDOM_U = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+export declare const RANDOM_L = "abcdefghijklmnopqrstuvwxyz";
+export declare const RANDOM_UN: string;
+export declare const RANDOM_LN: string;
+export declare const RANDOM_LU: string;
+export declare const RANDOM_LUN: string;
+export declare const RANDOM_V = "ACEFGHJKLMNPRSTWXY34567";
+export declare const RANDOM_LUNS: string;
+export declare function random(length?: number, source?: string, block?: string): string;
+export declare const CONVERT62_CHAR = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+export declare function convert62(n: bigint | number | string): string;
+export declare function unconvert62(n: string): bigint;
+export declare function purify(text: string): string;
+export declare function checkType(val: any, type: any, tree?: string): string;
+export declare function muid(ctr: sCtr.Ctr, opt?: {
+    'len'?: number;
+    'bin'?: boolean;
+    'key'?: string;
+    'insert'?: string;
+    'num'?: boolean;
+}): string;
+export declare function ip(ctr: sCtr.Ctr | http.IncomingHttpHeaders, req?: http2.Http2ServerRequest | http.IncomingMessage): string;
+export declare const REAL_IP_X = "x-forwarded-for";
+export declare const REAL_IP_CF = "cf-connecting-ip";
+export declare function realIP(ctr: sCtr.Ctr, name?: string): string;
+export declare function sleep(ms: number): Promise<void>;
+export declare function objectSort<T extends Record<string, any>>(o: T): T;
+export declare function emptyObject(obj: Record<string, types.Json>, deep?: boolean): void;
+export declare function passThroughAppend(passThrough: stream.PassThrough, data: Array<stream.Readable | lResponse.Response | string | Buffer>, end?: boolean): Promise<void>;
+export declare function exec(command: string): Promise<string | false>;
+export declare function sendReload(hosts?: string[]): Promise<string[]>;
+export declare function sendRestart(hosts?: string[]): Promise<string[]>;
+export declare const global: Record<string, any>;
+export declare function setGlobal(key: string, data: types.Json, hosts?: string[]): Promise<string[]>;
+export declare function removeGlobal(key: string, hosts?: string[]): Promise<string[]>;
+export declare function updateCode(sourcePath: string, path: string, hosts?: string[], config?: boolean): Promise<Record<string, {
+    'result': boolean;
+    'return': string;
+}>>;
+export interface ILogOptions {
+    'path': string;
+    'urlFull': string;
+    'hostname': string;
+    'req': http2.Http2ServerRequest | http.IncomingMessage | null;
+    'get': Record<string, types.Json>;
+    'cookie': Record<string, string>;
+    'headers': http.IncomingHttpHeaders;
+}
+export declare function log(opt: sCtr.Ctr | ILogOptions, msg: string, fend?: string): Promise<void>;
+export declare function getLog(opt: {
+    'host': string;
+    'path': string;
+    'fend'?: string;
+    'search'?: string;
+    'offset'?: number;
+    'limit'?: number;
+}): Promise<string[][] | null | false>;
+export declare function clone(obj: Record<string, any> | any[]): any[] | any;
+export declare function debug(message?: any, ...optionalParams: any[]): void;
+export declare function display(message?: any, ...optionalParams: any[]): void;

package/lib/crypto.d.ts

@@ -0,0 +1,47 @@
+import * as crypto from 'crypto';
+export declare function generateKeyPair(type: string, options?: {
+    'modulusLength'?: number;
+    'namedCurve'?: string;
+    'publicKeyEncoding'?: {
+        'type'?: 'pkcs1' | 'spki';
+        'format'?: 'pem' | 'der';
+    };
+    'privateKeyEncoding'?: {
+        'type'?: 'pkcs1' | 'pkcs8' | 'sec1';
+        'format'?: 'pem' | 'der';
+    };
+}): Promise<{
+    'public': string | Buffer;
+    'private': string | Buffer;
+}>;
+export declare function sign(data: crypto.BinaryLike, privateKey: crypto.KeyLike | crypto.SignKeyObjectInput | crypto.SignPrivateKeyInput | crypto.SignJsonWebKeyInput, format: 'hex' | 'base64' | 'binary', algorithm?: string): string;
+export declare function sign(data: crypto.BinaryLike, privateKey: crypto.KeyLike | crypto.SignKeyObjectInput | crypto.SignPrivateKeyInput | crypto.SignJsonWebKeyInput, format?: 'buffer', algorithm?: string): Buffer;
+export declare function verify(data: crypto.BinaryLike, object: crypto.KeyLike | crypto.VerifyKeyObjectInput | crypto.VerifyPublicKeyInput | crypto.VerifyJsonWebKeyInput, signature: NodeJS.ArrayBufferView, algorithm?: string): boolean;
+export declare function publicEncrypt(key: crypto.RsaPublicKey | crypto.RsaPrivateKey | crypto.KeyLike, buffer: NodeJS.ArrayBufferView): Buffer;
+export declare function privateEncrypt(key: crypto.RsaPrivateKey | crypto.KeyLike, buffer: NodeJS.ArrayBufferView): Buffer;
+export declare function publicDecrypt(key: crypto.RsaPublicKey | crypto.RsaPrivateKey | crypto.KeyLike, buffer: NodeJS.ArrayBufferView): Buffer;
+export declare function privateDecrypt(key: crypto.RsaPrivateKey | crypto.KeyLike, buffer: NodeJS.ArrayBufferView): Buffer;
+export declare const AES_256_ECB = "AES-256-ECB";
+export declare const AES_256_CBC = "AES-256-CBC";
+export declare const AES_256_CFB = "AES-256-CFB";
+export declare const SM4_ECB = "SM4-ECB";
+export declare const SM4_CBC = "SM4-CBC";
+export declare const SM4_CFB = "SM4-CFB";
+export declare function cipherEncrypt(original: string | Buffer, key: crypto.CipherKey, iv?: string, method?: string, output?: 'base64' | 'buffer'): string | Buffer | false;
+export declare function aesEncrypt(original: string | Buffer, key: crypto.CipherKey, iv: string, method: string, output: 'buffer'): Buffer | false;
+export declare function aesEncrypt(original: string | Buffer, key: crypto.CipherKey, iv?: string, method?: string, output?: 'base64'): string | false;
+export declare function sm4Encrypt(original: string | Buffer, key: crypto.CipherKey, iv: string, method: string, output: 'buffer'): Buffer | false;
+export declare function sm4Encrypt(original: string | Buffer, key: crypto.CipherKey, iv?: string, method?: string, output?: 'base64'): string | false;
+export declare function cipherDecrypt(encrypt: string | Buffer, key: crypto.CipherKey, iv?: string, method?: string, output?: 'binary' | 'buffer'): string | Buffer | false;
+export declare function aesDecrypt(encrypt: string | Buffer, key: crypto.CipherKey, iv: string, method: string, output: 'buffer'): Buffer | false;
+export declare function aesDecrypt(encrypt: string | Buffer, key: crypto.CipherKey, iv?: string, method?: string, output?: 'binary'): string | false;
+export declare function sm4Decrypt(encrypt: string | Buffer, key: crypto.CipherKey, iv: string, method: string, output: 'buffer'): Buffer | false;
+export declare function sm4Decrypt(encrypt: string | Buffer, key: crypto.CipherKey, iv?: string, method?: string, output?: 'binary'): string | false;
+export declare function hashHmac(algorithm: string, data: Buffer | string, key?: crypto.CipherKey, format?: 'hex' | 'base64'): string;
+export declare function hashHmac(algorithm: string, data: Buffer | string, key: crypto.CipherKey | undefined, format: 'buffer'): Buffer;
+export declare function hashHmacFile(algorithm: string, path: string, key?: crypto.CipherKey, encoding?: 'hex' | 'base64' | 'base64url'): Promise<string | false>;
+export declare function hashHmacFile(algorithm: string, path: string, key: crypto.CipherKey, encoding: 'buffer'): Promise<Buffer | false>;
+export declare function base64Encode(data: string | Buffer): string;
+export declare function base64Decode(data: string, encoding: 'buffer'): Buffer;
+export declare function base64Decode(data: string, encoding?: 'utf8'): string;
+export declare function uuid(options?: crypto.RandomUUIDOptions): string;

package/lib/db.d.ts

@@ -0,0 +1,88 @@
+import * as mysql2 from 'mysql2/promise';
+import * as ctr from '~/sys/ctr';
+import * as types from '~/types';
+export interface IData {
+    'rows': any[] | null;
+    'fields': mysql2.FieldPacket[];
+    'error': {
+        'message': string;
+        'errno': number;
+        [key: string]: any;
+    } | null;
+}
+export interface IPacket {
+    'packet': mysql2.ResultSetHeader | null;
+    'fields': mysql2.FieldPacket[];
+    'error': {
+        'message': string;
+        'errno': number;
+        [key: string]: any;
+    } | null;
+}
+export interface IConnectionInfo {
+    'id': number;
+    'last': number;
+    'host': string;
+    'port': number;
+    'name': string;
+    'user': string;
+    'lost': boolean;
+    'using': boolean;
+    'transaction': boolean;
+}
+export declare class Pool {
+    private _queries;
+    private readonly _etc;
+    constructor(etc: types.IConfigDb);
+    query(sql: string, values?: types.DbValue[]): Promise<IData>;
+    execute(sql: string, values?: types.DbValue[]): Promise<IPacket>;
+    beginTransaction(ctr: ctr.Ctr | null): Promise<Transaction | null>;
+    private _getConnection;
+    getQueries(): number;
+}
+export declare class Transaction {
+    private _queries;
+    private _conn;
+    private readonly _ctr;
+    private readonly _timer;
+    constructor(ctr: ctr.Ctr | null, conn: Connection, opts?: {
+        'warning'?: number;
+        'danger'?: number;
+    });
+    query(sql: string, values?: types.DbValue[]): Promise<IData>;
+    execute(sql: string, values?: types.DbValue[]): Promise<IPacket>;
+    commit(): Promise<boolean>;
+    rollback(): Promise<boolean>;
+}
+export declare class Connection {
+    private _last;
+    private readonly _lastSql;
+    private readonly _link;
+    private _using;
+    private _lost;
+    private _transaction;
+    private readonly _etc;
+    constructor(etc: types.IConfigDb, link: mysql2.Connection);
+    getEtc(): types.IConfigDb;
+    getLast(): number;
+    getLastSql(): Array<{
+        'sql': string;
+        'values'?: types.DbValue[];
+    }>;
+    setLost(): void;
+    isLost(): boolean;
+    isTransaction(): boolean;
+    isUsing(): boolean;
+    using(): boolean;
+    used(): void;
+    refreshLast(): void;
+    isAvailable(): Promise<boolean>;
+    query(sql: string, values?: types.DbValue[]): Promise<IData>;
+    execute(sql: string, values?: types.DbValue[]): Promise<IPacket>;
+    end(): Promise<boolean>;
+    beginTransaction(): Promise<boolean>;
+    commit(): Promise<boolean>;
+    rollback(): Promise<boolean>;
+}
+export declare function get(ctrEtc: ctr.Ctr | types.IConfigDb): Pool;
+export declare function getConnectionList(): IConnectionInfo[];

package/lib/dns.d.ts

@@ -0,0 +1,75 @@
+import * as ctr from '~/sys/ctr';
+export declare enum ESERVICE {
+    'DNSPOD' = 0,
+    'ALIBABA' = 1
+}
+export interface IOptions {
+    'service': ESERVICE;
+    'secretId'?: string;
+    'secretKey'?: string;
+}
+export interface IDomainList {
+    'total': number;
+    'list': Array<{
+        'id': string;
+        'name': string;
+        'count': number;
+        'punyCode': string;
+    }>;
+}
+export interface IAddDomainRecord {
+    'success': boolean;
+    'id': string;
+}
+export declare const RECORD_TYPE: {
+    A: string;
+    NS: string;
+    MX: string;
+    TXT: string;
+    CNAME: string;
+    SRV: string;
+    AAAA: string;
+};
+export declare enum ERecordLine {
+    'DEFAULT' = 0,
+    'TELECOM' = 1,
+    'UNICOM' = 2,
+    'MOBILE' = 3,
+    'EDU' = 4,
+    'OVERSEA' = 5
+}
+export declare class Dns {
+    private readonly _opt;
+    constructor(ctr: ctr.Ctr, opt: IOptions);
+    private _send;
+    getDomainList(opt: {
+        'offset'?: number;
+        'length'?: number;
+    }): Promise<IDomainList | null>;
+    addDomainRecord(opt: {
+        'domain': string;
+        'sub': string;
+        'type': string;
+        'value': string;
+        'line'?: number;
+        'ttl'?: number;
+        'mx'?: number;
+    }): Promise<IAddDomainRecord | null>;
+    updateDomainRecord(opt: {
+        'domain': string;
+        'record': string;
+        'sub': string;
+        'type': string;
+        'value': string;
+        'line'?: number;
+        'ttl'?: number;
+        'mx'?: number;
+    }): Promise<IAddDomainRecord | null>;
+    deleteDomainRecord(opt: {
+        'domain': string;
+        'id': string;
+    }): Promise<{
+        'success': boolean;
+    } | null>;
+}
+export declare function get(ctr: ctr.Ctr, opt: IOptions): Dns;

package/lib/fs.d.ts

@@ -0,0 +1,49 @@
+import * as fs from 'fs';
+import * as http from 'http';
+import * as http2 from 'http2';
+export declare function getContent(path: string, options?: {
+    'start'?: number;
+    'end'?: number;
+}): Promise<Buffer | null>;
+export declare function getContent(path: string, options: BufferEncoding | {
+    'encoding': BufferEncoding;
+    'start'?: number;
+    'end'?: number;
+}): Promise<string | null>;
+export declare function putContent(path: string, data: string | Buffer, options?: {
+    'encoding'?: BufferEncoding;
+    'mode'?: number;
+    'flag'?: string;
+}): Promise<boolean>;
+export declare function readLink(path: string, encoding?: BufferEncoding): Promise<string | null>;
+export declare function symlink(filePath: string, linkPath: string, type?: 'dir' | 'file' | 'junction'): Promise<boolean>;
+export declare function unlink(path: string): Promise<boolean>;
+export declare function stats(path: string): Promise<fs.Stats | null>;
+export declare function isDir(path: string): Promise<fs.Stats | false>;
+export declare function isFile(path: string): Promise<fs.Stats | false>;
+export declare function mkdir(path: string, mode?: number): Promise<boolean>;
+export declare function rmdir(path: string): Promise<boolean>;
+export declare function rmdirDeep(path: string): Promise<boolean>;
+export declare function chmod(path: string, mod: string | number): Promise<boolean>;
+export declare function rename(oldPath: string, newPath: string): Promise<boolean>;
+export declare function readDir(path: string, encoding?: BufferEncoding): Promise<fs.Dirent[]>;
+export declare function copyFolder(from: string, to: string, ignore?: RegExp[]): Promise<number>;
+export declare function copyFile(src: string, dest: string): Promise<boolean>;
+export declare function createReadStream(path: string, options?: BufferEncoding | {
+    'flags'?: string;
+    'encoding'?: BufferEncoding;
+    'autoClose'?: boolean;
+    'start'?: number;
+    'end'?: number;
+}): fs.ReadStream;
+export declare function pipe(path: string, destination: NodeJS.WritableStream, options?: {
+    'end'?: boolean;
+}): Promise<boolean>;
+export declare function createWriteStream(path: string, options?: BufferEncoding | {
+    'flags'?: string;
+    'encoding'?: BufferEncoding;
+    'mode'?: number;
+    'autoClose'?: boolean;
+    'start'?: number;
+}): fs.WriteStream;
+export declare function readToResponse(path: string, req: http2.Http2ServerRequest | http.IncomingMessage, res: http2.Http2ServerResponse | http.ServerResponse, stat?: fs.Stats | null): Promise<void>;

package/lib/jwt.d.ts

@@ -0,0 +1,30 @@
+import * as kv from '~/lib/kv';
+import * as ctr from '~/sys/ctr';
+import * as types from '~/types';
+export interface IOptions {
+    'name'?: string;
+    'ttl'?: number;
+    'ssl'?: boolean;
+    'secret'?: string;
+    'auth'?: boolean;
+}
+export declare class Jwt {
+    private _link?;
+    private _name;
+    private _ttl;
+    private _ssl;
+    private _secret;
+    private _auth;
+    private _ctr;
+    init(ctr: ctr.Ctr, opt?: IOptions, link?: kv.Pool): Promise<boolean>;
+    renew(): string;
+    clearCookie(): void;
+    destory(): Promise<{
+        token: string;
+        exp: number;
+    } | boolean>;
+}
+export declare function getOrigin(ctr: ctr.Ctr, name?: string, auth?: boolean): string;
+export declare function decode(ctr: ctr.Ctr, val: string, link?: kv.Pool, name?: string, secret?: string): Promise<Record<string, types.DbValue> | false>;
+export declare function block(ctr: ctr.Ctr, token: string, exp: number, link: kv.Pool, name?: string): Promise<boolean>;
+export declare function get(ctr: ctr.Ctr, opt?: IOptions, link?: kv.Pool): Promise<Jwt>;

package/lib/kv.d.ts

@@ -0,0 +1,111 @@
+import * as redis from '@litert/redis';
+import * as ctr from '~/sys/ctr';
+import * as types from '~/types';
+export interface IConnectionInfo {
+    'id': number;
+    'last': number;
+    'host': string;
+    'port': number;
+    'index': number;
+    'lost': boolean;
+}
+export declare class Pool {
+    private readonly _etc;
+    constructor(ctr: ctr.Ctr, etc?: types.IConfigKv);
+    set(key: string, val: object | string | number, ttl?: number, mod?: '' | 'nx' | 'xx'): Promise<boolean>;
+    add(key: string, val: object | string | number, ttl?: number): Promise<boolean>;
+    replace(key: string, val: object | string | number, ttl?: number): Promise<boolean>;
+    append(key: string, val: string): Promise<boolean>;
+    prepend(key: string, val: string): Promise<boolean>;
+    exists(keys: string | string[]): Promise<number>;
+    get(key: string): Promise<string | null>;
+    ttl(key: string): Promise<number | null>;
+    pttl(key: string): Promise<number | null>;
+    mSet(rows: Record<string, string | Buffer>): Promise<boolean>;
+    mGet(keys: string[]): Promise<Record<string, string | null>>;
+    getJson(key: string): Promise<any | null>;
+    del(keys: string | string[]): Promise<boolean>;
+    incr(key: string, num?: number): Promise<number | false>;
+    decr(key: string, num?: number): Promise<number | false>;
+    expire(key: string, ttl: number): Promise<boolean>;
+    keys(pattern: string): Promise<string[] | false>;
+    scan(cursor?: number, pattern?: string, count?: number): Promise<redis.IScanResult<string> | false>;
+    flushDb(): Promise<boolean>;
+    ping(): Promise<string | false>;
+    hSet(key: string, field: string, val: object | string | number, mod?: '' | 'nx'): Promise<boolean>;
+    hMSet(key: string, rows: Record<string, object | string | number>): Promise<boolean>;
+    hGet(key: string, field: string): Promise<string | null>;
+    hGetJson(key: string, field: string): Promise<any | null>;
+    hMGet(key: string, fields: string[]): Promise<Record<string, string | null>>;
+    hGetAll(key: string): Promise<Record<string, string | null> | null>;
+    hDel(key: string, fields: string | string[]): Promise<number>;
+    hExists(key: string, field: string): Promise<boolean>;
+    hIncr(key: string, field: string, increment: number): Promise<number>;
+    hKeys(key: string): Promise<string[]>;
+    lPush(key: string, values: Array<string | Buffer>): Promise<number>;
+    rPush(key: string, values: Array<string | Buffer>): Promise<number>;
+    bLMove(sourceKey: string, destKey: string, soo: 'LEFT' | 'RIGHT', deo: 'LEFT' | 'RIGHT', timeout: number): Promise<string | null>;
+    lPop(key: string): Promise<string | null>;
+    rPop(key: string): Promise<string | null>;
+    bRPop(key: string | string[], timeout: number): Promise<Record<string, string>>;
+    lRange(key: string, start: number, stop: number): Promise<string[]>;
+    lLen(key: string): Promise<number>;
+    private _getConnection;
+}
+export declare class Connection {
+    private _last;
+    private readonly _link;
+    private _using;
+    private _lost;
+    private readonly _etc;
+    constructor(etc: types.IConfigKv, link: redis.ICommandClient);
+    getEtc(): types.IConfigKv;
+    getLast(): number;
+    setLost(): void;
+    isLost(): boolean;
+    setUsing(): void;
+    isUsing(): boolean;
+    used(): void;
+    refreshLast(): void;
+    end(): Promise<void>;
+    set(key: string, val: object | string | number, ttl: number, mod: '' | 'nx' | 'xx', etc: types.IConfigKv): Promise<boolean>;
+    add(key: string, val: object | string | number, ttl: number, etc: types.IConfigKv): Promise<boolean>;
+    replace(key: string, val: object | string | number, ttl: number, etc: types.IConfigKv): Promise<boolean>;
+    append(key: string, val: string, etc: types.IConfigKv): Promise<boolean>;
+    prepend(key: string, val: string, etc: types.IConfigKv): Promise<boolean>;
+    exists(keys: string | string[], etc: types.IConfigKv): Promise<number>;
+    get(key: string, etc: types.IConfigKv): Promise<string | null>;
+    ttl(key: string, etc: types.IConfigKv): Promise<number | null>;
+    pttl(key: string, etc: types.IConfigKv): Promise<number | null>;
+    mGet(keys: string[], etc: types.IConfigKv): Promise<Record<string, string | null>>;
+    mSet(rows: Record<string, string | Buffer>, etc: types.IConfigKv): Promise<boolean>;
+    getJson(key: string, etc: types.IConfigKv): Promise<any | null>;
+    del(keys: string | string[], etc: types.IConfigKv): Promise<boolean>;
+    incr(key: string, num: number, etc: types.IConfigKv): Promise<number | false>;
+    decr(key: string, num: number, etc: types.IConfigKv): Promise<number | false>;
+    expire(key: string, ttl: number, etc: types.IConfigKv): Promise<boolean>;
+    keys(pattern: string, etc: types.IConfigKv): Promise<string[] | false>;
+    scan(cursor: number, pattern: string, count: number, etc: types.IConfigKv): Promise<redis.IScanResult<string> | false>;
+    flushDb(): Promise<boolean>;
+    ping(): Promise<false | string>;
+    hSet(key: string, field: string, val: object | string | number, mod: '' | 'nx', etc: types.IConfigKv): Promise<boolean>;
+    hMSet(key: string, rows: Record<string, object | string | number>, etc: types.IConfigKv): Promise<boolean>;
+    hGet(key: string, field: string, etc: types.IConfigKv): Promise<string | null>;
+    hGetJson(key: string, field: string, etc: types.IConfigKv): Promise<any | null>;
+    hMGet(key: string, fields: string[], etc: types.IConfigKv): Promise<Record<string, string | null>>;
+    hGetAll(key: string, etc: types.IConfigKv): Promise<Record<string, string | null> | null>;
+    hDel(key: string, fields: string | string[], etc: types.IConfigKv): Promise<number>;
+    hExists(key: string, field: string, etc: types.IConfigKv): Promise<boolean>;
+    hIncr(key: string, field: string, increment: number, etc: types.IConfigKv): Promise<number>;
+    hKeys(key: string, etc: types.IConfigKv): Promise<string[]>;
+    lPush(key: string, values: Array<string | Buffer>, etc: types.IConfigKv): Promise<number>;
+    rPush(key: string, values: Array<string | Buffer>, etc: types.IConfigKv): Promise<number>;
+    bLMove(sourceKey: string, destKey: string, soo: 'LEFT' | 'RIGHT', deo: 'LEFT' | 'RIGHT', timeout: number, etc: types.IConfigKv): Promise<string | null>;
+    lPop(key: string, etc: types.IConfigKv): Promise<string | null>;
+    rPop(key: string, etc: types.IConfigKv): Promise<string | null>;
+    bRPop(key: string | string[], timeout: number, etc: types.IConfigKv): Promise<Record<string, string>>;
+    lRange(key: string, start: number, stop: number, etc: types.IConfigKv): Promise<string[]>;
+    lLen(key: string, etc: types.IConfigKv): Promise<number>;
+}
+export declare function get(ctr: ctr.Ctr, etc?: types.IConfigKv): Pool;
+export declare function getConnectionList(): IConnectionInfo[];

package/lib/lan.d.ts

@@ -0,0 +1,10 @@
+export declare function card(): Promise<Array<{
+    'name': string;
+    'mac': string;
+    'iPv4': string;
+    'iPv6': string;
+}>>;
+export declare function scan(): Promise<Array<{
+    'mac': string;
+    'iPv4': string;
+}>>;

package/lib/net/formdata.d.ts

@@ -0,0 +1,23 @@
+import * as stream from 'stream';
+export interface IItem {
+    'key': string;
+    'isFile': boolean;
+    'isString': boolean;
+    'value': string;
+    'path': string;
+}
+export declare class FormData extends stream.Readable {
+    private _num;
+    private readonly _data;
+    private readonly _boundary;
+    private _fileReading;
+    private _close;
+    private _length;
+    private _sent;
+    putString(key: string, val: string): void;
+    putFile(key: string, path: string, fname?: string): Promise<boolean>;
+    getBoundary(): string;
+    getLength(): number;
+    getSent(): number;
+    _read(): void;
+}

package/lib/net/request.d.ts

@@ -0,0 +1,23 @@
+import * as stream from 'stream';
+import * as response from './response';
+import * as types from '~/types';
+export declare class Request {
+    private _data;
+    private readonly _url;
+    private _opt;
+    constructor(url: string);
+    data(data: Record<string, any> | Buffer | string | stream.Readable): this;
+    method(method: 'GET' | 'POST'): this;
+    get(): this;
+    post(): this;
+    type(type: 'form' | 'json'): this;
+    json(): this;
+    timeout(timeout: number): this;
+    follow(follow?: number): this;
+    hosts(hosts: Record<string, string>): this;
+    save(save: string): this;
+    local(addr: string): this;
+    headers(headers: types.THttpHeaders): this;
+    setHeader(name: string, val: string): this;
+    request(cookie?: Record<string, types.ICookie>): Promise<response.Response>;
+}

package/lib/net/response.d.ts

@@ -0,0 +1,14 @@
+import * as hc from '@litert/http-client';
+import * as nStream from 'stream';
+import * as types from '~/types';
+export declare class Response {
+    private readonly _req;
+    headers: types.THttpHeaders | null;
+    error: Error | null;
+    private _content;
+    constructor(req: hc.IResponse | null);
+    getContent(): Promise<Buffer | null>;
+    setContent(v: string | Buffer): void;
+    getStream(): nStream.Readable;
+    getRawStream(): nStream.Readable;
+}