@hyext/builder-revues 1.5.9-alpha.0 → 1.5.10-alpha.1

package/static/projects/ts/typings/wechat-miniprogram/lib.wx.cloud.d.ts

@@ -0,0 +1,903 @@
+interface IAPIError {
+    errMsg: string;
+}
+
+interface IAPIParam<T = any> {
+    config?: ICloudConfig | undefined;
+    success?: ((res: T) => void) | undefined;
+    fail?: ((err: IAPIError) => void) | undefined;
+    complete?: ((val: T | IAPIError) => void) | undefined;
+}
+
+interface IAPISuccessParam {
+    errMsg: string;
+}
+
+type IAPICompleteParam = IAPISuccessParam | IAPIError;
+
+type IAPIFunction<T, P extends IAPIParam<T>> = (param?: P) => Promise<T>;
+
+interface IInitCloudConfig {
+    env?:
+        | string
+        | {
+            database?: string | undefined;
+            functions?: string | undefined;
+            storage?: string | undefined;
+        }
+        | undefined;
+    traceUser?: boolean | undefined;
+}
+
+interface ICloudConfig {
+    env?: string | undefined;
+    traceUser?: boolean | undefined;
+}
+
+interface IICloudAPI {
+    init: (config?: IInitCloudConfig) => void;
+    [api: string]: AnyFunction | IAPIFunction<any, any>;
+}
+
+interface ICloudService {
+    name: string;
+
+    getAPIs: () => { [name: string]: IAPIFunction<any, any> };
+}
+
+interface ICloudServices {
+    [serviceName: string]: ICloudService;
+}
+
+interface ICloudMetaData {
+    session_id: string;
+}
+
+declare class InternalSymbol {}
+
+interface AnyObject {
+    [x: string]: any;
+}
+
+type AnyArray = any[];
+
+type AnyFunction = (...args: any[]) => any;
+
+/**
+ * extend wx with cloud
+ */
+interface WxCloud {
+    init: (config?: ICloudConfig) => void;
+
+    callFunction(param: OQ<ICloud.CallFunctionParam>): void;
+    callFunction(
+        param: RQ<ICloud.CallFunctionParam>,
+    ): Promise<ICloud.CallFunctionResult>;
+
+    uploadFile(param: OQ<ICloud.UploadFileParam>): WechatMiniprogram.UploadTask;
+    uploadFile(
+        param: RQ<ICloud.UploadFileParam>,
+    ): Promise<ICloud.UploadFileResult>;
+
+    downloadFile(
+        param: OQ<ICloud.DownloadFileParam>,
+    ): WechatMiniprogram.DownloadTask;
+    downloadFile(
+        param: RQ<ICloud.DownloadFileParam>,
+    ): Promise<ICloud.DownloadFileResult>;
+
+    getTempFileURL(param: OQ<ICloud.GetTempFileURLParam>): void;
+    getTempFileURL(
+        param: RQ<ICloud.GetTempFileURLParam>,
+    ): Promise<ICloud.GetTempFileURLResult>;
+
+    deleteFile(param: OQ<ICloud.DeleteFileParam>): void;
+    deleteFile(
+        param: RQ<ICloud.DeleteFileParam>,
+    ): Promise<ICloud.DeleteFileResult>;
+
+    database: (config?: ICloudConfig) => DB.Database;
+
+    CloudID: ICloud.ICloudIDConstructor;
+    CDN: ICloud.ICDNConstructor;
+}
+
+declare namespace ICloud {
+    interface ICloudAPIParam<T = any> extends IAPIParam<T> {
+        config?: ICloudConfig | undefined;
+    }
+
+    // === API: callFunction ===
+    type CallFunctionData = AnyObject;
+
+    interface CallFunctionResult extends IAPISuccessParam {
+        result: AnyObject | string | undefined;
+    }
+
+    interface CallFunctionParam extends ICloudAPIParam<CallFunctionResult> {
+        name: string;
+        data?: CallFunctionData | undefined;
+        slow?: boolean | undefined;
+    }
+    // === end ===
+
+    // === API: uploadFile ===
+    interface UploadFileResult extends IAPISuccessParam {
+        fileID: string;
+        statusCode: number;
+    }
+
+    interface UploadFileParam extends ICloudAPIParam<UploadFileResult> {
+        cloudPath: string;
+        filePath: string;
+        header?: AnyObject | undefined;
+    }
+    // === end ===
+
+    // === API: downloadFile ===
+    interface DownloadFileResult extends IAPISuccessParam {
+        tempFilePath: string;
+        statusCode: number;
+    }
+
+    interface DownloadFileParam extends ICloudAPIParam<DownloadFileResult> {
+        fileID: string;
+        cloudPath?: string | undefined;
+    }
+    // === end ===
+
+    // === API: getTempFileURL ===
+    interface GetTempFileURLResult extends IAPISuccessParam {
+        fileList: GetTempFileURLResultItem[];
+    }
+
+    interface GetTempFileURLResultItem {
+        fileID: string;
+        tempFileURL: string;
+        maxAge: number;
+        status: number;
+        errMsg: string;
+    }
+
+    interface GetTempFileURLParam extends ICloudAPIParam<GetTempFileURLResult> {
+        fileList: string[];
+    }
+    // === end ===
+
+    // === API: deleteFile ===
+    interface DeleteFileResult extends IAPISuccessParam {
+        fileList: DeleteFileResultItem[];
+    }
+
+    interface DeleteFileResultItem {
+        fileID: string;
+        status: number;
+        errMsg: string;
+    }
+
+    interface DeleteFileParam extends ICloudAPIParam<DeleteFileResult> {
+        fileList: string[];
+    }
+    // === end ===
+
+    // === API: CloudID ===
+    abstract class CloudID {
+        constructor(cloudID: string);
+    }
+
+    interface ICloudIDConstructor {
+        new(cloudId: string): CloudID;
+        (cloudId: string): CloudID;
+    }
+    // === end ===
+
+    // === API: CDN ===
+    abstract class CDN {
+        target: string | ArrayBuffer | ICDNFilePathSpec;
+        constructor(target: string | ArrayBuffer | ICDNFilePathSpec);
+    }
+
+    interface ICDNFilePathSpec {
+        type: "filePath";
+        filePath: string;
+    }
+
+    interface ICDNConstructor {
+        new(options: string | ArrayBuffer | ICDNFilePathSpec): CDN;
+        (options: string | ArrayBuffer | ICDNFilePathSpec): CDN;
+    }
+    // === end ===
+}
+
+// === Database ===
+declare namespace DB {
+    /**
+     * The class of all exposed cloud database instances
+     */
+    class Database {
+        readonly config: ICloudConfig;
+        readonly command: DatabaseCommand;
+        readonly Geo: IGeo;
+        readonly serverDate: () => ServerDate;
+        readonly RegExp: IRegExpConstructor;
+
+        private constructor();
+
+        collection(collectionName: string): CollectionReference;
+    }
+
+    class CollectionReference extends Query {
+        readonly collectionName: string;
+
+        private constructor(name: string, database: Database);
+
+        doc(docId: string | number): DocumentReference;
+
+        add(options: OQ<IAddDocumentOptions>): void;
+        add(options: RQ<IAddDocumentOptions>): Promise<IAddResult>;
+    }
+
+    class DocumentReference {
+        private constructor(docId: string | number, database: Database);
+
+        field(object: Record<string, any>): this;
+
+        get(options: OQ<IGetDocumentOptions>): void;
+        get(options?: RQ<IGetDocumentOptions>): Promise<IQuerySingleResult>;
+
+        set(options: OQ<ISetSingleDocumentOptions>): void;
+        set(options?: RQ<ISetSingleDocumentOptions>): Promise<ISetResult>;
+
+        update(options: OQ<IUpdateSingleDocumentOptions>): void;
+        update(
+            options?: RQ<IUpdateSingleDocumentOptions>,
+        ): Promise<IUpdateResult>;
+
+        remove(options: OQ<IRemoveSingleDocumentOptions>): void;
+        remove(
+            options?: RQ<IRemoveSingleDocumentOptions>,
+        ): Promise<IRemoveResult>;
+
+        watch(options: IWatchOptions): RealtimeListener;
+    }
+
+    class RealtimeListener {
+        // "And Now His Watch Is Ended"
+        close: () => Promise<void>;
+    }
+
+    class Query {
+        where(condition: IQueryCondition): Query;
+
+        orderBy(fieldPath: string, order: string): Query;
+
+        limit(max: number): Query;
+
+        skip(offset: number): Query;
+
+        field(object: Record<string, any>): Query;
+
+        get(options: OQ<IGetDocumentOptions>): void;
+        get(options?: RQ<IGetDocumentOptions>): Promise<IQueryResult>;
+
+        count(options: OQ<ICountDocumentOptions>): void;
+        count(options?: RQ<ICountDocumentOptions>): Promise<ICountResult>;
+
+        watch(options: IWatchOptions): RealtimeListener;
+    }
+
+    interface DatabaseCommand {
+        eq(val: any): DatabaseQueryCommand;
+        neq(val: any): DatabaseQueryCommand;
+        gt(val: any): DatabaseQueryCommand;
+        gte(val: any): DatabaseQueryCommand;
+        lt(val: any): DatabaseQueryCommand;
+        lte(val: any): DatabaseQueryCommand;
+        in(val: any[]): DatabaseQueryCommand;
+        nin(val: any[]): DatabaseQueryCommand;
+
+        geoNear(options: IGeoNearCommandOptions): DatabaseQueryCommand;
+        geoWithin(options: IGeoWithinCommandOptions): DatabaseQueryCommand;
+        geoIntersects(
+            options: IGeoIntersectsCommandOptions,
+        ): DatabaseQueryCommand;
+
+        and(
+            ...expressions: Array<DatabaseLogicCommand | IQueryCondition>
+        ): DatabaseLogicCommand;
+        or(
+            ...expressions: Array<DatabaseLogicCommand | IQueryCondition>
+        ): DatabaseLogicCommand;
+        nor(
+            ...expressions: Array<DatabaseLogicCommand | IQueryCondition>
+        ): DatabaseLogicCommand;
+        not(expression: DatabaseLogicCommand): DatabaseLogicCommand;
+
+        exists(val: boolean): DatabaseQueryCommand;
+
+        mod(divisor: number, remainder: number): DatabaseQueryCommand;
+
+        all(val: any[]): DatabaseQueryCommand;
+        elemMatch(val: any): DatabaseQueryCommand;
+        size(val: number): DatabaseQueryCommand;
+
+        set(val: any): DatabaseUpdateCommand;
+        remove(): DatabaseUpdateCommand;
+        inc(val: number): DatabaseUpdateCommand;
+        mul(val: number): DatabaseUpdateCommand;
+        min(val: number): DatabaseUpdateCommand;
+        max(val: number): DatabaseUpdateCommand;
+        rename(val: string): DatabaseUpdateCommand;
+        bit(val: number): DatabaseUpdateCommand;
+
+        push(...values: any[]): DatabaseUpdateCommand;
+        pop(): DatabaseUpdateCommand;
+        shift(): DatabaseUpdateCommand;
+        unshift(...values: any[]): DatabaseUpdateCommand;
+        addToSet(val: any): DatabaseUpdateCommand;
+        pull(val: any): DatabaseUpdateCommand;
+        pullAll(val: any): DatabaseUpdateCommand;
+
+        project: {
+            slice(val: number | [number, number]): DatabaseProjectionCommand;
+        };
+
+        aggregate: {
+            __safe_props__?: Set<string> | undefined;
+
+            abs(val: any): DatabaseAggregateCommand;
+            add(val: any): DatabaseAggregateCommand;
+            addToSet(val: any): DatabaseAggregateCommand;
+            allElementsTrue(val: any): DatabaseAggregateCommand;
+            and(val: any): DatabaseAggregateCommand;
+            anyElementTrue(val: any): DatabaseAggregateCommand;
+            arrayElemAt(val: any): DatabaseAggregateCommand;
+            arrayToObject(val: any): DatabaseAggregateCommand;
+            avg(val: any): DatabaseAggregateCommand;
+            ceil(val: any): DatabaseAggregateCommand;
+            cmp(val: any): DatabaseAggregateCommand;
+            concat(val: any): DatabaseAggregateCommand;
+            concatArrays(val: any): DatabaseAggregateCommand;
+            cond(val: any): DatabaseAggregateCommand;
+            convert(val: any): DatabaseAggregateCommand;
+            dateFromParts(val: any): DatabaseAggregateCommand;
+            dateToParts(val: any): DatabaseAggregateCommand;
+            dateFromString(val: any): DatabaseAggregateCommand;
+            dateToString(val: any): DatabaseAggregateCommand;
+            dayOfMonth(val: any): DatabaseAggregateCommand;
+            dayOfWeek(val: any): DatabaseAggregateCommand;
+            dayOfYear(val: any): DatabaseAggregateCommand;
+            divide(val: any): DatabaseAggregateCommand;
+            eq(val: any): DatabaseAggregateCommand;
+            exp(val: any): DatabaseAggregateCommand;
+            filter(val: any): DatabaseAggregateCommand;
+            first(val: any): DatabaseAggregateCommand;
+            floor(val: any): DatabaseAggregateCommand;
+            gt(val: any): DatabaseAggregateCommand;
+            gte(val: any): DatabaseAggregateCommand;
+            hour(val: any): DatabaseAggregateCommand;
+            ifNull(val: any): DatabaseAggregateCommand;
+            in(val: any): DatabaseAggregateCommand;
+            indexOfArray(val: any): DatabaseAggregateCommand;
+            indexOfBytes(val: any): DatabaseAggregateCommand;
+            indexOfCP(val: any): DatabaseAggregateCommand;
+            isArray(val: any): DatabaseAggregateCommand;
+            isoDayOfWeek(val: any): DatabaseAggregateCommand;
+            isoWeek(val: any): DatabaseAggregateCommand;
+            isoWeekYear(val: any): DatabaseAggregateCommand;
+            last(val: any): DatabaseAggregateCommand;
+            let(val: any): DatabaseAggregateCommand;
+            literal(val: any): DatabaseAggregateCommand;
+            ln(val: any): DatabaseAggregateCommand;
+            log(val: any): DatabaseAggregateCommand;
+            log10(val: any): DatabaseAggregateCommand;
+            lt(val: any): DatabaseAggregateCommand;
+            lte(val: any): DatabaseAggregateCommand;
+            ltrim(val: any): DatabaseAggregateCommand;
+            map(val: any): DatabaseAggregateCommand;
+            max(val: any): DatabaseAggregateCommand;
+            mergeObjects(val: any): DatabaseAggregateCommand;
+            meta(val: any): DatabaseAggregateCommand;
+            min(val: any): DatabaseAggregateCommand;
+            millisecond(val: any): DatabaseAggregateCommand;
+            minute(val: any): DatabaseAggregateCommand;
+            mod(val: any): DatabaseAggregateCommand;
+            month(val: any): DatabaseAggregateCommand;
+            multiply(val: any): DatabaseAggregateCommand;
+            neq(val: any): DatabaseAggregateCommand;
+            not(val: any): DatabaseAggregateCommand;
+            objectToArray(val: any): DatabaseAggregateCommand;
+            or(val: any): DatabaseAggregateCommand;
+            pow(val: any): DatabaseAggregateCommand;
+            push(val: any): DatabaseAggregateCommand;
+            range(val: any): DatabaseAggregateCommand;
+            reduce(val: any): DatabaseAggregateCommand;
+            reverseArray(val: any): DatabaseAggregateCommand;
+            rtrim(val: any): DatabaseAggregateCommand;
+            second(val: any): DatabaseAggregateCommand;
+            setDifference(val: any): DatabaseAggregateCommand;
+            setEquals(val: any): DatabaseAggregateCommand;
+            setIntersection(val: any): DatabaseAggregateCommand;
+            setIsSubset(val: any): DatabaseAggregateCommand;
+            setUnion(val: any): DatabaseAggregateCommand;
+            size(val: any): DatabaseAggregateCommand;
+            slice(val: any): DatabaseAggregateCommand;
+            split(val: any): DatabaseAggregateCommand;
+            sqrt(val: any): DatabaseAggregateCommand;
+            stdDevPop(val: any): DatabaseAggregateCommand;
+            stdDevSamp(val: any): DatabaseAggregateCommand;
+            strcasecmp(val: any): DatabaseAggregateCommand;
+            strLenBytes(val: any): DatabaseAggregateCommand;
+            strLenCP(val: any): DatabaseAggregateCommand;
+            substr(val: any): DatabaseAggregateCommand;
+            substrBytes(val: any): DatabaseAggregateCommand;
+            substrCP(val: any): DatabaseAggregateCommand;
+            subtract(val: any): DatabaseAggregateCommand;
+            sum(val: any): DatabaseAggregateCommand;
+            switch(val: any): DatabaseAggregateCommand;
+            toBool(val: any): DatabaseAggregateCommand;
+            toDate(val: any): DatabaseAggregateCommand;
+            toDecimal(val: any): DatabaseAggregateCommand;
+            toDouble(val: any): DatabaseAggregateCommand;
+            toInt(val: any): DatabaseAggregateCommand;
+            toLong(val: any): DatabaseAggregateCommand;
+            toObjectId(val: any): DatabaseAggregateCommand;
+            toString(val: any): DatabaseAggregateCommand;
+            toLower(val: any): DatabaseAggregateCommand;
+            toUpper(val: any): DatabaseAggregateCommand;
+            trim(val: any): DatabaseAggregateCommand;
+            trunc(val: any): DatabaseAggregateCommand;
+            type(val: any): DatabaseAggregateCommand;
+            week(val: any): DatabaseAggregateCommand;
+            year(val: any): DatabaseAggregateCommand;
+            zip(val: any): DatabaseAggregateCommand;
+        };
+    }
+
+    class DatabaseAggregateCommand {}
+
+    enum LOGIC_COMMANDS_LITERAL {
+        AND = "and",
+        OR = "or",
+        NOT = "not",
+        NOR = "nor",
+    }
+
+    class DatabaseLogicCommand {
+        and(...expressions: DatabaseLogicCommand[]): DatabaseLogicCommand;
+        or(...expressions: DatabaseLogicCommand[]): DatabaseLogicCommand;
+        nor(...expressions: DatabaseLogicCommand[]): DatabaseLogicCommand;
+        not(expression: DatabaseLogicCommand): DatabaseLogicCommand;
+    }
+
+    enum QUERY_COMMANDS_LITERAL {
+        // comparison
+        EQ = "eq",
+        NEQ = "neq",
+        GT = "gt",
+        GTE = "gte",
+        LT = "lt",
+        LTE = "lte",
+        IN = "in",
+        NIN = "nin",
+        // geo
+        GEO_NEAR = "geoNear",
+        GEO_WITHIN = "geoWithin",
+        GEO_INTERSECTS = "geoIntersects",
+        // element
+        EXISTS = "exists",
+        // evaluation
+        MOD = "mod",
+        // array
+        ALL = "all",
+        ELEM_MATCH = "elemMatch",
+        SIZE = "size",
+    }
+
+    class DatabaseQueryCommand extends DatabaseLogicCommand {
+        eq(val: any): DatabaseLogicCommand;
+        neq(val: any): DatabaseLogicCommand;
+        gt(val: any): DatabaseLogicCommand;
+        gte(val: any): DatabaseLogicCommand;
+        lt(val: any): DatabaseLogicCommand;
+        lte(val: any): DatabaseLogicCommand;
+        in(val: any[]): DatabaseLogicCommand;
+        nin(val: any[]): DatabaseLogicCommand;
+
+        exists(val: boolean): DatabaseLogicCommand;
+
+        mod(divisor: number, remainder: number): DatabaseLogicCommand;
+
+        all(val: any[]): DatabaseLogicCommand;
+        elemMatch(val: any): DatabaseLogicCommand;
+        size(val: number): DatabaseLogicCommand;
+
+        geoNear(options: IGeoNearCommandOptions): DatabaseLogicCommand;
+        geoWithin(options: IGeoWithinCommandOptions): DatabaseLogicCommand;
+        geoIntersects(
+            options: IGeoIntersectsCommandOptions,
+        ): DatabaseLogicCommand;
+    }
+
+    enum PROJECTION_COMMANDS_LITERAL {
+        SLICE = "slice",
+    }
+
+    class DatabaseProjectionCommand {}
+
+    enum UPDATE_COMMANDS_LITERAL {
+        // field
+        SET = "set",
+        REMOVE = "remove",
+        INC = "inc",
+        MUL = "mul",
+        MIN = "min",
+        MAX = "max",
+        RENAME = "rename",
+        // bitwise
+        BIT = "bit",
+        // array
+        PUSH = "push",
+        POP = "pop",
+        SHIFT = "shift",
+        UNSHIFT = "unshift",
+        ADD_TO_SET = "addToSet",
+        PULL = "pull",
+        PULL_ALL = "pullAll",
+    }
+
+    class DatabaseUpdateCommand {}
+
+    class Batch {}
+
+    /**
+     * A contract that all API provider must adhere to
+     */
+    class APIBaseContract<
+        PromiseReturn,
+        CallbackReturn,
+        Param extends IAPIParam,
+        Context = any,
+    > {
+        getContext(param: Param): Context;
+
+        /**
+         * In case of callback-style invocation, this function will be called
+         */
+        getCallbackReturn(param: Param, context: Context): CallbackReturn;
+
+        getFinalParam<T extends Param>(param: Param, context: Context): T;
+
+        run<T extends Param>(param: T): Promise<PromiseReturn>;
+    }
+
+    interface IGeoPointConstructor {
+        new(longitude: number, latitide: number): GeoPoint;
+        new(geojson: IGeoJSONPoint): GeoPoint;
+        (longitude: number, latitide: number): GeoPoint;
+        (geojson: IGeoJSONPoint): GeoPoint;
+    }
+
+    interface IGeoMultiPointConstructor {
+        new(points: GeoPoint[] | IGeoJSONMultiPoint): GeoMultiPoint;
+        (points: GeoPoint[] | IGeoJSONMultiPoint): GeoMultiPoint;
+    }
+
+    interface IGeoLineStringConstructor {
+        new(points: GeoPoint[] | IGeoJSONLineString): GeoLineString;
+        (points: GeoPoint[] | IGeoJSONLineString): GeoLineString;
+    }
+
+    interface IGeoMultiLineStringConstructor {
+        new(
+            lineStrings: GeoLineString[] | IGeoJSONMultiLineString,
+        ): GeoMultiLineString;
+        (
+            lineStrings: GeoLineString[] | IGeoJSONMultiLineString,
+        ): GeoMultiLineString;
+    }
+
+    interface IGeoPolygonConstructor {
+        new(lineStrings: GeoLineString[] | IGeoJSONPolygon): GeoPolygon;
+        (lineStrings: GeoLineString[] | IGeoJSONPolygon): GeoPolygon;
+    }
+
+    interface IGeoMultiPolygonConstructor {
+        new(polygons: GeoPolygon[] | IGeoJSONMultiPolygon): GeoMultiPolygon;
+        (polygons: GeoPolygon[] | IGeoJSONMultiPolygon): GeoMultiPolygon;
+    }
+
+    interface IGeo {
+        Point: IGeoPointConstructor;
+        MultiPoint: IGeoMultiPointConstructor;
+        LineString: IGeoLineStringConstructor;
+        MultiLineString: IGeoMultiLineStringConstructor;
+        Polygon: IGeoPolygonConstructor;
+        MultiPolygon: IGeoMultiPolygonConstructor;
+    }
+
+    interface IGeoJSONPoint {
+        type: "Point";
+        coordinates: [number, number];
+    }
+
+    interface IGeoJSONMultiPoint {
+        type: "MultiPoint";
+        coordinates: Array<[number, number]>;
+    }
+
+    interface IGeoJSONLineString {
+        type: "LineString";
+        coordinates: Array<[number, number]>;
+    }
+
+    interface IGeoJSONMultiLineString {
+        type: "MultiLineString";
+        coordinates: Array<Array<[number, number]>>;
+    }
+
+    interface IGeoJSONPolygon {
+        type: "Polygon";
+        coordinates: Array<Array<[number, number]>>;
+    }
+
+    interface IGeoJSONMultiPolygon {
+        type: "MultiPolygon";
+        coordinates: Array<Array<Array<[number, number]>>>;
+    }
+
+    type IGeoJSONObject =
+        | IGeoJSONPoint
+        | IGeoJSONMultiPoint
+        | IGeoJSONLineString
+        | IGeoJSONMultiLineString
+        | IGeoJSONPolygon
+        | IGeoJSONMultiPolygon;
+
+    abstract class GeoPoint {
+        longitude: number;
+        latitude: number;
+
+        constructor(longitude: number, latitude: number);
+
+        toJSON(): Record<string, any>;
+        toString(): string;
+    }
+
+    abstract class GeoMultiPoint {
+        points: GeoPoint[];
+
+        constructor(points: GeoPoint[]);
+
+        toJSON(): IGeoJSONMultiPoint;
+        toString(): string;
+    }
+
+    abstract class GeoLineString {
+        points: GeoPoint[];
+
+        constructor(points: GeoPoint[]);
+
+        toJSON(): IGeoJSONLineString;
+        toString(): string;
+    }
+
+    abstract class GeoMultiLineString {
+        lines: GeoLineString[];
+
+        constructor(lines: GeoLineString[]);
+
+        toJSON(): IGeoJSONMultiLineString;
+        toString(): string;
+    }
+
+    abstract class GeoPolygon {
+        lines: GeoLineString[];
+
+        constructor(lines: GeoLineString[]);
+
+        toJSON(): IGeoJSONPolygon;
+        toString(): string;
+    }
+
+    abstract class GeoMultiPolygon {
+        polygons: GeoPolygon[];
+
+        constructor(polygons: GeoPolygon[]);
+
+        toJSON(): IGeoJSONMultiPolygon;
+        toString(): string;
+    }
+
+    type GeoInstance =
+        | GeoPoint
+        | GeoMultiPoint
+        | GeoLineString
+        | GeoMultiLineString
+        | GeoPolygon
+        | GeoMultiPolygon;
+
+    interface IGeoNearCommandOptions {
+        geometry: GeoPoint;
+        maxDistance?: number | undefined;
+        minDistance?: number | undefined;
+    }
+
+    interface IGeoWithinCommandOptions {
+        geometry: GeoPolygon | GeoMultiPolygon;
+    }
+
+    interface IGeoIntersectsCommandOptions {
+        geometry:
+            | GeoPoint
+            | GeoMultiPoint
+            | GeoLineString
+            | GeoMultiLineString
+            | GeoPolygon
+            | GeoMultiPolygon;
+    }
+
+    interface IServerDateOptions {
+        offset: number;
+    }
+
+    abstract class ServerDate {
+        readonly options: IServerDateOptions;
+        constructor(options?: IServerDateOptions);
+    }
+
+    interface IRegExpOptions {
+        regexp: string;
+        options?: string | undefined;
+    }
+
+    interface IRegExpConstructor {
+        new(options: IRegExpOptions): RegExp;
+        (options: IRegExpOptions): RegExp;
+    }
+
+    abstract class RegExp {
+        readonly regexp: string;
+        readonly options: string;
+        constructor(options: IRegExpOptions);
+    }
+
+    type DocumentId = string | number;
+
+    interface IDocumentData {
+        _id?: DocumentId | undefined;
+        [key: string]: any;
+    }
+
+    type IDBAPIParam = IAPIParam;
+
+    interface IAddDocumentOptions extends IDBAPIParam {
+        data: IDocumentData;
+    }
+
+    type IGetDocumentOptions = IDBAPIParam;
+
+    type ICountDocumentOptions = IDBAPIParam;
+
+    interface IUpdateDocumentOptions extends IDBAPIParam {
+        data: IUpdateCondition;
+    }
+
+    interface IUpdateSingleDocumentOptions extends IDBAPIParam {
+        data: IUpdateCondition;
+    }
+
+    interface ISetDocumentOptions extends IDBAPIParam {
+        data: IUpdateCondition;
+    }
+
+    interface ISetSingleDocumentOptions extends IDBAPIParam {
+        data: IUpdateCondition;
+    }
+
+    interface IRemoveDocumentOptions extends IDBAPIParam {
+        query: IQueryCondition;
+    }
+
+    type IRemoveSingleDocumentOptions = IDBAPIParam;
+
+    interface IWatchOptions {
+        // server realtime data init & change event
+        onChange: (snapshot: ISnapshot) => void;
+        // error while connecting / listening
+        onError: (error: any) => void;
+    }
+
+    interface ISnapshot {
+        id: number;
+        docChanges: ISingleDBEvent[];
+        docs: Record<string, any>;
+        type?: SnapshotType | undefined;
+    }
+
+    type SnapshotType = "init";
+
+    interface ISingleDBEvent {
+        id: number;
+        dataType: DataType;
+        queueType: QueueType;
+        docId: string;
+        doc: Record<string, any>;
+        updatedFields?: Record<string, any> | undefined;
+        removedFields?: string[] | undefined;
+    }
+
+    type DataType = "init" | "update" | "replace" | "add" | "remove" | "limit";
+
+    type QueueType = "init" | "enqueue" | "dequeue" | "update";
+
+    interface IQueryCondition {
+        [key: string]: any;
+    }
+
+    type IStringQueryCondition = string;
+
+    interface IQueryResult extends IAPISuccessParam {
+        data: IDocumentData[];
+    }
+
+    interface IQuerySingleResult extends IAPISuccessParam {
+        data: IDocumentData;
+    }
+
+    interface IUpdateCondition {
+        [key: string]: any;
+    }
+
+    type IStringUpdateCondition = string;
+
+    interface IAddResult extends IAPISuccessParam {
+        _id: DocumentId;
+    }
+
+    interface IUpdateResult extends IAPISuccessParam {
+        stats: {
+            updated: number;
+            // created: number,
+        };
+    }
+
+    interface ISetResult extends IAPISuccessParam {
+        _id: DocumentId;
+        stats: {
+            updated: number;
+            created: number;
+        };
+    }
+
+    interface IRemoveResult extends IAPISuccessParam {
+        stats: {
+            removed: number;
+        };
+    }
+
+    interface ICountResult extends IAPISuccessParam {
+        total: number;
+    }
+}
+
+type Optional<T> = { [K in keyof T]+?: T[K] };
+
+type OQ<
+    T extends Optional<
+        Record<"complete" | "success" | "fail", (...args: any[]) => any>
+    >,
+> =
+    | (RQ<T> & Required<Pick<T, "success">>)
+    | (RQ<T> & Required<Pick<T, "fail">>)
+    | (RQ<T> & Required<Pick<T, "complete">>)
+    | (RQ<T> & Required<Pick<T, "success" | "fail">>)
+    | (RQ<T> & Required<Pick<T, "success" | "complete">>)
+    | (RQ<T> & Required<Pick<T, "fail" | "complete">>)
+    | (RQ<T> & Required<Pick<T, "fail" | "complete" | "success">>);
+
+type RQ<
+    T extends Optional<
+        Record<"complete" | "success" | "fail", (...args: any[]) => any>
+    >,
+> = Pick<T, Exclude<keyof T, "complete" | "success" | "fail">>;