arangojs/database.d.ts

The official ArangoDB JavaScript driver.

/// <reference types="node" resolution-mode="require"/>
/// <reference types="node" resolution-mode="require"/>
/**
 * ```js
 * import { Database } from "arangojs/database.js";
 * ```
 *
 * The "database" module provides the {@link Database} class and associated
 * types and interfaces for TypeScript.
 *
 * The Database class is also re-exported by the "index" module.
 *
 * @packageDocumentation
 */
import { Analyzer, AnalyzerDescription, CreateAnalyzerOptions } from "./analyzer.js";
import { AqlLiteral, AqlQuery } from "./aql.js";
import { ArangoCollection, Collection, CollectionMetadata, CollectionType, CreateCollectionOptions, DocumentCollection, EdgeCollection } from "./collection.js";
import { ArangoApiResponse, Config, Connection, RequestOptions } from "./connection.js";
import { ArrayCursor } from "./cursor.js";
import { FoxxManifest } from "./foxx-manifest.js";
import { CreateGraphOptions, EdgeDefinitionOptions, Graph, GraphInfo } from "./graph.js";
import { Job } from "./job.js";
import { ArangojsResponse } from "./lib/request.js";
import { Route } from "./route.js";
import { Transaction } from "./transaction.js";
import { CreateViewOptions, View, ViewDescription } from "./view.js";
/**
 * Indicates whether the given value represents a {@link Database}.
 *
 * @param database - A value that might be a database.
 */
export declare function isArangoDatabase(database: any): database is Database;
/**
 * Collections involved in a transaction.
 */
export type TransactionCollections = {
    /**
     * An array of collections or a single collection that will be read from or
     * written to during the transaction with no other writes being able to run
     * in parallel.
     */
    exclusive?: (string | ArangoCollection)[] | string | ArangoCollection;
    /**
     * An array of collections or a single collection that will be read from or
     * written to during the transaction.
     */
    write?: (string | ArangoCollection)[] | string | ArangoCollection;
    /**
     * An array of collections or a single collection that will be read from
     * during the transaction.
     */
    read?: (string | ArangoCollection)[] | string | ArangoCollection;
};
/**
 * Options for how the transaction should be performed.
 */
export type TransactionOptions = {
    /**
     * Whether the transaction may read from collections not specified for this
     * transaction. If set to `false`, accessing any collections not specified
     * will result in the transaction being aborted to avoid potential deadlocks.
     *
     * Default: `true`.
     */
    allowImplicit?: boolean;
    /**
     * If set to `true`, the request will explicitly permit ArangoDB to return a
     * potentially dirty or stale result and arangojs will load balance the
     * request without distinguishing between leaders and followers.
     */
    allowDirtyRead?: boolean;
    /**
     * Determines whether to force the transaction to write all data to disk
     * before returning.
     */
    waitForSync?: boolean;
    /**
     * Determines how long the database will wait while attempting to gain locks
     * on collections used by the transaction before timing out.
     */
    lockTimeout?: number;
    /**
     * Determines the transaction size limit in bytes.
     */
    maxTransactionSize?: number;
    /**
     * If set to `true`, the fast lock round will be skipped, which makes each
     * locking operation take longer but guarantees deterministic locking order
     * and may avoid deadlocks when many concurrent transactions are queued and
     * try to access the same collection with an exclusive lock.
     */
    skipFastLockRound?: boolean;
};
/**
 * Options for executing a query.
 *
 * See {@link Database#query}.
 */
export type QueryOptions = {
    /**
     * If set to `true`, the query will be executed with support for dirty reads
     * enabled, permitting ArangoDB to return a potentially dirty or stale result
     * and arangojs will load balance the request without distinguishing between
     * leaders and followers.
     *
     * Note that dirty reads are only supported for read-only queries, not data
     * modification queries (e.g. using `INSERT`, `UPDATE`, `REPLACE` or
     * `REMOVE`) and only when using ArangoDB 3.4 or later.
     *
     * Default: `false`
     */
    allowDirtyRead?: boolean;
    /**
     * If set to `true`, cursor results will be stored by ArangoDB in such a way
     * that batch reads can be retried in the case of a communication error.
     *
     * Default: `false`
     */
    allowRetry?: boolean;
    /**
     * Maximum time in milliseconds arangojs will wait for a server response.
     * Exceeding this value will result in the request being cancelled.
     *
     * **Note**: Setting a timeout for the client does not guarantee the query
     * will be killed by ArangoDB if it is already being executed. See the
     * `maxRuntime` option for limiting the execution time within ArangoDB.
     */
    timeout?: number;
    /**
     * If set to a positive number, the query will automatically be retried at
     * most this many times if it results in a write-write conflict.
     *
     * Default: `0`
     */
    retryOnConflict?: number;
    /**
     * Unless set to `false`, the number of result values in the result set will
     * be returned in the `count` attribute. This may be disabled by default in
     * a future version of ArangoDB if calculating this value has a performance
     * impact for some queries.
     *
     * Default: `true`.
     */
    count?: boolean;
    /**
     * Number of result values to be transferred by the server in each
     * network roundtrip (or "batch").
     *
     * Must be greater than zero.
     */
    batchSize?: number;
    /**
     * If set to `false`, the AQL query results cache lookup will be skipped for
     * this query.
     *
     * Default: `true`
     */
    cache?: boolean;
    /**
     * Maximum memory size in bytes that the query is allowed to use.
     * Exceeding this value will result in the query failing with an error.
     *
     * If set to `0`, the memory limit is disabled.
     *
     * Default: `0`
     */
    memoryLimit?: number;
    /**
     * Maximum allowed execution time before the query will be killed in seconds.
     *
     * If set to `0`, the query will be allowed to run indefinitely.
     *
     * Default: `0`
     */
    maxRuntime?: number;
    /**
     * Time-to-live for the cursor in seconds. The cursor results may be
     * garbage collected by ArangoDB after this much time has passed.
     *
     * Default: `30`
     */
    ttl?: number;
    /**
     * If set to `true`, the query will throw an exception and abort if it would
      otherwise produce a warning.
     */
    failOnWarning?: boolean;
    /**
     * If set to `1` or `true`, additional query profiling information will be
     * returned in the `extra.profile` attribute if the query is not served from
     * the result cache.
     *
     * If set to `2`, the query will return execution stats per query plan node
     * in the `extra.stats.nodes` attribute. Additionally the query plan is
     * returned in `extra.plan`.
     */
    profile?: boolean | number;
    /**
     * If set to `true`, the query will be executed as a streaming query.
     */
    stream?: boolean;
    /**
     * Limits the maximum number of warnings a query will return.
     */
    maxWarningsCount?: number;
    /**
     * If set to `true` and the query has a `LIMIT` clause, the total number of
     * values matched before the last top-level `LIMIT` in the query was applied
     * will be returned in the `extra.stats.fullCount` attribute.
     */
    fullCount?: boolean;
    /**
     * If set to `false`, the query data will not be stored in the RocksDB block
     * cache. This can be used to avoid thrashing he block cache when reading a
     * lot of data.
     */
    fillBlockCache?: boolean;
    /**
     * An object with a `rules` property specifying a list of optimizer rules to
     * be included or excluded by the optimizer for this query. Prefix a rule
     * name with `+` to include it, or `-` to exclude it. The name `all` acts as
     * an alias matching all optimizer rules.
     */
    optimizer?: {
        rules: string[];
    };
    /**
     * Limits the maximum number of plans that will be created by the AQL query
     * optimizer.
     */
    maxPlans?: number;
    /**
     * Controls after how many execution nodes in a query a stack split should be
     * performed.
     *
     * Default: `250` (`200` on macOS)
     */
    maxNodesPerCallstack?: number;
    /**
     * Maximum size of transactions in bytes.
     */
    maxTransactionSize?: number;
    /**
     * Maximum number of operations after which an intermediate commit is
     * automatically performed.
     */
    intermediateCommitCount?: number;
    /**
     * Maximum total size of operations in bytes after which an intermediate
     * commit is automatically performed.
     */
    intermediateCommitSize?: number;
    /**
     * (Enterprise Edition cluster only.) If set to `true`, collections
     * inaccessible to current user will result in an access error instead
     * of being treated as empty.
     */
    skipInaccessibleCollections?: boolean;
    /**
     * (Enterprise Edition cluster only.) Limits the maximum time in seconds a
     * DBServer will wait to bring satellite collections involved in the query
     * into sync. Exceeding this value will result in the query being stopped.
     *
     * Default: `60`
     */
    satelliteSyncWait?: number;
};
/**
 * Options for explaining a query.
 *
 * See {@link Database#explain}.
 */
export type ExplainOptions = {
    /**
     * An object with a `rules` property specifying a list of optimizer rules to
     * be included or excluded by the optimizer for this query. Prefix a rule
     * name with `+` to include it, or `-` to exclude it. The name `all` acts as
     * an alias matching all optimizer rules.
     */
    optimizer?: {
        rules: string[];
    };
    /**
     * Maximum number of plans that the optimizer is allowed to generate.
     * Setting this to a low value limits the amount of work the optimizer does.
     */
    maxNumberOfPlans?: number;
    /**
     * If set to true, all possible execution plans will be returned as the
     * `plans` property. Otherwise only the optimal execution plan will be
     * returned as the `plan` property.
     *
     * Default: `false`
     */
    allPlans?: boolean;
};
/**
 * Details for a transaction.
 *
 * See also {@link transaction.TransactionStatus}.
 */
export type TransactionDetails = {
    /**
     * Unique identifier of the transaction.
     */
    id: string;
    /**
     * Status (or "state") of the transaction.
     */
    state: "running" | "committed" | "aborted";
};
/**
 * Plan explaining query execution.
 */
export type ExplainPlan = {
    /**
     * Execution nodes in this plan.
     */
    nodes: {
        [key: string]: any;
        type: string;
        id: number;
        dependencies: number[];
        estimatedCost: number;
        estimatedNrItems: number;
    }[];
    /**
     * Rules applied by the optimizer.
     */
    rules: string[];
    /**
     * Information about collections involved in the query.
     */
    collections: {
        name: string;
        type: "read" | "write";
    }[];
    /**
     * Variables used in the query.
     */
    variables: {
        id: number;
        name: string;
    }[];
    /**
     * Total estimated cost of the plan.
     */
    estimatedCost: number;
    /**
     * Estimated number of items returned by the query.
     */
    estimatedNrItems: number;
    /**
     * Whether the query is a data modification query.
     */
    isModificationQuery: boolean;
};
/**
 * Optimizer statistics for an explained query.
 */
export type ExplainStats = {
    /**
     * Total number of rules executed for this query.
     */
    rulesExecuted: number;
    /**
     * Number of rules skipped for this query.
     */
    rulesSkipped: number;
    /**
     * Total number of plans created.
     */
    plansCreated: number;
    /**
     * Maximum memory usage in bytes of the query during explain.
     */
    peakMemoryUsage: number;
    /**
     * Time in seconds needed to explain the query.
     */
    executionTime: number;
};
/**
 * Result of explaining a query with a single plan.
 */
export type SingleExplainResult = {
    /**
     * Query plan.
     */
    plan: ExplainPlan;
    /**
     * Whether it would be possible to cache the query.
     */
    cacheable: boolean;
    /**
     * Warnings encountered while planning the query execution.
     */
    warnings: {
        code: number;
        message: string;
    }[];
    /**
     * Optimizer statistics for the explained query.
     */
    stats: ExplainStats;
};
/**
 * Result of explaining a query with multiple plans.
 */
export type MultiExplainResult = {
    /**
     * Query plans.
     */
    plans: ExplainPlan[];
    /**
     * Whether it would be possible to cache the query.
     */
    cacheable: boolean;
    /**
     * Warnings encountered while planning the query execution.
     */
    warnings: {
        code: number;
        message: string;
    }[];
    /**
     * Optimizer statistics for the explained query.
     */
    stats: ExplainStats;
};
/**
 * Node in an AQL abstract syntax tree (AST).
 */
export type AstNode = {
    [key: string]: any;
    type: string;
    subNodes: AstNode[];
};
/**
 * Result of parsing a query.
 */
export type ParseResult = {
    /**
     * Whether the query was parsed.
     */
    parsed: boolean;
    /**
     * Names of all collections involved in the query.
     */
    collections: string[];
    /**
     * Names of all bind parameters used in the query.
     */
    bindVars: string[];
    /**
     * Abstract syntax tree (AST) of the query.
     */
    ast: AstNode[];
};
/**
 * Optimizer rule for AQL queries.
 */
export type QueryOptimizerRule = {
    name: string;
    flags: {
        hidden: boolean;
        clusterOnly: boolean;
        canBeDisabled: boolean;
        canCreateAdditionalPlans: boolean;
        disabledByDefault: boolean;
        enterpriseOnly: boolean;
    };
};
/**
 * Information about query tracking.
 */
export type QueryTracking = {
    /**
     * Whether query tracking is enabled.
     */
    enabled: boolean;
    /**
     * Maximum query string length in bytes that is kept in the list.
     */
    maxQueryStringLength: number;
    /**
     * Maximum number of slow queries that is kept in the list.
     */
    maxSlowQueries: number;
    /**
     * Threshold execution time in seconds for when a query is
     * considered slow.
     */
    slowQueryThreshold: number;
    /**
     * Whether bind parameters are being tracked along with queries.
     */
    trackBindVars: boolean;
    /**
     * Whether slow queries are being tracked.
     */
    trackSlowQueries: boolean;
};
/**
 * Options for query tracking.
 *
 * See {@link Database#queryTracking}.
 */
export type QueryTrackingOptions = {
    /**
     * If set to `false`, neither queries nor slow queries will be tracked.
     */
    enabled?: boolean;
    /**
     * Maximum query string length in bytes that will be kept in the list.
     */
    maxQueryStringLength?: number;
    /**
     * Maximum number of slow queries to be kept in the list.
     */
    maxSlowQueries?: number;
    /**
     * Threshold execution time in seconds for when a query will be
     * considered slow.
     */
    slowQueryThreshold?: number;
    /**
     * If set to `true`, bind parameters will be tracked along with queries.
     */
    trackBindVars?: boolean;
    /**
     * If set to `true` and `enabled` is also set to `true`, slow queries will be
     * tracked if their execution time exceeds `slowQueryThreshold`.
     */
    trackSlowQueries?: boolean;
};
/**
 * Object describing a query.
 */
export type QueryInfo = {
    /**
     * Unique identifier for this query.
     */
    id: string;
    /**
     * Name of the database the query runs in.
     */
    database: string;
    /**
     * Name of the user that started the query.
     */
    user: string;
    /**
     * Query string (potentially truncated).
     */
    query: string;
    /**
     * Bind parameters used in the query.
     */
    bindVars: Record<string, any>;
    /**
     * Date and time the query was started.
     */
    started: string;
    /**
     * Query's running time in seconds.
     */
    runTime: number;
    /**
     * Maximum memory usage in bytes of the query.
     */
    peakMemoryUsage: number;
    /**
     * Query's current execution state.
     */
    state: "executing" | "finished" | "killed";
    /**
     * Whether the query uses a streaming cursor.
     */
    stream: boolean;
};
/**
 * Information about a cluster imbalance.
 */
export type ClusterImbalanceInfo = {
    /**
     * Information about the leader imbalance.
     */
    leader: {
        /**
         * The weight of leader shards per DB-Server. A leader has a weight of 1 by default but it is higher if collections can only be moved together because of `distributeShardsLike`.
         */
        weightUsed: number[];
        /**
         * The ideal weight of leader shards per DB-Server.
         */
        targetWeight: number[];
        /**
         * The number of leader shards per DB-Server.
         */
        numberShards: number[];
        /**
         * The measure of the leader shard distribution. The higher the number, the worse the distribution.
         */
        leaderDupl: number[];
        /**
         * The sum of all weights.
         */
        totalWeight: number;
        /**
         * The measure of the total imbalance. A high value indicates a high imbalance.
         */
        imbalance: number;
        /**
         * The sum of shards, counting leader shards only.
         */
        totalShards: number;
    };
    /**
     * Information about the shard imbalance.
     */
    shards: {
        /**
         * The size of shards per DB-Server.
         */
        sizeUsed: number[];
        /**
         * The ideal size of shards per DB-Server.
         */
        targetSize: number[];
        /**
         * The number of leader and follower shards per DB-Server.
         */
        numberShards: number[];
        /**
         * The sum of the sizes.
         */
        totalUsed: number;
        /**
         * The sum of shards, counting leader and follower shards.
         */
        totalShards: number;
        /**
         * The sum of system collection shards, counting leader shards only.
         */
        totalShardsFromSystemCollections: number;
        /**
         * The measure of the total imbalance. A high value indicates a high imbalance.
         */
        imbalance: number;
    };
};
/**
 * Information about the current state of the cluster imbalance.
 */
export type ClusterRebalanceState = ClusterImbalanceInfo & {
    /**
     * The number of pending move shard operations.
     */
    pendingMoveShards: number;
    /**
     * The number of planned move shard operations.
     */
    todoMoveShards: number;
};
/**
 * Options for rebalancing the cluster.
 */
export type ClusterRebalanceOptions = {
    /**
     * Maximum number of moves to be computed.
     *
     * Default: `1000`
     */
    maximumNumberOfMoves?: number;
    /**
     * Allow leader changes without moving data.
     *
     * Default: `true`
     */
    leaderChanges?: boolean;
    /**
     * Allow moving leaders.
     *
     * Default: `false`
     */
    moveLeaders?: boolean;
    /**
     * Allow moving followers.
     *
     * Default: `false`
     */
    moveFollowers?: boolean;
    /**
     * Ignore system collections in the rebalance plan.
     *
     * Default: `false`
     */
    excludeSystemCollections?: boolean;
    /**
     * Default: `256**6`
     */
    piFactor?: number;
    /**
     * A list of database names to exclude from the analysis.
     *
     * Default: `[]`
     */
    databasesExcluded?: string[];
};
export type ClusterRebalanceMove = {
    /**
     * The server name from which to move.
     */
    from: string;
    /**
     * The ID of the destination server.
     */
    to: string;
    /**
     * Shard ID of the shard to be moved.
     */
    shard: string;
    /**
     * Collection ID of the collection the shard belongs to.
     */
    collection: number;
    /**
     * True if this is a leader move shard operation.
     */
    isLeader: boolean;
};
export type ClusterRebalanceResult = {
    /**
     * Imbalance before the suggested move shard operations are applied.
     */
    imbalanceBefore: ClusterImbalanceInfo;
    /**
     * Expected imbalance after the suggested move shard operations are applied.
     */
    imbalanceAfter: ClusterImbalanceInfo;
    /**
     * Suggested move shard operations.
     */
    moves: ClusterRebalanceMove[];
};
/**
 * Database user to create with a database.
 */
export type CreateDatabaseUser = {
    /**
     * Username of the user to create.
     */
    username: string;
    /**
     * Password of the user to create.
     *
     * Default: `""`
     */
    passwd?: string;
    /**
     * Whether the user is active.
     *
     * Default: `true`
     */
    active?: boolean;
    /**
     * Additional data to store with the user object.
     */
    extra?: Record<string, any>;
};
/**
 * Options for creating a database.
 *
 * See {@link Database#createDatabase}.
 */
export type CreateDatabaseOptions = {
    /**
     * Database users to create with the database.
     */
    users?: CreateDatabaseUser[];
    /**
     * (Cluster only.) The sharding method to use for new collections in the
     * database.
     */
    sharding?: "" | "flexible" | "single";
    /**
     * (Cluster only.) Default replication factor for new collections in this
     * database.
     *
     * Setting this to `1` disables replication. Setting this to `"satellite"`
     * will replicate to every DBServer.
     */
    replicationFactor?: "satellite" | number;
    /**
     * (Cluster only.) Default write concern for new collections created in this
     * database.
     */
    writeConcern?: number;
};
/**
 * Object describing a database.
 *
 * See {@link Database#get}.
 */
export type DatabaseInfo = {
    /**
     * Name of the database.
     */
    name: string;
    /**
     * Unique identifier of the database.
     */
    id: string;
    /**
     * File system path of the database.
     */
    path: string;
    /**
     * Whether the database is the system database.
     */
    isSystem: boolean;
    /**
     * (Cluster only.) The sharding method to use for new collections in the
     * database.
     */
    sharding?: "" | "flexible" | "single";
    /**
     * (Cluster only.) Default replication factor for new collections in this
     * database.
     */
    replicationFactor?: "satellite" | number;
    /**
     * (Cluster only.) Default write concern for new collections created in this
     * database.
     */
    writeConcern?: number;
};
/**
 * Result of retrieving database version information.
 */
export type VersionInfo = {
    /**
     * Value identifying the server type, i.e. `"arango"`.
     */
    server: string;
    /**
     * ArangoDB license type or "edition".
     */
    license: "community" | "enterprise";
    /**
     * ArangoDB server version.
     */
    version: string;
    /**
     * Additional information about the ArangoDB server.
     */
    details?: {
        [key: string]: string;
    };
};
/**
 * Definition of an AQL User Function.
 */
export type AqlUserFunction = {
    /**
     * Name of the AQL User Function.
     */
    name: string;
    /**
     * Implementation of the AQL User Function.
     */
    code: string;
    /**
     * Whether the function is deterministic.
     *
     * See {@link Database#createFunction}.
     */
    isDeterministic: boolean;
};
/**
 * Options for installing the service.
 *
 * See {@link Database#installService}.
 */
export type InstallServiceOptions = {
    /**
     * An object mapping configuration option names to values.
     *
     * See also {@link Database#getServiceConfiguration}.
     */
    configuration?: Record<string, any>;
    /**
     * An object mapping dependency aliases to mount points.
     *
     * See also {@link Database#getServiceDependencies}.
     */
    dependencies?: Record<string, string>;
    /**
     * Whether the service should be installed in development mode.
     *
     * See also {@link Database#setServiceDevelopmentMode}.
     *
     * Default: `false`
     */
    development?: boolean;
    /**
     * Whether the service should be installed in legacy compatibility mode
     *
     * This overrides the `engines` option in the service manifest (if any).
     *
     * Default: `false`
     */
    legacy?: boolean;
    /**
     * Whether the "setup" script should be executed.
     *
     * Default: `true`
     */
    setup?: boolean;
};
/**
 * Options for replacing a service.
 *
 * See {@link Database#replaceService}.
 */
export type ReplaceServiceOptions = {
    /**
     * An object mapping configuration option names to values.
     *
     * See also {@link Database#getServiceConfiguration}.
     */
    configuration?: Record<string, any>;
    /**
     * An object mapping dependency aliases to mount points.
     *
     * See also {@link Database#getServiceDependencies}.
     */
    dependencies?: Record<string, string>;
    /**
     * Whether the service should be installed in development mode.
     *
     * See also {@link Database#setServiceDevelopmentMode}.
     *
     * Default: `false`
     */
    development?: boolean;
    /**
     * Whether the service should be installed in legacy compatibility mode
     *
     * This overrides the `engines` option in the service manifest (if any).
     *
     * Default: `false`
     */
    legacy?: boolean;
    /**
     * Whether the "setup" script should be executed.
     *
     * Default: `true`
     */
    setup?: boolean;
    /**
     * Whether the existing service's "teardown" script should be executed
     * prior to removing that service.
     *
     * Default: `true`
     */
    teardown?: boolean;
    /**
     * If set to `true`, replacing a service that does not already exist will
     * fall back to installing the new service.
     *
     * Default: `false`
     */
    force?: boolean;
};
/**
 * Options for upgrading a service.
 *
 * See {@link Database#upgradeService}.
 */
export type UpgradeServiceOptions = {
    /**
     * An object mapping configuration option names to values.
     *
     * See also {@link Database#getServiceConfiguration}.
     */
    configuration?: Record<string, any>;
    /**
     * An object mapping dependency aliases to mount points.
     *
     * See also {@link Database#getServiceDependencies}.
     */
    dependencies?: Record<string, string>;
    /**
     * Whether the service should be installed in development mode.
     *
     * See also {@link Database#setServiceDevelopmentMode}.
     *
     * Default: `false`
     */
    development?: boolean;
    /**
     * Whether the service should be installed in legacy compatibility mode
     *
     * This overrides the `engines` option in the service manifest (if any).
     *
     * Default: `false`
     */
    legacy?: boolean;
    /**
     * Whether the "setup" script should be executed.
     *
     * Default: `true`
     */
    setup?: boolean;
    /**
     * Whether the existing service's "teardown" script should be executed
     * prior to upgrading that service.
     *
     * Default: `false`
     */
    teardown?: boolean;
    /**
     * Unless set to `true`, upgrading a service that does not already exist will
     * fall back to installing the new service.
     *
     * Default: `false`
     */
    force?: boolean;
};
/**
 * Options for uninstalling a service.
 *
 * See {@link Database#uninstallService}.
 */
export type UninstallServiceOptions = {
    /**
     * Whether the service's "teardown" script should be executed
     * prior to removing that service.
     *
     * Default: `true`
     */
    teardown?: boolean;
    /**
     * If set to `true`, uninstalling a service that does not already exist
     * will be considered successful.
     *
     * Default: `false`
     */
    force?: boolean;
};
/**
 * Object briefly describing a Foxx service.
 */
export type ServiceSummary = {
    /**
     * Service mount point, relative to the database.
     */
    mount: string;
    /**
     * Name defined in the service manifest.
     */
    name?: string;
    /**
     * Version defined in the service manifest.
     */
    version?: string;
    /**
     * Service dependencies the service expects to be able to match as a mapping
     * from dependency names to versions the service is compatible with.
     */
    provides: Record<string, string>;
    /**
     * Whether development mode is enabled for this service.
     */
    development: boolean;
    /**
     * Whether the service is running in legacy compatibility mode.
     */
    legacy: boolean;
};
/**
 * Object describing a Foxx service in detail.
 */
export type ServiceInfo = {
    /**
     * Service mount point, relative to the database.
     */
    mount: string;
    /**
     * File system path of the service.
     */
    path: string;
    /**
     * Name defined in the service manifest.
     */
    name?: string;
    /**
     * Version defined in the service manifest.
     */
    version?: string;
    /**
     * Whether development mode is enabled for this service.
     */
    development: boolean;
    /**
     * Whether the service is running in legacy compatibility mode.
     */
    legacy: boolean;
    /**
     * Content of the service manifest of this service.
     */
    manifest: FoxxManifest;
    /**
     * Internal checksum of the service's initial source bundle.
     */
    checksum: string;
    /**
     * Options for this service.
     */
    options: {
        /**
         * Configuration values set for this service.
         */
        configuration: Record<string, any>;
        /**
         * Service dependency configuration of this service.
         */
        dependencies: Record<string, string>;
    };
};
/**
 * Object describing a configuration option of a Foxx service.
 */
export type ServiceConfiguration = {
    /**
     * Data type of the configuration value.
     *
     * **Note**: `"int"` and `"bool"` are historical synonyms for `"integer"` and
     * `"boolean"`. The `"password"` type is synonymous with `"string"` but can
     * be used to distinguish values which should not be displayed in plain text
     * by software when managing the service.
     */
    type: "integer" | "boolean" | "string" | "number" | "json" | "password" | "int" | "bool";
    /**
     * Current value of the configuration option as stored internally.
     */
    currentRaw: any;
    /**
     * Processed current value of the configuration option as exposed in the
     * service code.
     */
    current: any;
    /**
     * Formatted name of the configuration option.
     */
    title: string;
    /**
     * Human-readable description of the configuration option.
     */
    description?: string;
    /**
     * Whether the configuration option must be set in order for the service
     * to be operational.
     */
    required: boolean;
    /**
     * Default value of the configuration option.
     */
    default?: any;
};
/**
 * Object describing a single-service dependency defined by a Foxx service.
 */
export type SingleServiceDependency = {
    /**
     * Whether this is a multi-service dependency.
     */
    multiple: false;
    /**
     * Current mount point the dependency is resolved to.
     */
    current?: string;
    /**
     * Formatted name of the dependency.
     */
    title: string;
    /**
     * Name of the service the dependency expects to match.
     */
    name: string;
    /**
     * Version of the service the dependency expects to match.
     */
    version: string;
    /**
     * Human-readable description of the dependency.
     */
    description?: string;
    /**
     * Whether the dependency must be matched in order for the service
     * to be operational.
     */
    required: boolean;
};
/**
 * Object describing a multi-service dependency defined by a Foxx service.
 */
export type MultiServiceDependency = {
    /**
     * Whether this is a multi-service dependency.
     */
    multiple: true;
    /**
     * Current mount points the dependency is resolved to.
     */
    current?: string[];
    /**
     * Formatted name of the dependency.
     */
    title: string;
    /**
     * Name of the service the dependency expects to match.
     */
    name: string;
    /**
     * Version of the service the dependency expects to match.
     */
    version: string;
    /**
     * Human-readable description of the dependency.
     */
    description?: string;
    /**
     * Whether the dependency must be matched in order for the service
     * to be operational.
     */
    required: boolean;
};
/**
 * Test stats for a Foxx service's tests.
 */
export type ServiceTestStats = {
    /**
     * Total number of tests found.
     */
    tests: number;
    /**
     * Number of tests that ran successfully.
     */
    passes: number;
    /**
     * Number of tests that failed.
     */
    failures: number;
    /**
     * Number of tests skipped or not executed.
     */
    pending: number;
    /**
     * Total test duration in milliseconds.
     */
    duration: number;
};
/**
 * Test results for a single test case using the stream reporter.
 */
export type ServiceTestStreamTest = {
    title: string;
    fullTitle: string;
    duration: number;
    err?: string;
};
/**
 * Test results for a Foxx service's tests using the stream reporter.
 */
export type ServiceTestStreamReport = (["start", {
    total: number;
}] | ["pass", ServiceTestStreamTest] | ["fail", ServiceTestStreamTest] | ["end", ServiceTestStats])[];
/**
 * Test results for a single test case using the suite reporter.
 */
export type ServiceTestSuiteTest = {
    result: "pending" | "pass" | "fail";
    title: string;
    duration: number;
    err?: any;
};
/**
 * Test results for a single test suite using the suite reporter.
 */
export type ServiceTestSuite = {
    title: string;
    suites: ServiceTestSuite[];
    tests: ServiceTestSuiteTest[];
};
/**
 * Test results for a Foxx service's tests using the suite reporter.
 */
export type ServiceTestSuiteReport = {
    stats: ServiceTestStats;
    suites: ServiceTestSuite[];
    tests: ServiceTestSuiteTest[];
};
/**
 * Test results for a single test case in XUnit format using the JSONML
 * representation.
 */
export type ServiceTestXunitTest = ["testcase", {
    classname: string;
    name: string;
    time: number;
}] | [
    "testcase",
    {
        classname: string;
        name: string;
        time: number;
    },
    [
        "failure",
        {
            message: string;
            type: string;
        },
        string
    ]
];
/**
 * Test results for a Foxx service's tests in XUnit format using the JSONML
 * representation.
 */
export type ServiceTestXunitReport = [
    "testsuite",
    {
        timestamp: number;
        tests: number;
        errors: number;
        failures: number;
        skip: number;
        time: number;
    },
    ...ServiceTestXunitTest[]
];
/**
 * Test results for a Foxx service's tests in TAP format.
 */
export type ServiceTestTapReport = string[];
/**
 * Test results for a single test case using the default reporter.
 */
export type ServiceTestDefaultTest = {
    title: string;
    fullTitle: string;
    duration: number;
    err?: string;
};
/**
 * Test results for a Foxx service's tests using the default reporter.
 */
export type ServiceTestDefaultReport = {
    stats: ServiceTestStats;
    tests: ServiceTestDefaultTest[];
    pending: ServiceTestDefaultTest[];
    failures: ServiceTestDefaultTest[];
    passes: ServiceTestDefaultTest[];
};
/**
 * OpenAPI 2.0 description of a Foxx service.
 */
export type SwaggerJson = {
    [key: string]: any;
    info: {
        title: string;
        description: string;
        version: string;
        license: string;
    };
    path: {
        [key: string]: any;
    };
};
/**
 * Access level for an ArangoDB user's access to a collection or database.
 */
export type AccessLevel = "rw" | "ro" | "none";
/**
 * Properties of an ArangoDB user object.
 */
export type ArangoUser = {
    /**
     * ArangoDB username of the user.
     */
    user: string;
    /**
     * Whether the ArangoDB user account is enabled and can authenticate.
     */
    active: boolean;
    /**
     * Additional information to store about this user.
     */
    extra: Record<string, any>;
};
/**
 * Options for creating an ArangoDB user.
 */
export type CreateUserOptions = {
    /**
     * ArangoDB username of the user.
     */
    user: string;
    /**
     * Password the ArangoDB user will use for authentication.
     */
    passwd: string;
    /**
     * Whether the ArangoDB user account is enabled and can authenticate.
     *
     * Default: `true`
     */
    active?: boolean;
    /**
     * Additional information to store about this user.
     *
     * Default: `{}`
     */
    extra?: Record<string, any>;
};
/**
 * Options for modifying an ArangoDB user.
 */
export type UserOptions = {
    /**
     * Password the ArangoDB user will use for authentication.
     */
    passwd: string;
    /**
     * Whether the ArangoDB user account is enabled and can authenticate.
     *
     * Default: `true`
     */
    active?: boolean;
    /**
     * Additional information to store about this user.
     *
     * Default: `{}`
     */
    extra?: Record<string, any>;
};
/**
 * Options for accessing or manipulating access levels.
 */
export type UserAccessLevelOptions = {
    /**
     * The database to access or manipulate the access level of.
     *
     * If `collection` is an `ArangoCollection`, this option defaults to the
     * database the collection is contained in. Otherwise this option defaults to
     * the current database.
     */
    database?: Database | string;
    /**
     * The collection to access or manipulate the access level of.
     */
    collection?: ArangoCollection | string;
};
/**
 * An object providing methods for accessing queue time metrics of the most
 * recently received server responses if the server supports this feature.
 */
export type QueueTimeMetrics = {
    /**
     * Returns the queue time of the most recently received response in seconds.
     */
    getLatest: () => number | undefined;
    /**
     * Returns a list of the most recently received queue time values as tuples
     * of the timestamp of the response being processed in milliseconds and the
     * queue time in seconds.
     */
    getValues: () => [number, number][];
    /**
     * Returns the average queue time of the most recently received responses
     * in seconds.
     */
    getAvg: () => number;
};
/**
 * (Enterprise Edition only.) Options for creating a hot backup.
 */
export type HotBackupOptions = {
    /**
     * If set to `true` and no global transaction lock can be acquired within the
     * given timeout, a possibly inconsistent backup is taken.
     *
     * Default: `false`
     */
    allowInconsistent?: boolean;
    /**
     * (Enterprise Edition cluster only.) If set to `true` and no global
     * transaction lock can be acquired within the given timeout, all running
     * transactions are forcefully aborted to ensure that a consistent backup
     * can be created.
     *
     * Default: `false`.
     */
    force?: boolean;
    /**
     * Label to appended to the backup's identifier.
     *
     * Default: If omitted or empty, a UUID will be generated.
     */
    label?: string;
    /**
     * Time in seconds that the operation will attempt to get a consistent
     * snapshot.
     *
     * Default: `120`.
     */
    timeout?: number;
};
/**
 * (Enterprise Edition only.) Result of a hot backup.
 */
export type HotBackupResult = {
    id: string;
    potentiallyInconsistent: boolean;
    sizeInBytes: number;
    datetime: string;
    nrDBServers: number;
    nrFiles: number;
};
/**
 * (Enterprise Edition only.) List of known hot backups.
 */
export type HotBackupList = {
    server: string;
    list: Record<string, HotBackupResult & {
        version: string;
        keys: any[];
        available: boolean;
        nrPiecesPresent: number;
        countIncludesFilesOnly: boolean;
    }>;
};
/**
 * Numeric representation of the logging level of a log entry.
 */
export declare enum LogLevel {
    FATAL = 0,
    ERROR = 1,
    WARNING = 2,
    INFO = 3,
    DEBUG = 4
}
/**
 * String representation of the logging level of a log entry.
 */
export type LogLevelLabel = "FATAL" | "ERROR" | "WARNING" | "INFO" | "DEBUG";
/**
 * Logging level setting.
 */
export type LogLevelSetting = LogLevelLabel | "DEFAULT";
/**
 * Log sorting direction, ascending or descending.
 */
export type LogSortDirection = "asc" | "desc";
/**
 * Options for retrieving log entries.
 */
export type LogEntriesOptions = {
    /**
     * Maximum log level of the entries to retrieve.
     *
     * Default: `INFO`.
     */
    upto?: LogLevel | LogLevelLabel | Lowercase<LogLevelLabel>;
    /**
     * If set, only log entries with this log level will be returned.
     */
    level?: LogLevel | LogLevelLabel | Lowercase<LogLevelLabel>;
    /**
     * If set, only log entries with an `lid` greater than or equal to this value
     * will be returned.
     */
    start?: number;
    /**
     * If set, only this many entries will be returned.
     */
    size?: number;
    /**
     * If set, this many log entries will be skipped.
     */
    offset?: number;
    /**
     * If set, only log entries containing the specified text will be returned.
     */
    search?: string;
    /**
     * If set to `"desc"`, log entries will be returned in reverse chronological
     * order.
     *
     * Default: `"asc"`.
     */
    sort?: LogSortDirection;
};
/**
 * An object representing a single log entry.
 */
export type LogMessage = {
    id: number;
    topic: string;
    level: LogLevelLabel;
    date: string;
    message: string;
};
/**
 * An object representing a list of log entries.
 */
export type LogEntries = {
    totalAmount: number;
    lid: number[];
    topic: string[];
    level: LogLevel[];
    timestamp: number[];
    text: string[];
};
type TrappedError = {
    error: true;
};
type TrappedRequest = {
    error?: false;
    jobId: string;
    onResolve: (res: ArangojsResponse) => void;
    onReject: (error: any) => void;
};
/**
 * An object representing a single ArangoDB database. All arangojs collections,
 * cursors, analyzers and so on are linked to a `Database` object.
 */
export declare class Database {
    protected _connection: Connection;
    protected _name: string;
    protected _analyzers: Map<string, Analyzer>;
    protected _collections: Map<string, Collection<any, any>>;
    protected _graphs: Map<string, Graph>;
    protected _views: Map<string, View>;
    protected _trapRequest?: (trapped: TrappedError | TrappedRequest) => void;
    /**
     * Creates a new `Database` instance with its own connection pool.
     *
     * See also {@link Database#database}.
     *
     * @param config - An object with configuration options.
     *
     * @example
     * ```js
     * const db = new Database({
     *   url: "http://127.0.0.1:8529",
     *   databaseName: "my_database",
     *   auth: { username: "admin", password: "hunter2" },
     * });
     * ```
     */
    constructor(config?: Config);
    /**
     * Creates a new `Database` instance with its own connection pool.
     *
     * See also {@link Database#database}.
     *
     * @param url - Base URL of the ArangoDB server or list of server URLs.
     * Equivalent to the `url` option in {@link connection.Config}.
     *
     * @example
     * ```js
     * const db = new Database("http://127.0.0.1:8529", "my_database");
     * db.useBasicAuth("admin", "hunter2");
     * ```
     */
    constructor(url: string | string[], name?: string);
    /**
     * @internal
     */
    constructor(database: Database, name?: string);
    /**
     * @internal
     *
     * Indicates that this object represents an ArangoDB database.
     */
    get isArangoDatabase(): true;
    /**
     * Name of the ArangoDB database this instance represents.
     */
    get name(): string;
    /**
     * Fetches version information from the ArangoDB server.
     *
     * @param details - If set to `true`, additional information about the
     * ArangoDB server will be available as the `details` property.
     *
     * @example
     * ```js
     * const db = new Database();
     * const version = await db.version();
     * // the version object contains the ArangoDB version information.
     * // license: "community" or "enterprise"
     * // version: ArangoDB version number
     * // server: description of the server
     * ```
     */
    version(details?: boolean): Promise<VersionInfo>;
    /**
     * Retrives the server's current system time in milliseconds with microsecond
     * precision.
     */
    time(): Promise<number>;
    /**
     * Returns a new {@link route.Route} instance for the given path (relative to the
     * database) that can be used to perform arbitrary HTTP requests.
     *
     * @param path - The database-relative URL of the route. Defaults to the
     * database API root.
     * @param headers - Default headers that should be sent with each request to
     * the route.
     *
     * @example
     * ```js
     * const db = new Database();
     * const myFoxxService = db.route("my-foxx-service");
     * const response = await myFoxxService.post("users", {
     *   username: "admin",
     *   password: "hunter2"
     * });
     * // response.body is the result of
     * // POST /_db/_system/my-foxx-service/users
     * // with JSON request body '{"username": "admin", "password": "hunter2"}'
     * ```
     */
    route(path?: string, headers?: Headers | Record<string, string>): Route;
    /**
     * Creates an async job by executing the given callback function. The first
     * database request performed by the callback will be marked for asynchronous
     * execution and its result will be made available as an async job.
     *
     * Returns a {@link Job} instance that can be used to retrieve the result
     * of the callback function once the request has been executed.
     *
     * @param callback - Callback function to execute as an async job.
     *
     * @example
     * ```js
     * const db = new Database();
     * const job = await db.createJob(() => db.collections());
     * while (!job.isLoaded) {
     *  await timeout(1000);
     *  await job.load();
     * }
     * // job.result is a list of Collection instances
     * ```
     */
    createJob<T>(callback: () => Promise<T>): Promise<Job<T>>;
    /**
     * @internal
     *
     * Performs an arbitrary HTTP request against the database.
     *
     * If `absolutePath` is set to `true`, the database path will not be
     * automatically prepended to the `basePath`.
     *
     * @param T - Return type to use. Defaults to the response object type.
     * @param options - Options for this request.
     * @param transform - An optional function to transform the low-level
     * response object to a more useful return value.
     */
    request<T = any>(options: RequestOptions & {
        absolutePath?: boolean;
    }, transform?: (res: ArangojsResponse) => T): Promise<T>;
    /**
     * @internal
     *
     * Performs an arbitrary HTTP request against the database.
     *
     * If `absolutePath` is set to `true`, the database path will not be
     * automatically prepended to the `basePath`.
     *
     * @param options - Options for this request.
     * @param transform - If set to `false`, the raw response object will be
     * returned.
     */
    request(options: RequestOptions & {
        absolutePath?: boolean;
    }, transform: false): Promise<ArangojsResponse>;
    /**
     * Updates the URL list by requesting a list of all coordinators in the
     * cluster and adding any endpoints not initially specified in the
     * {@link connection.Config}.
     *
     * For long-running processes communicating with an ArangoDB cluster it is
     * recommended to run this method periodically (e.g. once per hour) to make
     * sure new coordinators are picked up correctly and can be used for
     * fail-over or load balancing.
     *
     * @param overwrite - If set to `true`, the existing host list will be
     * replaced instead of extended.
     *
     * @example
     * ```js
     * const db = new Database();
     * const interval = setInterval(
     *   () => db.acquireHostList(),
     *   5 * 60 * 1000 // every 5 minutes
     * );
     *
     * // later
     * clearInterval(interval);
     * system.close();
     * ```
     */
    acquireHostList(overwrite?: boolean): Promise<void>;
    /**
     * Closes all active connections of this database instance.
     *
     * Can be used to clean up idling connections during longer periods of
     * inactivity.
     *
     * **Note**: This method currently has no effect in the browser version of
     * arangojs.
     *
     * @example
     * ```js
     * const db = new Database();
     * const sessions = db.collection("sessions");
     * // Clean up expired sessions once per hour
     * setInterval(async () => {
     *   await db.query(aql`
     *     FOR session IN ${sessions}
     *     FILTER session.expires < DATE_NOW()
     *     REMOVE session IN ${sessions}
     *   `);
     *   // Making sure to close the connections because they're no longer used
     *   system.close();
     * }, 1000 * 60 * 60