/**
 * Ultipa Configuration is the basic configuration that used for establishing the connections.
 */
export declare class UltipaConfig {
    /**
     * List of host addresses (IPs or URLs)
     * - Supports IPv4 and IPv6 addresses
     * - Supports URLs (if prefixed with https://, uses secure connection)
     * - Required
     */
    hosts: string[];
    /** Username for authentication (Required) */
    username: string;
    /** Password for authentication (Required) */
    password: string;
    /** Default graph to interact with (Optional) */
    defaultGraph?: string;
    /** Path string to CRT file, used for SSL connections. */
    crt?: string;
    /**
     * Password encryption method
     * @default "MD5"
     */
    passwordEncrypt?: "MD5" | "LDAP" | "NOTHING";
    /**
     * Request timeout in seconds
     * @default 2147483647
     */
    timeout?: number;
    /**
     * Heartbeat interval in milliseconds
     * Set to 0 to disable heartbeat
     * Used for keeping connection alive
     * @default 0
     */
    heartbeat?: number;
    /**
     * Maximum receive size in megabytes
     * @default 32
     */
    maxRecvSize?: number;
}
/**
 * Configuration for each request, can be null
 */
export declare class RequestConfig {
    /**
     * specify graphName, if null will use defaultGraph of UltipaConfiguration
     */
    graph?: string;
    /**
     * Operation timeout in seconds
     */
    timeout?: number;
    /**
     * Specify the host to execute the request
     * */
    host?: string;
    /**
     * request,thread num
     */
    thread?: number;
    /**
     * name of time zone,
     * default: current time zone.
     * e.g. Aisa/Shanghai
     */
    timezone?: string;
    /**
     * hour elapse from UTC
     * When both `timezone` and `timezoneOffset` are provided, `timezoneOffset` takes precedence.
     * Unit: hour. Example:” +08:30”,”-05:00”，“+2”，“-0300”
     */
    timezoneOffset?: string;
    /**
     * If true the queryText will be logged.
     */
    logQueryText?: boolean;
    /**
     * If true the request info will be logged.
     */
    withRequestInfo?: boolean;
}
/**
* configuration for insert request. extends RequestConfig,have all RequestConfig property
*/
export declare class InsertRequestConfig extends RequestConfig {
    /**
     * NORMAL,
     * OVERWRITE,
     * UPSERT
     */
    insertType: InsertType;
    /**
     * Return data or not when insert/delete batch. true - not return data, false - return data.
     */
    silent: boolean;
}
/**
 * The insert error code from server.
 */
export declare enum InsertErrorCode {
    ID_NOT_MATCH_UUID = 10001,
    ID_UUID_NOT_MATCH_SCHEMA = 10002,
    FROM_ID_NOT_EXISTED = 10003,
    TO_ID_NOT_EXISTED = 10004,
    ID_LEN = 10005,
    NOT_NULL = 10006,
    UNIQUCHECK = 10007,
    ID_EMPTY = 10008,
    FROM_ID_EMPTY = 10009,
    TO_ID_EMPTY = 10010,
    DUPLICATE_ID = 10011,
    KEY_CONSTRAINT_VIOLATED = 10012,
    OK_BUT_ID_EXISTED = 11001,
    OTHERS = 19999
}
export declare const InsertErrorMessages: {
    10001: string;
    10002: string;
    10003: string;
    10004: string;
    10005: string;
    10006: string;
    10007: string;
    10008: string;
    10009: string;
    10010: string;
    10011: string;
    10012: string;
    11001: string;
    19999: string;
};
export declare function getInsertErrorMessage(errorCode: InsertErrorCode | number): string;
/**
 * TODO: delete Ttimezone
 */
export interface Ttimezone {
    timezone?: string;
    timezoneOffset?: string;
    timestampToString?: boolean;
}
/**
 * The schema property type.When create property.Need set property type.
 */
export declare enum UltipaPropertyType {
    /**
     * Ultipa schema id type
     */
    ID = -1,
    /**
     * Ultipa schema uuid type
     */
    UUID = -2,
    /**
     * Ultipa edge schema from_id type
     */
    FROM = -3,
    /**
     * Ultipa edge schema to_id type
     */
    TO = -4,
    /**
     * Ultipa edge schema from_uuid type
     */
    FROM_UUID = -5,
    /**
     * Ultipa edge schema to_uuid type
     */
    TO_UUID = -6,
    /**
     * Ignore
     */
    IGNORE = -7,
    /**
     * No type set
     */
    UNSET = 0,
    /**
     * Signed 32 integer
     */
    INT32 = 1,
    /**
     * Unsigned 32 integer
     */
    UINT32 = 2,
    /**
     * Signed 64 integer
     */
    INT64 = 3,
    /**
     * Unsigned 64 integer
     */
    UINT64 = 4,
    /**
    * Single floating-point number
    */
    FLOAT = 5,
    /**
     * Double-precision floating-point numbers
     */
    DOUBLE = 6,
    /**
     * A data type that represents a sequence of characters
     */
    STRING = 7,
    /**
     * Represents a combination of a date and a time
     */
    DATETIME = 8,
    /**
     * A data type that typically represents a specific point in time, often with a high level of precision
     */
    TIMESTAMP = 9,
    /**
     * Used to store large amounts of text data
     */
    TEXT = 10,
    /**
     * Stands for Binary Large Object
     */
    BLOB = 11,
    /**
     * In the context of databases dealing with spatial data (e.g., in GIS systems)
     */
    POINT = 12,
    /**
     * Represents a fixed-point number with a specified precision and scale
     */
    DECIMAL = 13,
    /**
     * A data structure that can hold a collection of elements
     */
    LIST = 14,
    /**
     * A data structure that stores a collection of unique elements
     */
    SET = 15,
    /**
     * A data structure that stores key-value pairs
     */
    MAP = 16,
    /**
     * Null type
     */
    NULL = 17,
    /**
     * Stands for Boolean
     */
    BOOL = 18
}
/**
 * The insertion mode.
 */
export declare enum InsertType {
    /**
     * Insert new data
     */
    NORMAL = 0,
    /**
     * The insert overwrite operation first clears the existing data in the target location and then inserts new data
     */
    OVERWRITE = 1,
    /**
     * If the data record to be inserted already exists in the target location  the record will be updated; if it does not exist, a new record will be inserted
     */
    UPSERT = 2
}
/**
 * Algorithm Detail Response Data
 */
export declare class Algo {
    /**
     * name
     */
    name?: string;
    /**
     * type
     */
    type?: string;
    /**
     * write support type
     */
    writeSupportType?: string;
    /**
     * Whether the algorithm can be rolled back to previous version.
     */
    canRollback?: string;
    /**
     * config context
     */
    configContext?: string;
    /**
     * version
     */
    version?: string;
    /**
     * algo params
     */
    params?: AlgoParam[];
    /**
     * algo description
     */
    description?: string;
}
export interface AlgoParam {
    name: string;
    desc?: string;
}
/**
 * TODO delete Code
 */
export declare enum ErrorCode {
    SUCCESS,
    FAILED,
    PARAM_ERROR,
    BASE_DB_ERROR,
    ENGINE_ERROR,
    SYSTEM_ERROR,
    SYNTAX_ERROR,
    PERMISSION_DENIED,
    DUPLICATE_ID,
    RAFT_REDIRECT,
    RAFT_LEADER_NOT_YET_ELECTED,
    RAFT_LOG_ERROR,
    NOT_RAFT_MODE,
    RAFT_NO_AVAILABLE_FOLLOWERS,
    RAFT_NO_AVAILABLE_ALGO_SERVERS,
    UNKNOWN_ERROR = 1000
}
export declare enum ResultType {
    RESULT_TYPE_UNSET,
    RESULT_TYPE_PATH,
    RESULT_TYPE_NODE,
    RESULT_TYPE_EDGE,
    RESULT_TYPE_ATTR,
    RESULT_TYPE_TABLE
}
export declare enum AuthenticateType {
    PERMISSION_TYPE_UNSET,
    PERMISSION_TYPE_UQL,
    PERMISSION_TYPE_GQL,
    PERMISSION_TYPE_INSERTNODES,
    PERMISSION_TYPE_INSERTEDGES,
    PERMISSION_TYPE_EXPORT,
    PERMISSION_TYPE_DOWNLOADFILE,
    PERMISSION_TYPE_INSTALLALGO,
    PERMISSION_TYPE_UNINSTALLALGO,
    PERMISSION_TYPE_ROLLBACKALGO
}
/**
 * privilege level type
 */
export declare enum PrivilegeLevel {
    /**
     * Graph privilege type
     */
    GraphLevel = 0,
    /**
     * System privilege type
     */
    SystemLevel = 1
}
/**
 * HDC synchronization type.
 */
export declare enum HDCSyncType {
    /**
     * Static synchronization
     */
    STATIC = "static",
    /**
     * Asynchronous synchronization
     */
    ASYNC = "async",
    /**
     * Synchronous synchronization
     */
    SYNC = "sync"
}
/** Query type contains UQL,GQL */
export declare enum QueryType {
    QL_UNSET = 0,
    UQL = 1,
    GQL = 2
}
/**
 * The schema type in database.
 */
export declare enum DBType {
    /**
     * Node
     */
    DBNODE,
    /**
     * Edge
     */
    DBEDGE
}
/**
 * Job status
 */
export declare enum JOB_STATUS {
    JOB_PENDING,
    JOB_COMPUTING,
    JOB_WRITING,
    JOB_DONE,
    JOB_FAILED,
    JOB_STOPPED
}
/**
 * Property index
 */
export declare class Index {
    id?: string;
    /**
     * Index name
     */
    name: string;
    /**
     * Index on which properties
     */
    properties: string;
    /**
     * Index on which scehma
     */
    schema: string;
    /**
     * Index status
     */
    status: string;
    /**
     * Index size
     */
    size?: string;
    /**
     * Node index or edge index
     */
    dbType?: DBType;
}
/**
 * User
 */
export declare class User {
    /**
     * username
     */
    username?: string;
    /**
     * pasword
     */
    password?: string;
    /**
     * create time
     */
    createdTime?: Date;
    /**
     * System privileges list
     */
    systemPrivileges?: string[];
    /**
     * Graph privileges key value map
     */
    graphPrivileges?: Map<string, string[]>;
    /**
     * Property privileges
     */
    propertyPrivileges?: PropertyPrivilege;
    /**
     * Policy list
     */
    policies?: string[];
}
export interface PropertyPrivilege {
    node?: PropertyPrivilegeElement;
    edge?: PropertyPrivilegeElement;
}
export interface PropertyPrivilegeElement {
    read?: string[][];
    write?: string[][];
    deny?: string[][];
}
/**
 * A policy is a set of privileges designed for a specific user role, often encompassing multiple privileges and other policies. Effective policy design and usage enable role-based access control.
 */
export declare class Policy {
    /** Policy name */
    name?: string;
    /** Atlas permissions included in the policy */
    systemPrivileges?: string[];
    /** System permissions included in the policy */
    graphPrivileges?: Map<string, string[]>;
    /** Permissions for properties included in the policy */
    propertyPrivileges?: PropertyPrivilege;
    /** Other strategies included in the policy */
    policies?: string[];
}
/**
 * Control user permissions to operate on the graph database
 */
export declare class Privilege {
    /**
     * privilege name
     */
    name?: string;
    /**
     * privilege type
     */
    level?: PrivilegeLevel;
}
/**
 * 连接返回的统一状态
 */
export type Status = {
    code: ErrorCode;
    message: string;
};
/**
 * The background job INFO from database.
 */
export declare class Job {
    /**
     * job id
     */
    id?: string;
    /**
     * job run in graph name
     */
    graphName?: string;
    /**
     * job query
     */
    query?: string;
    /**
     * Job types, such as CREATE_INDEX, CACHE, COMPACT
     */
    type?: string;
    /**
     * Error messages encountered during job execution (if any)
     */
    errMsg?: string;
    /**
     * The results generated by assignments, such as output files or statistical overviews of algorithms.
     */
    result?: Map<any, any>;
    /**
     * job start time
     */
    startTime?: string;
    /**
     * job end time
     */
    endTime?: string;
    /**
     * Current state of the job, which can be FINISHED, RUNNING, STOPPING, STOPPED or FAILED.
     */
    status?: "FINISHED" | "RUNNING" | "STOPPING" | "STOPPED" | "FAILED";
    /**
     * Progress updates for the job, such as indications that the write operation has been started.
     */
    progress?: string;
}
/**
 * The response items of top()
 */
export declare class Process {
    /**
     * process id
     */
    processId?: string;
    /**
     * process query
     */
    processQuery?: string;
    /**
     * duration
     */
    duration?: string;
    /**
     * status
     */
    status?: string;
}
/**
 * hdc.graph.show()
 */
export declare class HDCGraph {
    /**
     * name
     */
    name?: string;
    /**
     * graph name
     */
    graphName?: string;
    /**
     * status
     */
    status?: string;
    /**
     * stats
     */
    stats?: string;
    /**
     * is default
     */
    isDefault?: string;
    /**
     * hdc server name
     */
    hdcServerName?: string;
    /**
     * hdc server status
     */
    hdcServerStatus?: string;
    /**
     * hdc config name
     */
    config?: string;
}
/**
 * projection
 */
export declare class Projection {
    /**
     * name
     */
    name?: string;
    /**
     * graph name
     */
    graphName?: string;
    /**
     * status
     */
    status?: string;
    /**
     * stats
     */
    stats?: string;
    /**
     * config
     */
    config?: string;
}
/**
    * Statistics information about license and usage limits
    */
export interface Stats {
    /**
     * License uuid
     */
    licenseUuid?: string;
    /**
     * Company name
     */
    company?: string;
    /**
     * Department name
     */
    department?: string;
    /**
     * Maximum number of users allowed
     */
    limitedUser?: string;
    /**
     * Maximum number of graphs allowed
     */
    limitedGraph?: string;
    /**
     * Maximum number of nodes allowed
     */
    limitedNode?: string;
    /**
     * Maximum number of edges allowed
     */
    limitedEdge?: string;
    /**
     * Maximum number of shards allowed
     */
    limitedShard?: string;
    /**
     * Maximum number of HDC connections allowed
     */
    limitedHdc?: string;
    /**
     * License expiration date
     */
    expiredDate?: string;
}
/**
 * The graph data about nodes.
 */
export declare class Node {
    /**
     * _uuid
     */
    uuid?: string;
    /**
     * _id
     */
    id?: string;
    /**
     * schema
     */
    schema?: string;
    /**
     * key: value
     */
    values?: {
        [key: string]: any;
    };
    /**
     * returns property value
     * @param propName property name
     * @returns property value
     */
    get?(propName: string): any;
    /**
     * sets property value
     * @param propName
     * @param value
     */
    set?(propName: string, value: any): void;
}
/**
 * Stores edge data.
 */
export declare class Edge {
    /**
     * _uuid
     */
    uuid?: string;
    /**
     * _from_uuid
     */
    fromUuid?: string;
    /**
     * _to_uuid
     */
    toUuid?: string;
    /**
     * _from: from id
     */
    from?: string;
    /**
     * _to: to id
     */
    to?: string;
    /**
     * schema
     */
    schema?: string;
    /**
     * key: value
     */
    values?: {
        [key: string]: any;
    };
    /**
     * returns property value
     * @param propName property name
     * @returns  property value
     */
    get?(propName: string): any;
    /**
     * set property value
     * @param propName
     * @param value
     */
    set?(propName: string, value: any): void;
}
/**
 * 一组边
 */
export type EdgeAlias = {
    edges: Edge[];
    alias: string;
};
/**
 * Path entity
 */
export declare class Path {
    /**
     * Node uuid list
     */
    nodeUuids?: string[];
    /**
     * Edge uuid list
     */
    edgeUuids?: string[];
    /**
     * nodes details
     */
    nodes?: Map<string, Node>;
    /**
     * edges details
     */
    edges?: Map<string, Edge>;
    /**
     * return node by index
     * @param index node index
     * @returns node
    /**
     * return edge length
     * @returns edge length
     */
    length?(): number;
}
/**
 * Graph that contains nodes, edges maps and paths.
 */
export declare class Graph {
    /**
     * Graph path list
     */
    paths?: Path[];
    /**
     * Graph all nodes
     */
    nodes?: Map<string, Node>;
    /**
     * Graph all edges
     */
    edges?: Map<string, Edge>;
    /**
     * Convert path list to
     * @returns Path[]
     */
    getPaths(): Path[];
    /**
     * Add node to nodes
     * @param node new Node
     */
    addNode(node: Node): void;
    /**
     * Add edge to graph
     * @param edge new Edge
     */
    addEdge(edge: Edge): void;
}
/**
 * GraphSet that contains the graph name and total nodes and edges.
 */
export declare class GraphSet {
    /**
     * graph id
     */
    id?: string;
    /**
     * graph name
     */
    name: string;
    /**
     * number of nodes
     */
    totalNodes?: string;
    /**
     * number of edges
     */
    totalEdges?: string;
    /**
     * graph shards list
     */
    shards?: string[];
    /**
     * the partition type of graph
     */
    partitionBy?: string;
    /**
     * status
     */
    status?: string;
    /**
     * graph description
     */
    description?: string | null;
    /**
     * the number of slots
     */
    slotNum?: number | 0;
}
/**
 * Node or edge schemas
 */
export declare class Schema {
    /**
     * schema name
     */
    name: string;
    /**
     * schema description
     */
    description?: string;
    /**
     * properties of schema
     */
    properties?: Property[];
    /**
     * schema type
     */
    dbType: DBType;
    /**
     * node or edge count
     */
    total?: string;
    /**
     * schema id
     */
    id?: string;
    /**
     * store the count for each pair of start and end node schemas of current edge schema.
     */
    stats?: SchemaStat[];
    /**
     * Convert list of schemas to a map of schema Schema name -> Schema
     * @param schemas
     * @returns
     */
    static toDict?(schemas: Schema[]): Map<string, Schema>;
}
/**
 * Statistics for node schema pairs in edge schema
 */
export declare class SchemaStat {
    /**
     * Schema type
     */
    dbType?: DBType;
    /**
     * Schema name
     */
    schema?: string;
    /**
     * From Schema name
     */
    fromSchema: string;
    /**
     * To Schema name
     */
    toSchema: string;
    /**
     * Number of edges between these node schemas
     */
    count: string;
}
export declare class SchemaStats {
    stats: SchemaStat[];
}
/**
 * The properties of schema
 */
export declare class Property {
    /**
     * Property name
     */
    name: string;
    /**
     * PropertyType Enum
     */
    type: UltipaPropertyType;
    /**
     * Sub PropertyType Enum
     */
    subType?: UltipaPropertyType[];
    /**
     * This property is lte
     */
    lte?: boolean;
    /**
     * Whether it has read permission or not true-yes,false-no
     */
    read?: boolean;
    /**
     * Whether it has write permission or not true-yes,false-no
     */
    write?: boolean;
    /**
     * Property`s schema name
     */
    schema: string;
    /**
     * Property`s description
     */
    description?: string;
    /**
     * encrypt method for this property, if null, value is not encrypted
     */
    encrypt?: string;
    /**
     * additional info for this property. For decimal property, it represents the length and precision in parentheses, default is "(20,8)"
     */
    decimalExtra?: DecimalExtral;
}
/**
 * Decimal additional info
 */
export interface DecimalExtral {
    precision: number;
    scale: number;
}
export interface AllProperties {
    nodeProperties: Property[];
    edgeProperties: Property[];
}
export declare class Header {
    propertyName: string;
    propertyType: UltipaPropertyType;
}
/**
 * Table
 */
export declare class Table {
    /**
     * Table name
     */
    name?: string;
    /**
     * Table headers
     */
    headers?: Header[];
    /**
     * Table rows
     */
    rows?: any[][];
    /**
     * Convert table to list of KV
     * @returns
     */
    toKV(): any[];
    getHeaders(): Header[];
    getRows(): any[][];
}
export type Replica = {
    addr: string;
    status: string;
    streamAddr: string;
    lastHearBeat: string;
};
export type Statistics = {
    nodeAffected?: number;
    edgeAffected?: number;
    totalCost: number;
    engineCost: number;
};
/**
 * Attribute Response Data
 */
export declare class Attr {
    /**
     * Ultipa property type
     */
    propertyType?: UltipaPropertyType;
    /**
     * Ultipa result type
     */
    resultType?: ResultType;
    /**
     * Attr values
     */
    values?: object[];
    /**
     * Attr name
     */
    name?: string;
}
export type AttrListData = {
    type: ResultType;
    type_desc: string;
    nodes?: Node[];
    edges?: Edge[];
    paths?: Path[];
    attrs?: Attr[];
};
export declare class ExplainPlan {
    planNodes: PlanNode[];
}
export declare class PlanNode {
    alias: string;
    childrenNum: number;
    uql: string;
    infos: string;
}
export declare function getExplainPlansTreeTopNode(plans: ExplainPlan): PlanNode;
/**
 * The get () method or alias () method of the Response class returns a DataItem embedded in the query result. You need to use the as < Type > () method of the DataItem to convert the result to the appropriate driver type.
 */
export declare class DataItem {
    /**
     * Alias name
     */
    alias?: string;
    /**
     * Ultipa result type
     */
    type?: ResultType;
    /**
     * result entity
     */
    entities?: any;
    constructor(alias: string, type: ResultType, entities: any);
    private _asTypeError;
    asNodes(): Node[];
    asFirstNode(): Node;
    asEdges(): Edge[];
    asFirstEdge(): Edge;
    asPaths(): Path[];
    asGraph(): Graph;
    asTable(): Table;
    asAttr(): Attr;
    asGraphSets(): GraphSet[];
    asProperties(): Property[];
    asSchemas(): Schema[];
    asIndexes(): Index[];
    asPolicies(): Policy[];
    asUsers(): User[];
    asPrivileges(): Privilege[];
    asProcesses(): Process[];
    asHDCGraphs(): HDCGraph[];
    asProjections(): Projection[];
    asAlgos(): Algo[];
    asJobs(): Job[];
    asAny(): any;
    asTableWithT<T>(): T[];
    toJSONString(): string;
}
/**
 * Unified response structure for all requests
 */
export declare class Response {
    /**
     * Holds statistics field of rpc response
     */
    statistics?: Statistics;
    /**
     * Holds status field of rpc response
     */
    status?: Status;
    /**
     * Holds all alias result of grpc api
     */
    aliases?: Alias[];
    /**
     * Holds all result of grpc api, from aliases
     */
    items: {
        [key: string]: DataItem;
    };
    requestInfo?: any;
    /**
     * Holds result of explain uql.
     */
    explainPlan?: ExplainPlan;
    constructor(status?: Status);
    get(index: number): DataItem;
    alias(alias: string): DataItem;
}
export declare class InsertResponse {
    ids?: string[];
    uuids?: string[];
    errorItems?: Map<number, InsertErrorCode>;
    /**
     * Holds statistics field of rpc response
     */
    statistics?: Statistics;
    /**
     * Holds status field of rpc response
     */
    status?: Status;
}
/**
 * Remarks: A language that cannot return two results, use this to return results
 */
export declare class ResponseWithExistCheck {
    /**
     * When insert,return insert item exist
     */
    exist?: boolean;
    /**
     * The insert response
     */
    response: Response;
}
export declare class JobResponse {
    jobId?: string;
    /**
     * Holds statistics field of response
     */
    statistics?: Statistics;
    /**
     * Holds status field of  response
     */
    status?: Status;
}
export interface Alias {
    name?: string;
    type?: ResultType;
}
export type AttrAlias = {
    values: any[];
    type: ResultType;
    type_desc: string;
    alias: string;
};