@maiyunnet/kebab 2.0.4 → 2.0.6

package/sys/mod.d.ts

@@ -0,0 +1,205 @@
+import * as lSql from '../lib/sql';
+import * as lDb from '../lib/db';
+import * as sCtr from '../sys/ctr';
+import * as types from '../types';
+declare class Rows<T extends Mod> implements types.Rows<T> {
+    private readonly _items;
+    constructor(initialItems?: T[]);
+    get length(): number;
+    item(index: number): T;
+    toArray(): Array<Record<string, any>>;
+    filter(predicate: (value: T, index: number) => boolean): Rows<T>;
+    map<TU>(allbackfn: (value: T, index: number) => TU): TU[];
+    [Symbol.iterator](): Iterator<T>;
+}
+export default class Mod {
+    protected static _$table: string;
+    protected static _$primary: string;
+    protected static _$key: string;
+    protected static _$soft: boolean;
+    protected _updates: Record<string, boolean>;
+    protected _data: Record<string, any>;
+    protected _index: string[] | null;
+    protected _contain: {
+        'key': string;
+        'list': string[];
+    } | null;
+    protected _total: number[];
+    protected _db: lDb.Pool | lDb.Transaction;
+    protected _sql: lSql.Sql;
+    protected _ctr?: sCtr.Ctr;
+    constructor(opt: {
+        'db': lDb.Pool | lDb.Transaction;
+        'ctr'?: sCtr.Ctr;
+        'index'?: string | string[];
+        'alias'?: string;
+        'row'?: Record<string, any>;
+        'select'?: string | string[];
+        'where'?: string | types.Json;
+        'contain'?: {
+            'key': string;
+            'list': string[];
+        };
+        'raw'?: boolean;
+        'pre'?: string;
+    });
+    static column(field: string): {
+        'type': 'column';
+        'token': string;
+        'value': string;
+    };
+    static insert(db: lDb.Pool | lDb.Transaction, cs: string[] | Record<string, any>, vs?: any[] | any[][], opt?: {
+        'pre'?: sCtr.Ctr | string;
+        'index'?: string;
+    }): Promise<boolean | null | false>;
+    static insertSql(cs: string[] | Record<string, any>, vs?: any[] | any[][], opt?: {
+        'pre'?: sCtr.Ctr | string;
+        'index'?: string;
+    }): string;
+    static insertDuplicate(db: lDb.Pool | lDb.Transaction, data: Record<string, any>, update: types.Json, opt?: {
+        'pre'?: sCtr.Ctr | string;
+        'index'?: string;
+    }): Promise<boolean | null>;
+    static removeByWhere(db: lDb.Pool | lDb.Transaction, where: string | types.Json, opt?: {
+        'raw'?: boolean;
+        'pre'?: sCtr.Ctr | string;
+        'index'?: string;
+        'by'?: [string | string[], 'DESC' | 'ASC'];
+        'limit'?: [number, number?];
+    }): Promise<number | false | null>;
+    static removeByWhereSql(db: lDb.Pool | lDb.Transaction, where: string | types.Json, opt?: {
+        'raw'?: boolean;
+        'pre'?: sCtr.Ctr | string;
+        'index'?: string;
+        'by'?: [string | string[], 'DESC' | 'ASC'];
+        'limit'?: [number, number?];
+    }): lSql.Sql;
+    static updateByWhere(db: lDb.Pool | lDb.Transaction, data: types.Json, where: string | types.Json, opt?: {
+        'raw'?: boolean;
+        'pre'?: sCtr.Ctr | string;
+        'index'?: string | string[];
+        'by'?: [string | string[], 'DESC' | 'ASC'];
+        'limit'?: [number, number?];
+    }): Promise<number | false | null>;
+    static updateByWhereSql(data: types.Json, where: string | types.Json, opt?: {
+        'raw'?: boolean;
+        'pre'?: sCtr.Ctr | string;
+        'index'?: string;
+        'by'?: [string | string[], 'DESC' | 'ASC'];
+        'limit'?: [number, number?];
+    }): lSql.Sql;
+    static select<T extends Mod>(db: lDb.Pool | lDb.Transaction, c: string | string[], opt?: {
+        'ctr'?: sCtr.Ctr;
+        'pre'?: string;
+        'index'?: string | string[];
+        'alias'?: string;
+        'contain'?: {
+            'key': string;
+            'list': string[];
+        };
+    }): T & Record<string, any>;
+    static where<T extends Mod>(db: lDb.Pool | lDb.Transaction, s?: string | types.Json, opt?: {
+        'ctr'?: sCtr.Ctr;
+        'raw'?: boolean;
+        'pre'?: string;
+        'index'?: string | string[];
+        'contain'?: {
+            'key': string;
+            'list': string[];
+        };
+    }): T & Record<string, any>;
+    static getCreate<T extends Mod>(db: lDb.Pool | lDb.Transaction, opt?: {
+        'ctr'?: sCtr.Ctr;
+        'pre'?: string;
+        'index'?: string;
+    }): T;
+    static find<T extends Mod>(db: lDb.Pool | lDb.Transaction, val: string | number | null, opt?: {
+        'ctr'?: sCtr.Ctr;
+        'lock'?: boolean;
+        'raw'?: boolean;
+        'pre'?: string;
+        'index'?: string;
+    }): Promise<false | null | (T & Record<string, any>)>;
+    static one(db: lDb.Pool | lDb.Transaction, s: string | types.Json, opt: {
+        'ctr'?: sCtr.Ctr;
+        'raw'?: boolean;
+        'pre'?: string;
+        'index'?: string | string[];
+        'select'?: string | string[];
+        'by'?: [string | string[], 'DESC' | 'ASC'];
+        'array': true;
+    }): Promise<false | null | Record<string, any>>;
+    static one<T extends Mod>(db: lDb.Pool | lDb.Transaction, s: string | types.Json, opt: {
+        'ctr'?: sCtr.Ctr;
+        'raw'?: boolean;
+        'pre'?: string;
+        'index'?: string | string[];
+        'select'?: string | string[];
+        'by'?: [string | string[], 'DESC' | 'ASC'];
+        'array'?: false;
+    }): Promise<false | null | (T & Record<string, any>)>;
+    static oneArray(db: lDb.Pool | lDb.Transaction, s: string | types.Json, opt?: {
+        'ctr'?: sCtr.Ctr;
+        'raw'?: boolean;
+        'pre'?: string;
+        'index'?: string | string[];
+        'select'?: string | string[];
+    }): Promise<false | null | Record<string, any>>;
+    static primarys(db: lDb.Pool | lDb.Transaction, where?: string | types.Json, opt?: {
+        'ctr'?: sCtr.Ctr;
+        'raw'?: boolean;
+        'pre'?: string;
+        'index'?: string;
+    }): Promise<any[] | false>;
+    static toArrayByRecord<T extends Mod>(obj: Record<string, T>): Record<string, Record<string, any>>;
+    set<T extends this, TK extends keyof T>(n: Record<TK, T[TK] | undefined>): void;
+    set<T extends this, TK extends keyof T>(n: TK, v: T[TK]): void;
+    get(n: string): any;
+    create(notWhere?: string | types.Json, table?: string): Promise<boolean>;
+    replace(): Promise<boolean>;
+    refresh(lock?: boolean): Promise<boolean | null>;
+    save(): Promise<boolean>;
+    remove(raw?: boolean): Promise<boolean>;
+    first(lock: boolean, array: true): Promise<false | null | Record<string, any>>;
+    first(lock?: boolean, array?: false): Promise<false | null | (this & Record<string, any>)>;
+    firstArray(lock?: boolean): Promise<Record<string, any> | false | null>;
+    union(f: lSql.Sql | string | types.IModUnionItem | string[] | types.IModUnionItem[], type?: string): this;
+    unionAll(f: lSql.Sql | string | types.IModUnionItem | string[] | types.IModUnionItem[]): this;
+    all(): Promise<false | Rows<this>>;
+    all(key: string): Promise<false | Record<string, this>>;
+    allArray(): Promise<false | Array<Record<string, any>>>;
+    allArray(key: string): Promise<false | Record<string, Record<string, any>>>;
+    explain(all?: false): Promise<false | string>;
+    explain(all: true): Promise<false | Record<string, any>>;
+    private _formatTotal;
+    total(f?: string): Promise<number>;
+    count(): Promise<number>;
+    join(f: string, s?: types.Json, type?: string, index?: string, pre?: string): this;
+    leftJoin(f: string, s: types.Json, index?: string, pre?: string): this;
+    rightJoin(f: string, s: types.Json, index?: string, pre?: string): this;
+    innerJoin(f: string, s: types.Json, index?: string, pre?: string): this;
+    fullJoin(f: string, s: types.Json, index?: string, pre?: string): this;
+    crossJoin(f: string, s: types.Json, index?: string, pre?: string): this;
+    having(s: types.Json): this;
+    filter(s: types.Json, raw?: boolean): this;
+    where(s: types.Json, raw?: boolean): this;
+    by(c: string | Array<string | string[]>, d?: 'DESC' | 'ASC'): this;
+    group(c: string | string[]): this;
+    private _limit;
+    limit(a: number, b?: number): this;
+    page(count: number, page?: number): this;
+    append(sql: string): this;
+    contain(contain: {
+        'key': string;
+        'list': string[];
+    }): this;
+    getSql(): string;
+    getData(): any[];
+    format(sql?: string, data?: any[]): string;
+    toArray(): Record<string, any>;
+    updates(): Record<string, any>;
+    unsaved(): boolean;
+    langText(col: string, lang: string): string;
+    protected _keyGenerator(): string;
+}
+export {};

package/sys/mod.js

@@ -33,11 +33,11 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-const lSql = __importStar(require("~/lib/sql"));
-const lTime = __importStar(require("~/lib/time"));
-const lCore = __importStar(require("~/lib/core"));
-const lText = __importStar(require("~/lib/text"));
-const sCtr = __importStar(require("~/sys/ctr"));
+const lSql = __importStar(require("../lib/sql"));
+const lTime = __importStar(require("../lib/time"));
+const lCore = __importStar(require("../lib/core"));
+const lText = __importStar(require("../lib/text"));
+const sCtr = __importStar(require("../sys/ctr"));
 class Rows {
     constructor(initialItems = []) {
         this._items = [];

package/sys/route.d.ts

@@ -0,0 +1,31 @@
+import * as http from 'http';
+import * as http2 from 'http2';
+import * as net from 'net';
+import * as sCtr from './ctr';
+import * as types from '../types';
+export declare function clearKebabConfigs(): void;
+export declare function run(data: {
+    'req': http2.Http2ServerRequest | http.IncomingMessage;
+    'res'?: http2.Http2ServerResponse | http.ServerResponse;
+    'socket'?: net.Socket;
+    'uri': types.IUrlParse;
+    'rootPath': string;
+    'urlBase': string;
+    'path': string;
+    'timer'?: {
+        'timer': NodeJS.Timeout;
+        'timeout': number;
+        'callback': () => void;
+    };
+}): Promise<boolean>;
+export declare function unlinkUploadFiles(cctr: sCtr.Ctr | Record<string, types.IPostFile | types.IPostFile[]>): Promise<void>;
+export declare function waitCtr(cctr: sCtr.Ctr): Promise<void>;
+export declare function trimPost(post: Record<string, types.Json>): void;
+export declare function getFormData(req: http2.Http2ServerRequest | http.IncomingMessage, events?: {
+    onfilestart?: (name: string) => boolean | undefined;
+    onfiledata?: (chunk: Buffer) => void;
+    onfileend?: () => void;
+}): Promise<{
+    'post': Record<string, types.Json>;
+    'files': Record<string, types.IPostFile | types.IPostFile[]>;
+} | false>;

package/sys/route.js

@@ -42,15 +42,15 @@ exports.getFormData = getFormData;
 const http = __importStar(require("http"));
 const stream = __importStar(require("stream"));
 const ws = __importStar(require("@litert/websocket"));
-const lFs = __importStar(require("~/lib/fs"));
-const lZlib = __importStar(require("~/lib/zlib"));
-const lCore = __importStar(require("~/lib/core"));
-const lText = __importStar(require("~/lib/text"));
-const lTime = __importStar(require("~/lib/time"));
-const lResponse = __importStar(require("~/lib/net/response"));
-const lWs = __importStar(require("~/lib/ws"));
+const lFs = __importStar(require("../lib/fs"));
+const lZlib = __importStar(require("../lib/zlib"));
+const lCore = __importStar(require("../lib/core"));
+const lText = __importStar(require("../lib/text"));
+const lTime = __importStar(require("../lib/time"));
+const lResponse = __importStar(require("../lib/net/response"));
+const lWs = __importStar(require("../lib/ws"));
 const sCtr = __importStar(require("./ctr"));
-const kebab = __importStar(require("~/index"));
+const kebab = __importStar(require("../index"));
 let kebabConfigs = {};
 function clearKebabConfigs() {
     kebabConfigs = {};

package/types/index.d.ts

@@ -0,0 +1,283 @@
+/**
+ * Project: Kebab, User: JianSuoQiYue
+ * Date: 2022-07-22 13:44:12
+ * Last: 2022-07-22 13:44:12, 2023-5-2 21:12:32, 2023-12-14 11:43:09
+ */
+import * as http from 'http';
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+/** --- 除非确定是不可知的 Json，否则不能使用 --- */
+export type Json = any;
+
+/* eslint-enable */
+
+/** --- 数据库值的类型 --- */
+export type DbValue = string | number | null | Record<string, Json>;
+
+/** --- mod ls 对象 --- */
+export declare class Rows<T> implements Iterable<T> {
+
+    /** --- 总行数 --- */
+    public get length(): number;
+
+    /** --- 通过索引获取一个对象 --- */
+    public item(index: number): T;
+
+    /** --- 转换为数组对象 --- */
+    public toArray(): Array<Record<string, DbValue>>;
+
+    public [Symbol.iterator](): Iterator<T>;
+
+}
+
+/** --- 虚拟机配置对象 --- */
+export interface IVhost {
+    readonly 'name': string;
+    readonly 'domains': string[];
+    readonly 'root': string;
+    readonly 'remark': string;
+}
+
+/** --- 上传的文件信息对象 --- */
+export interface IPostFile {
+    readonly 'name': string;
+    readonly 'origin': string;
+    readonly 'size': number;
+    readonly 'path': string;
+}
+
+/** --- 动态目录配置文件 --- */
+export interface IConfig {
+    'set': {
+        'timezone': number;
+        'mustHttps': boolean;
+        'cacheTtl': number;
+
+        'staticVer': string;
+        'staticPath': string;
+        'staticPathFull': string;
+
+        [key: string]: Json;
+    };
+    'const': IConfigConst;
+    'db': IConfigDb;
+    'jwt': IConfigJwt;
+    'kv': IConfigKv;
+    'route': Record<string, string>;
+    'session': {
+        'name': string;
+        'ttl': number;
+        'ssl': boolean;
+    };
+    'sql': IConfigSql;
+    'dns': Record<string, IConfigDns>;
+    'lang': IConfigLang;
+    's3': Record<string, IConfigS3>;
+    'turnstile': IConfigTurnstile;
+
+    [key: string]: Record<string, Json>;
+}
+
+/** --- 动配数据库 --- */
+export interface IConfigLang {
+    'list': string[];
+    'direct': string[];
+}
+
+/** --- 动配对象存储信息 --- */
+export interface IConfigS3 {
+    /** --- cf r2 要用 --- */
+    'account'?: string;
+    'sid': string;
+    'skey': string;
+    'region': string;
+    'bucket': string;
+}
+
+/** --- 动配对象存储信息 --- */
+export interface IConfigTurnstile {
+    'CF': {
+        'sid': string;
+        'skey': string;
+    },
+    'TENCENT': {
+        'sid': string;
+        'skey': string;
+        'aid': string;
+        'akey': string;
+    }
+}
+
+/** --- 动配数据库 --- */
+export interface IConfigDb {
+    'host': string;
+    'port': number;
+    'charset': string;
+    'name': string;
+
+    'user': string;
+    'pwd': string;
+}
+
+/** --- Jwt 信息 --- */
+export interface IConfigJwt {
+    'name': string;
+    'ttl': number;
+    'ssl': boolean;
+    'secret': string;
+    'auth': boolean;
+}
+
+/** --- DNS --- */
+export interface IConfigDns {
+    'sid': string;
+    'skey': string;
+}
+
+/** --- 动配 kv --- */
+export interface IConfigKv {
+    'host': string;
+    'port': number;
+    'index': number;
+    'pre': string;
+
+    'user': string;
+    'pwd': string;
+}
+
+/** --- 动配 sql --- */
+export interface IConfigSql {
+    'pre': string;
+}
+
+/** --- 动配常量 --- */
+export interface IConfigConst {
+    'path': string;
+    'qs': string;
+    'startTime': bigint;
+    'startMemory': number;
+
+    // --- 环境判断 ---
+
+    'mobile': boolean;
+    'wechat': boolean;
+    'https': boolean;
+    'host': string;
+    'hostname': string;
+    'hostport': number;
+    'uri': IUrlParse;
+
+    // --- 服务端用的路径 ---
+
+    'rootPath': string;
+    'modPath': string;
+    'ctrPath': string;
+    'viewPath': string;
+    'dataPath': string;
+    'wsPath': string;
+
+    // --- 前端用的路径 ---
+
+    'urlBase': string;
+    'urlStc': string;
+    'urlFull': string;
+    'urlStcFull': string;
+}
+
+/** --- http headers --- */
+/* eslint-disable @typescript-eslint/naming-convention */
+export type THttpHeaders = http.IncomingHttpHeaders & {
+    'http-version'?: '1.1' | '2.0';
+    'http-code'?: number;
+    'http-url'?: string;
+};
+/* eslint-enable */
+
+/** --- Net Cookie 对象 --- */
+export interface ICookie {
+    'name': string;
+    'value': string;
+    /** --- 有效期秒级时间戳 --- */
+    'exp': number;
+    'path': string;
+    'domain': string;
+    'secure': boolean;
+    'httponly': boolean;
+}
+
+export interface IUrlParse {
+    'protocol': string | null;
+    'auth': string | null;
+    'user': string | null;
+    'pass': string | null;
+    'host': string | null;
+    'hostname': string | null;
+    'port': string | null;
+    'pathname': string;
+    'path': string | null;
+    'query': string | null;
+    'hash': string | null;
+}
+
+export interface IModUnionItem {
+    'field': string;
+    'where'?: any;
+}
+
+// -------------------------
+// -------- zip lib --------
+// -------------------------
+
+export interface IZipItem {
+    'name': string;
+    'compressedSize': number;
+    'uncompressedSize': number;
+    'date': Date;
+    'isFile': boolean;
+    'isDirectory': boolean;
+    'path': string;
+}
+
+export interface IZipStats {
+    'compressedSize': number;
+    'uncompressedSize': number;
+    'date': Date;
+    'isFile': boolean;
+    'isDirectory': boolean;
+}
+
+export interface IZipOutputByType {
+    'base64': string;
+    'string': string;
+    'text': string;
+    'binarystring': string;
+    'array': number[];
+    'uint8array': Uint8Array;
+    'arraybuffer': ArrayBuffer;
+    'blob': Blob;
+    'nodebuffer': Buffer;
+}
+
+export type TZipOutputType = keyof IZipOutputByType;
+
+export interface IZipInputByType {
+    'base64': string;
+    'string': string;
+    'text': string;
+    'binarystring': string;
+    'array': number[];
+    'uint8array': Uint8Array;
+    'arraybuffer': ArrayBuffer;
+    'blob': Blob;
+    'nodebuffer': Buffer;
+}
+
+export type TZipInputType = keyof IZipInputByType;
+
+export type TZipInputFileFormat = IZipInputByType[keyof IZipInputByType];
+
+export interface IZipMetadata {
+    'percent': number;
+    'currentFile': string | null;
+}

package/www/example/ctr/main.d.ts

@@ -0,0 +1,4 @@
+import * as ctr from '../../../sys/ctr';
+export default class extends ctr.Ctr {
+    index(): string;
+}

package/www/example/ctr/main.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-const ctr = __importStar(require("~/sys/ctr"));
+const ctr = __importStar(require("../../../sys/ctr"));
 class default_1 extends ctr.Ctr {
     index() {
         return `<a href="${this._config.const.urlBase}test">Hello world! Click here to visit demo.</a>`;

package/www/example/ctr/middle.d.ts

@@ -0,0 +1,6 @@
+import * as ctr from '../../../sys/ctr';
+import * as types from '../../../types';
+export default class extends ctr.Ctr {
+    onLoad(): string | boolean;
+    onUnload(rtn: string | boolean | types.DbValue[]): string | boolean | types.DbValue[];
+}

package/www/example/ctr/middle.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-const ctr = __importStar(require("~/sys/ctr"));
+const ctr = __importStar(require("../../../sys/ctr"));
 class default_1 extends ctr.Ctr {
     onLoad() {
         if (this._config.const.path !== 'test/middle') {

package/www/example/ctr/test.d.ts

@@ -0,0 +1,94 @@
+import * as fs from 'fs';
+import * as sCtr from '../../../sys/ctr';
+import * as types from '../../../types';
+export default class extends sCtr.Ctr {
+    private _internalUrl;
+    onLoad(): Array<string | number> | boolean;
+    onUnload(rtn: string | boolean | types.DbValue[]): string | boolean | types.DbValue[];
+    notfound(): string;
+    index(): string;
+    article(): string;
+    qs(): string;
+    view(): Promise<string>;
+    json(): Array<number | string | object> | object;
+    ctrXsrf(): string;
+    ctrXsrf1(): types.Json[];
+    ctrCheckinput(): string;
+    ctrCheckinput1(): Promise<types.Json[]>;
+    ctrLocale(): Promise<types.Json[] | string>;
+    ctrCachettl(): string;
+    ctrHttpcode(): string;
+    ctrCross(): string;
+    ctrCross1(): types.Json[];
+    ctrCross2(): types.Json[];
+    ctrReadable(): fs.ReadStream;
+    ctrAsynctask(): any[];
+    ctrTimeout(): Promise<any[]>;
+    modTest(): Promise<types.Json[] | string | boolean>;
+    modSplit(): Promise<string>;
+    modSplit1(): Promise<void>;
+    modSplit2(): Promise<types.Json[]>;
+    captchaFastbuild(): string;
+    captchaBase64(): string;
+    coreRandom(): string;
+    coreRand(): string;
+    coreConvert62(): string;
+    corePurify(): string;
+    coreChecktype(): string;
+    coreMuid(): string;
+    coreGetlog(): Promise<string>;
+    coreUpdatecode(): Promise<string>;
+    coreReload(): Promise<string>;
+    coreRestart(): Promise<string>;
+    coreGlobal(): Promise<string>;
+    crypto(): Promise<string>;
+    db(): Promise<types.Json>;
+    private _dbTable;
+    kv(): Promise<types.Json>;
+    net(): Promise<string>;
+    netPipe(): Promise<types.Json>;
+    netPost(): Promise<types.Json>;
+    netPost1(): string;
+    netPostString(): Promise<string>;
+    netPostString1(): types.Json[];
+    netOpen(): Promise<types.Json>;
+    netFormTest(): Promise<string>;
+    netUpload(): Promise<string>;
+    netUpload1(): Promise<string>;
+    netCookie(): Promise<string>;
+    netCookie1(): string;
+    netCookie2(): string;
+    netSave(): Promise<string>;
+    netFollow(): Promise<string>;
+    netFollow1(): void;
+    netFollow2(): types.Json;
+    netReuse(): Promise<string>;
+    netError(): Promise<string>;
+    netHosts(): Promise<string>;
+    netRproxy(): Promise<string | boolean>;
+    netMproxy(): Promise<string | boolean>;
+    netMproxy1(): Promise<string | boolean>;
+    scan(): Promise<types.Json>;
+    scan1(): Promise<types.Json>;
+    scan2(): Promise<types.Json>;
+    scan3(): Promise<types.Json>;
+    private _scanLink;
+    session(): Promise<string | types.Json[]>;
+    jwt(): Promise<string | types.Json[]>;
+    jwt1(): Promise<[number, types.Json]>;
+    sql(): string;
+    consistentHash(): string;
+    consistentDistributed(): string;
+    consistentMigration(): string;
+    consistentFast(): string;
+    text(): string;
+    time(): string;
+    wsServer(): string;
+    wsClient(): Promise<string>;
+    ssh(): Promise<string | types.Json[]>;
+    s3(): Promise<string>;
+    zip(): Promise<string>;
+    buffer(): string;
+    lan(): Promise<string>;
+    private _getEnd;
+}