import { ResponseType } from '.';
export declare namespace ULTIPA {
    /**
     * Raft集群的类型
     */
    enum ClientType {
        Default = 0,
        Algo = 1,
        Update = 2,
        Leader = 3
    }
    interface TimeZone {
        timeZone?: string;
        timeZoneOffset?: number;
        timestampToString?: boolean;
    }
    /**
     * 连接的配置
     */
    class UltipaConfig {
        useHost?: string;
        graphSetName?: string;
        clusterId?: string;
        timeZone?: string;
        timeZoneOffset?: number;
        timestampToString?: boolean;
        logUql?: boolean;
        timeout?: number;
        threadNum?: number;
        responseWithRequestInfo?: boolean;
        consistency?: boolean;
    }
    /**
     * 属性类型
     */
    enum PropertyType {
        PROPERTY_UNSET,
        PROPERTY_INT32,
        PROPERTY_STRING,
        PROPERTY_FLOAT,
        PROPERTY_DOUBLE,
        PROPERTY_UINT32,
        PROPERTY_INT64,
        PROPERTY_UINT64,
        PROPERTY_DATETIME,
        PROPERTY_TIMESTAMP,
        PROPERTY_TEXT,
        PROPERTY_BLOB,
        PROPERTY_POINT,
        PROPERTY_DECIMAL,
        PROPERTY_LIST,
        PROPERTY_SET,
        PROPERTY_MAP,
        PROPERTY_NULL,
        unset,
        int32,
        string,
        float,
        double,
        uint32,
        int64,
        uint64,
        datetime,
        timestamp,
        text,
        blob,
        point,
        decimal,
        list,
        set,
        map,
        null
    }
    /**
     * 返回状态码
     */
    enum Code {
        SUCCESS,
        FAILED,
        PARAM_ERROR,
        BASE_DB_ERROR,
        ENGINE_ERROR,
        SYSTEM_ERROR,
        RAFT_REDIRECT,
        RAFT_LEADER_NOT_YET_ELECTED,
        RAFT_LOG_ERROR,
        UQL_ERROR,
        NOT_RAFT_MODE,
        RAFT_NO_AVAILABLE_FOLLOWERS,
        RAFT_NO_AVAILABLE_ALGO_SERVERS,
        PERMISSION_DENIED,
        UNKNOWN_ERROR = 1000
    }
    enum ResultType {
        RESULT_TYPE_UNSET,
        RESULT_TYPE_PATH,
        RESULT_TYPE_NODE,
        RESULT_TYPE_EDGE,
        RESULT_TYPE_ATTR,
        RESULT_TYPE_TABLE,
        RESULT_TYPE_GRAPH
    }
    enum AuthenticateType {
        PERMISSION_TYPE_UQL,
        PERMISSION_TYPE_INSERTNODES,
        PERMISSION_TYPE_INSERTEDGES,
        PERMISSION_TYPE_EXPORT,
        PERMISSION_TYPE_DOWNLOADFILE,
        PERMISSION_TYPE_INSTALLALGO,
        PERMISSION_TYPE_UNINSTALLALGO,
        PERMISSION_TYPE_UPLOADER,
        PERMISSION_TYPE_CREATEGRAPHBYUPLOADER,
        PERMISSION_TYPE_INSTALLEXTA,
        PERMISSION_TYPE_UNINSTALLEXTA
    }
    enum InsertType {
        INSERT_TYPE_NORMAL,
        INSERT_TYPE_OVERWRITE,
        INSERT_TYPE_UPSERT
    }
    /**
     * 数据库类型
     */
    enum DBType {
        /**
         * 点
         */
        DBNODE,
        /**
         * 边
         */
        DBEDGE
    }
    /**
     * Raft从节点的规则
     */
    enum RaftFollowerRole {
        ROLE_UNSET,
        ROLE_READABLE,
        ROLE_ALGO_EXECUTABLE
    }
    /**
     * 算法任务的状态
     */
    enum Task_Status {
        pending,
        computing,
        writing,
        done,
        failed,
        stopped
    }
    /**
     * Raft节点的信息
     */
    type RaftPeerInfo = {
        host: string;
        status: boolean;
        isLeader: boolean;
        isFollowerReadable: boolean;
        isAlgoExecutable: boolean;
        isUnset: boolean;
    };
    /**
     * 连接返回的统一状态
     */
    type Status = {
        code: number;
        code_desc?: string;
        message: string;
        clusterInfo?: {
            redirect: string;
            raftPeers: RaftPeerInfo[];
        };
    };
    type ResultAlias = {
        alias: string;
        result_type: ResultType;
    };
    type ResultAliases = ResultAlias[];
    /**
     * 点的结构
     */
    class Node {
        schema: string;
        id: string;
        uuid: string;
        values: object;
        getID(): string;
        getUUID(): string;
        getSchema(): string;
        getValues(): object;
        get(prop_name: string): any;
        set(prop_name: string, value: any): void;
    }
    type NodeTable = Node[];
    /**
     * 一组点
     */
    type NodeAlias = {
        nodes: NodeTable;
        alias: string;
    };
    /**
     * 边的结构
     */
    class Edge {
        schema: string;
        from: string;
        to: string;
        uuid: string;
        from_uuid: string;
        to_uuid: string;
        values: object;
        getUUID(): string;
        getSchema(): string;
        getFrom(): string;
        getFromUUID(): string;
        getTo(): string;
        getToUUID(): string;
        getValues(): object;
        get(prop_name: string): any;
        set(prop_name: string, value: any): void;
    }
    type EdgeTable = Edge[];
    /**
     * 一组边
     */
    type EdgeAlias = {
        edges: EdgeTable;
        alias: string;
    };
    type GraphAlias = {
        graph: Graph;
        alias: string;
    };
    class Graph {
        nodes: NodeTable;
        edges: EdgeTable;
        getNodes(): NodeTable;
        getEdges(): EdgeTable;
    }
    /**
     * 路径的结构
     */
    class Path extends Graph {
        length: number;
        getLength(): number;
    }
    type Paths = Path[];
    type PathAlias = {
        alias: string;
        paths: Paths;
    };
    type Header = {
        name: string;
        type: PropertyType;
        subTypes?: PropertyType[];
    };
    type Property = Header;
    type Schema = {
        dbType: DBType;
        name: string;
        desc?: string;
        properties?: Property[];
    };
    type Statistics = {
        totalCost: number;
        engineCost: number;
        nodeAffected?: number;
        edgeAffected?: number;
    };
    /**
     * 表格的结构
     */
    class Table {
        name: string;
        alias: string;
        headers: string[];
        rows: any[][];
        toKV(): any[];
        getHeaders(): string[];
        getRows(): any[][];
    }
    type AttrAlias = {
        values: any[];
        type: ResultType;
        type_desc: string;
        alias: string;
    };
    type AttrNodesAlias = {
        values: Node[][];
        type: ResultType;
        type_desc: string;
        alias: string;
    };
    type AttrEdgesAlias = {
        values: Edge[][];
        type: ResultType;
        type_desc: string;
        alias: string;
    };
    type AttrPathsAlias = {
        values: Path[][];
        type: ResultType;
        type_desc: string;
        alias: string;
    };
    /**
     * 一组属性
     */
    type AttrNewAlias = {
        attr: Attr;
        alias: string;
    };
    type Attr = {
        type: PropertyType;
        type_desc: string;
        values: any[];
        has_attr_data: boolean;
        has_ultipa_data: boolean;
    };
    type AttrListData = {
        type: ResultType;
        type_desc: string;
        nodes?: NodeTable;
        edges?: EdgeTable;
        paths?: Paths;
        attrs?: Attr[];
    };
    type AttrMapData = {
        key: Attr;
        value: Attr;
    };
    type ListData = {
        values: any[];
    };
    type SetData = ListData;
    type MapValue = {
        key: any;
        value: any;
    };
    type MapData = {
        values: MapData[];
    };
    type ExplainPlan = {
        plan_nodes: PlanNode[];
    };
    type PlanNode = {
        alias: string;
        children_num: number;
        children?: PlanNode[] | null;
        uql: string;
        infos: string;
    };
    /**
     * uql统一返回结构体的data
     */
    type UQLReplyBase = {
        total_time_cost: number;
        engine_time_cost: number;
        results?: ResultAlias[];
        paths?: PathAlias[];
        nodes?: NodeAlias[];
        edges?: EdgeAlias[];
        attrs?: AttrAlias[];
        tables?: Table[];
        graphs?: GraphAlias[];
        statistics: Statistics;
        explainPlans?: ExplainPlan;
        explainPlansTreeTopNode?: PlanNode;
    };
    function getExplainPlansTreeTopNode(plans: ExplainPlan): PlanNode;
    class UQLReply {
        aliasMap: {
            [x: string]: DataItem;
        };
        datas: DataItem[];
        statistics: Statistics;
        explainPlansTreeTopNode: PlanNode;
        constructor(uqlReplyBase: UQLReplyBase);
        private defaultValueFromType;
        ___aliasMapFromDatas(): void;
        isEmpty(): boolean;
        singleDataNodes(): Node[];
        singleDataEdges(): Edge[];
        singleDataPaths(): any;
        getTables(): Table[];
        singleDataTables(): Table;
        singleDataGraph(): Graph;
        singleDataAttrs(): AttrAlias;
        get(index: number): DataItem;
        alias(alias: string): DataItem;
        toJSON(): {
            statistics: Statistics;
            explainPlansTreeTopNode: PlanNode;
            datas: DataItem[];
        };
    }
    class DataItem {
        data: any;
        type: ResultType;
        type_desc: string;
        alias: string;
        constructor(alias: string, data: any, type: ResultType);
        private _asTypeError;
        asEdges(): EdgeTable;
        asPaths(): Paths;
        asNodes(): NodeTable;
        asTable(): Table;
        asGraph(): Graph;
        asAttrs(): AttrAlias;
        asNodeList(): AttrNodesAlias;
        asEdgeList(): AttrEdgesAlias;
        asPathList(): AttrPathsAlias;
        asGraphInfos(): ResponseType.GraphSet[];
        asProperties(): ResponseType.Property[];
        asSchemas(): ResponseType.Schema[];
        asAlgos(): ResponseType.Algo[];
        asExtas(): ResponseType.Exta[];
        asTasks(): ResponseType.Task[];
        asAny(): any;
        asTableWithT<T>(): T[];
        toJSONString(): string;
    }
    /**
     * 所有请求的统一返回结构体
     */
    class Response<T> {
        req?: any;
        status: Status;
        data?: T;
        statistics?: Statistics;
        explainPlans?: ExplainPlan;
    }
    /**
     * uql请求的返回结构体
     */
    class UQLResponse extends Response<ULTIPA.UQLReply> {
    }
    function NewUQLResponse(jsonObj: any): UQLResponse;
    class UQLBaseResponse extends Response<ULTIPA.UQLReplyBase> {
    }
    function NewUQLBaseResponse(jsonObj: any): UQLBaseResponse;
    function formatBaseResponse(base: UQLBaseResponse): any;
    class UQLSingleResponse {
        responseWithoutData: Response<null>;
        uqlReply: UQLReply;
    }
    class TruncateType {
        node: string;
        edge: string;
    }
}