/// <reference types="node" />

declare namespace ArangoDB {

type JwtAlgorithm = "HS512" | "HS384" | "HS256";

type HashAlgorithm =

| "sha512"

| "sha384"

| "sha256"

| "sha224"

| "sha1"

| "md5";

type HttpMethod =

| "HEAD"

| "GET"

| "POST"

| "PUT"

| "PATCH"

| "DELETE"

| "OPTIONS";

type HttpStatus =

| "continue"

| "switching protocols"

| "processing"

| "ok"

| "created"

| "accepted"

| "non-authoritative information"

| "no content"

| "reset content"

| "partial content"

| "multi-status"

| "already reported"

| "im used"

| "multiple choices"

| "moved permanently"

| "found"

| "see other"

| "not modified"

| "use proxy"

| "(unused)"

| "temporary redirect"

| "permanent redirect"

| "bad request"

| "unauthorized"

| "payment required"

| "forbidden"

| "not found"

| "method not allowed"

| "not acceptable"

| "proxy authentication required"

| "request timeout"

| "conflict"

| "gone"

| "length required"

| "precondition failed"

| "payload too large"

| "uri too long"

| "unsupported media type"

| "range not satisfiable"

| "expectation failed"

| "i'm a teapot"

| "misdirected request"

| "unprocessable entity"

| "locked"

| "failed dependency"

| "unordered collection"

| "upgrade required"

| "precondition required"

| "too many requests"

| "request header fields too large"

| "unavailable for legal reasons"

| "internal server error"

| "not implemented"

| "bad gateway"

| "service unavailable"

| "gateway timeout"

| "http version not supported"

| "variant also negotiates"

| "insufficient storage"

| "loop detected"

| "bandwidth limit exceeded"

| "not extended"

| "network authentication required";

type EdgeDirection = "any" | "inbound" | "outbound";

type EngineType = "mmfiles" | "rocksdb";

type IndexType = "persistent" | "hash" | "skiplist" | "fulltext" | "geo" | "ttl";

type ViewType = "arangosearch";

type KeyGeneratorType = "traditional" | "autoincrement" | "padded" | "uuid";

type ErrorName =

| "ERROR_NO_ERROR"

| "ERROR_FAILED"

| "ERROR_SYS_ERROR"

| "ERROR_OUT_OF_MEMORY"

| "ERROR_INTERNAL"

| "ERROR_ILLEGAL_NUMBER"

| "ERROR_NUMERIC_OVERFLOW"

| "ERROR_ILLEGAL_OPTION"

| "ERROR_DEAD_PID"

| "ERROR_NOT_IMPLEMENTED"

| "ERROR_BAD_PARAMETER"

| "ERROR_FORBIDDEN"

| "ERROR_OUT_OF_MEMORY_MMAP"

| "ERROR_CORRUPTED_CSV"

| "ERROR_FILE_NOT_FOUND"

| "ERROR_CANNOT_WRITE_FILE"

| "ERROR_CANNOT_OVERWRITE_FILE"

| "ERROR_TYPE_ERROR"

| "ERROR_LOCK_TIMEOUT"

| "ERROR_CANNOT_CREATE_DIRECTORY"

| "ERROR_CANNOT_CREATE_TEMP_FILE"

| "ERROR_REQUEST_CANCELED"

| "ERROR_DEBUG"

| "ERROR_IP_ADDRESS_INVALID"

| "ERROR_FILE_EXISTS"

| "ERROR_LOCKED"

| "ERROR_DEADLOCK"

| "ERROR_SHUTTING_DOWN"

| "ERROR_ONLY_ENTERPRISE"

| "ERROR_RESOURCE_LIMIT"

| "ERROR_ARANGO_ICU_ERROR"

| "ERROR_CANNOT_READ_FILE"

| "ERROR_HTTP_BAD_PARAMETER"

| "ERROR_HTTP_UNAUTHORIZED"

| "ERROR_HTTP_FORBIDDEN"

| "ERROR_HTTP_NOT_FOUND"

| "ERROR_HTTP_METHOD_NOT_ALLOWED"

| "ERROR_HTTP_NOT_ACCEPTABLE"

| "ERROR_HTTP_PRECONDITION_FAILED"

| "ERROR_HTTP_SERVER_ERROR"

| "ERROR_HTTP_SERVICE_UNAVAILABLE"

| "ERROR_HTTP_GATEWAY_TIMEOUT"

| "ERROR_HTTP_CORRUPTED_JSON"

| "ERROR_HTTP_SUPERFLUOUS_SUFFICES"

| "ERROR_ARANGO_ILLEGAL_STATE"

| "ERROR_ARANGO_DATAFILE_SEALED"

| "ERROR_ARANGO_READ_ONLY"

| "ERROR_ARANGO_DUPLICATE_IDENTIFIER"

| "ERROR_ARANGO_DATAFILE_UNREADABLE"

| "ERROR_ARANGO_DATAFILE_EMPTY"

| "ERROR_ARANGO_RECOVERY"

| "ERROR_ARANGO_DATAFILE_STATISTICS_NOT_FOUND"

| "ERROR_ARANGO_CORRUPTED_DATAFILE"

| "ERROR_ARANGO_ILLEGAL_PARAMETER_FILE"

| "ERROR_ARANGO_CORRUPTED_COLLECTION"

| "ERROR_ARANGO_MMAP_FAILED"

| "ERROR_ARANGO_FILESYSTEM_FULL"

| "ERROR_ARANGO_NO_JOURNAL"

| "ERROR_ARANGO_DATAFILE_ALREADY_EXISTS"

| "ERROR_ARANGO_DATADIR_LOCKED"

| "ERROR_ARANGO_COLLECTION_DIRECTORY_ALREADY_EXISTS"

| "ERROR_ARANGO_MSYNC_FAILED"

| "ERROR_ARANGO_DATADIR_UNLOCKABLE"

| "ERROR_ARANGO_SYNC_TIMEOUT"

| "ERROR_ARANGO_CONFLICT"

| "ERROR_ARANGO_DATADIR_INVALID"

| "ERROR_ARANGO_DOCUMENT_NOT_FOUND"

| "ERROR_ARANGO_DATA_SOURCE_NOT_FOUND"

| "ERROR_ARANGO_COLLECTION_PARAMETER_MISSING"

| "ERROR_ARANGO_DOCUMENT_HANDLE_BAD"

| "ERROR_ARANGO_MAXIMAL_SIZE_TOO_SMALL"

| "ERROR_ARANGO_DUPLICATE_NAME"

| "ERROR_ARANGO_ILLEGAL_NAME"

| "ERROR_ARANGO_NO_INDEX"

| "ERROR_ARANGO_UNIQUE_CONSTRAINT_VIOLATED"

| "ERROR_ARANGO_INDEX_NOT_FOUND"

| "ERROR_ARANGO_CROSS_COLLECTION_REQUEST"

| "ERROR_ARANGO_INDEX_HANDLE_BAD"

| "ERROR_ARANGO_DOCUMENT_TOO_LARGE"

| "ERROR_ARANGO_COLLECTION_NOT_UNLOADED"

| "ERROR_ARANGO_COLLECTION_TYPE_INVALID"

| "ERROR_ARANGO_VALIDATION_FAILED"

| "ERROR_ARANGO_ATTRIBUTE_PARSER_FAILED"

| "ERROR_ARANGO_DOCUMENT_KEY_BAD"

| "ERROR_ARANGO_DOCUMENT_KEY_UNEXPECTED"

| "ERROR_ARANGO_DATADIR_NOT_WRITABLE"

| "ERROR_ARANGO_OUT_OF_KEYS"

| "ERROR_ARANGO_DOCUMENT_KEY_MISSING"

| "ERROR_ARANGO_DOCUMENT_TYPE_INVALID"

| "ERROR_ARANGO_DATABASE_NOT_FOUND"

| "ERROR_ARANGO_DATABASE_NAME_INVALID"

| "ERROR_ARANGO_USE_SYSTEM_DATABASE"

| "ERROR_ARANGO_ENDPOINT_NOT_FOUND"

| "ERROR_ARANGO_INVALID_KEY_GENERATOR"

| "ERROR_ARANGO_INVALID_EDGE_ATTRIBUTE"

| "ERROR_ARANGO_INDEX_DOCUMENT_ATTRIBUTE_MISSING"

| "ERROR_ARANGO_INDEX_CREATION_FAILED"

| "ERROR_ARANGO_WRITE_THROTTLE_TIMEOUT"

| "ERROR_ARANGO_COLLECTION_TYPE_MISMATCH"

| "ERROR_ARANGO_COLLECTION_NOT_LOADED"

| "ERROR_ARANGO_DOCUMENT_REV_BAD"

| "ERROR_ARANGO_DATAFILE_FULL"

| "ERROR_ARANGO_EMPTY_DATADIR"

| "ERROR_ARANGO_TRY_AGAIN"

| "ERROR_ARANGO_BUSY"

| "ERROR_ARANGO_MERGE_IN_PROGRESS"

| "ERROR_ARANGO_IO_ERROR"

| "ERROR_REPLICATION_NO_RESPONSE"

| "ERROR_REPLICATION_INVALID_RESPONSE"

| "ERROR_REPLICATION_MASTER_ERROR"

| "ERROR_REPLICATION_MASTER_INCOMPATIBLE"

| "ERROR_REPLICATION_MASTER_CHANGE"

| "ERROR_REPLICATION_LOOP"

| "ERROR_REPLICATION_UNEXPECTED_MARKER"

| "ERROR_REPLICATION_INVALID_APPLIER_STATE"

| "ERROR_REPLICATION_UNEXPECTED_TRANSACTION"

| "ERROR_REPLICATION_INVALID_APPLIER_CONFIGURATION"

| "ERROR_REPLICATION_RUNNING"

| "ERROR_REPLICATION_APPLIER_STOPPED"

| "ERROR_REPLICATION_NO_START_TICK"

| "ERROR_REPLICATION_START_TICK_NOT_PRESENT"

| "ERROR_REPLICATION_WRONG_CHECKSUM"

| "ERROR_REPLICATION_SHARD_NONEMPTY"

| "ERROR_CLUSTER_NO_AGENCY"

| "ERROR_CLUSTER_NO_COORDINATOR_HEADER"

| "ERROR_CLUSTER_COULD_NOT_LOCK_PLAN"

| "ERROR_CLUSTER_COLLECTION_ID_EXISTS"

| "ERROR_CLUSTER_COULD_NOT_CREATE_COLLECTION_IN_PLAN"

| "ERROR_CLUSTER_COULD_NOT_READ_CURRENT_VERSION"

| "ERROR_CLUSTER_COULD_NOT_CREATE_COLLECTION"

| "ERROR_CLUSTER_TIMEOUT"

| "ERROR_CLUSTER_COULD_NOT_REMOVE_COLLECTION_IN_PLAN"

| "ERROR_CLUSTER_COULD_NOT_REMOVE_COLLECTION_IN_CURRENT"

| "ERROR_CLUSTER_COULD_NOT_CREATE_DATABASE_IN_PLAN"

| "ERROR_CLUSTER_COULD_NOT_CREATE_DATABASE"

| "ERROR_CLUSTER_COULD_NOT_REMOVE_DATABASE_IN_PLAN"

| "ERROR_CLUSTER_COULD_NOT_REMOVE_DATABASE_IN_CURRENT"

| "ERROR_CLUSTER_SHARD_GONE"

| "ERROR_CLUSTER_CONNECTION_LOST"

| "ERROR_CLUSTER_MUST_NOT_SPECIFY_KEY"

| "ERROR_CLUSTER_GOT_CONTRADICTING_ANSWERS"

| "ERROR_CLUSTER_NOT_ALL_SHARDING_ATTRIBUTES_GIVEN"

| "ERROR_CLUSTER_MUST_NOT_CHANGE_SHARDING_ATTRIBUTES"

| "ERROR_CLUSTER_UNSUPPORTED"

| "ERROR_CLUSTER_ONLY_ON_COORDINATOR"

| "ERROR_CLUSTER_READING_PLAN_AGENCY"

| "ERROR_CLUSTER_COULD_NOT_TRUNCATE_COLLECTION"

| "ERROR_CLUSTER_AQL_COMMUNICATION"

| "ERROR_ARANGO_DOCUMENT_NOT_FOUND_OR_SHARDING_ATTRIBUTES_CHANGED"

| "ERROR_CLUSTER_COULD_NOT_DETERMINE_ID"

| "ERROR_CLUSTER_ONLY_ON_DBSERVER"

| "ERROR_CLUSTER_BACKEND_UNAVAILABLE"

| "ERROR_CLUSTER_UNKNOWN_CALLBACK_ENDPOINT"

| "ERROR_CLUSTER_AGENCY_STRUCTURE_INVALID"

| "ERROR_CLUSTER_AQL_COLLECTION_OUT_OF_SYNC"

| "ERROR_CLUSTER_COULD_NOT_CREATE_INDEX_IN_PLAN"

| "ERROR_CLUSTER_COULD_NOT_DROP_INDEX_IN_PLAN"

| "ERROR_CLUSTER_CHAIN_OF_DISTRIBUTESHARDSLIKE"

| "ERROR_CLUSTER_MUST_NOT_DROP_COLL_OTHER_DISTRIBUTESHARDSLIKE"

| "ERROR_CLUSTER_UNKNOWN_DISTRIBUTESHARDSLIKE"

| "ERROR_CLUSTER_INSUFFICIENT_DBSERVERS"

| "ERROR_CLUSTER_COULD_NOT_DROP_FOLLOWER"

| "ERROR_CLUSTER_SHARD_LEADER_REFUSES_REPLICATION"

| "ERROR_CLUSTER_SHARD_FOLLOWER_REFUSES_OPERATION"

| "ERROR_CLUSTER_SHARD_LEADER_RESIGNED"

| "ERROR_CLUSTER_AGENCY_COMMUNICATION_FAILED"

| "ERROR_CLUSTER_DISTRIBUTE_SHARDS_LIKE_REPLICATION_FACTOR"

| "ERROR_CLUSTER_DISTRIBUTE_SHARDS_LIKE_NUMBER_OF_SHARDS"

| "ERROR_CLUSTER_LEADERSHIP_CHALLENGE_ONGOING"

| "ERROR_CLUSTER_NOT_LEADER"

| "ERROR_CLUSTER_COULD_NOT_CREATE_VIEW_IN_PLAN"

| "ERROR_QUERY_KILLED"

| "ERROR_QUERY_PARSE"

| "ERROR_QUERY_EMPTY"

| "ERROR_QUERY_SCRIPT"

| "ERROR_QUERY_NUMBER_OUT_OF_RANGE"

| "ERROR_QUERY_VARIABLE_NAME_INVALID"

| "ERROR_QUERY_VARIABLE_REDECLARED"

| "ERROR_QUERY_VARIABLE_NAME_UNKNOWN"

| "ERROR_QUERY_COLLECTION_LOCK_FAILED"

| "ERROR_QUERY_TOO_MANY_COLLECTIONS"

| "ERROR_QUERY_DOCUMENT_ATTRIBUTE_REDECLARED"

| "ERROR_QUERY_FUNCTION_NAME_UNKNOWN"

| "ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH"

| "ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH"

| "ERROR_QUERY_INVALID_REGEX"

| "ERROR_QUERY_BIND_PARAMETERS_INVALID"

| "ERROR_QUERY_BIND_PARAMETER_MISSING"

| "ERROR_QUERY_BIND_PARAMETER_UNDECLARED"

| "ERROR_QUERY_BIND_PARAMETER_TYPE"

| "ERROR_QUERY_INVALID_LOGICAL_VALUE"

| "ERROR_QUERY_INVALID_ARITHMETIC_VALUE"

| "ERROR_QUERY_DIVISION_BY_ZERO"

| "ERROR_QUERY_ARRAY_EXPECTED"

| "ERROR_QUERY_FAIL_CALLED"

| "ERROR_QUERY_GEO_INDEX_MISSING"

| "ERROR_QUERY_FULLTEXT_INDEX_MISSING"

| "ERROR_QUERY_INVALID_DATE_VALUE"

| "ERROR_QUERY_MULTI_MODIFY"

| "ERROR_QUERY_INVALID_AGGREGATE_EXPRESSION"

| "ERROR_QUERY_COMPILE_TIME_OPTIONS"

| "ERROR_QUERY_EXCEPTION_OPTIONS"

| "ERROR_QUERY_COLLECTION_USED_IN_EXPRESSION"

| "ERROR_QUERY_DISALLOWED_DYNAMIC_CALL"

| "ERROR_QUERY_ACCESS_AFTER_MODIFICATION"

| "ERROR_QUERY_FUNCTION_INVALID_NAME"

| "ERROR_QUERY_FUNCTION_INVALID_CODE"

| "ERROR_QUERY_FUNCTION_NOT_FOUND"

| "ERROR_QUERY_FUNCTION_RUNTIME_ERROR"

| "ERROR_QUERY_BAD_JSON_PLAN"

| "ERROR_QUERY_NOT_FOUND"

| "ERROR_QUERY_IN_USE"

| "ERROR_QUERY_USER_ASSERT"

| "ERROR_QUERY_USER_WARN"

| "ERROR_CURSOR_NOT_FOUND"

| "ERROR_CURSOR_BUSY"

| "ERROR_TRANSACTION_INTERNAL"

| "ERROR_TRANSACTION_NESTED"

| "ERROR_TRANSACTION_UNREGISTERED_COLLECTION"

| "ERROR_TRANSACTION_DISALLOWED_OPERATION"

| "ERROR_TRANSACTION_ABORTED"

| "ERROR_USER_INVALID_NAME"

| "ERROR_USER_INVALID_PASSWORD"

| "ERROR_USER_DUPLICATE"

| "ERROR_USER_NOT_FOUND"

| "ERROR_USER_CHANGE_PASSWORD"

| "ERROR_USER_EXTERNAL"

| "ERROR_SERVICE_INVALID_NAME"

| "ERROR_SERVICE_INVALID_MOUNT"

| "ERROR_SERVICE_DOWNLOAD_FAILED"

| "ERROR_SERVICE_UPLOAD_FAILED"

| "ERROR_LDAP_CANNOT_INIT"

| "ERROR_LDAP_CANNOT_SET_OPTION"

| "ERROR_LDAP_CANNOT_BIND"

| "ERROR_LDAP_CANNOT_UNBIND"

| "ERROR_LDAP_CANNOT_SEARCH"

| "ERROR_LDAP_CANNOT_START_TLS"

| "ERROR_LDAP_FOUND_NO_OBJECTS"

| "ERROR_LDAP_NOT_ONE_USER_FOUND"

| "ERROR_LDAP_USER_NOT_IDENTIFIED"

| "ERROR_LDAP_INVALID_MODE"

| "ERROR_TASK_INVALID_ID"

| "ERROR_TASK_DUPLICATE_ID"

| "ERROR_TASK_NOT_FOUND"

| "ERROR_GRAPH_INVALID_GRAPH"

| "ERROR_GRAPH_COULD_NOT_CREATE_GRAPH"

| "ERROR_GRAPH_INVALID_VERTEX"

| "ERROR_GRAPH_COULD_NOT_CREATE_VERTEX"

| "ERROR_GRAPH_COULD_NOT_CHANGE_VERTEX"

| "ERROR_GRAPH_INVALID_EDGE"

| "ERROR_GRAPH_COULD_NOT_CREATE_EDGE"

| "ERROR_GRAPH_COULD_NOT_CHANGE_EDGE"

| "ERROR_GRAPH_TOO_MANY_ITERATIONS"

| "ERROR_GRAPH_INVALID_FILTER_RESULT"

| "ERROR_GRAPH_EMPTY"

| "ERROR_SESSION_UNKNOWN"

| "ERROR_SESSION_EXPIRED"

| "SIMPLE_CLIENT_UNKNOWN_ERROR"

| "SIMPLE_CLIENT_COULD_NOT_CONNECT"

| "SIMPLE_CLIENT_COULD_NOT_WRITE"

| "SIMPLE_CLIENT_COULD_NOT_READ"

| "COMMUNICATOR_REQUEST_ABORTED"

| "COMMUNICATOR_DISABLED"

| "ERROR_MALFORMED_MANIFEST_FILE"

| "ERROR_INVALID_SERVICE_MANIFEST"

| "ERROR_SERVICE_FILES_MISSING"

| "ERROR_SERVICE_FILES_OUTDATED"

| "ERROR_INVALID_FOXX_OPTIONS"

| "ERROR_INVALID_MOUNTPOINT"

| "ERROR_SERVICE_NOT_FOUND"

| "ERROR_SERVICE_NEEDS_CONFIGURATION"

| "ERROR_SERVICE_MOUNTPOINT_CONFLICT"

| "ERROR_SERVICE_MANIFEST_NOT_FOUND"

| "ERROR_SERVICE_OPTIONS_MALFORMED"

| "ERROR_SERVICE_SOURCE_NOT_FOUND"

| "ERROR_SERVICE_SOURCE_ERROR"

| "ERROR_SERVICE_UNKNOWN_SCRIPT"

| "ERROR_MODULE_NOT_FOUND"

| "ERROR_MODULE_SYNTAX_ERROR"

| "ERROR_MODULE_FAILURE"

| "ERROR_NO_SMART_COLLECTION"

| "ERROR_NO_SMART_GRAPH_ATTRIBUTE"

| "ERROR_CANNOT_DROP_SMART_COLLECTION"

| "ERROR_KEY_MUST_BE_PREFIXED_WITH_SMART_GRAPH_ATTRIBUTE"

| "ERROR_ILLEGAL_SMART_GRAPH_ATTRIBUTE"

| "ERROR_AGENCY_INQUIRY_SYNTAX"

| "ERROR_AGENCY_INFORM_MUST_BE_OBJECT"

| "ERROR_AGENCY_INFORM_MUST_CONTAIN_TERM"

| "ERROR_AGENCY_INFORM_MUST_CONTAIN_ID"

| "ERROR_AGENCY_INFORM_MUST_CONTAIN_ACTIVE"

| "ERROR_AGENCY_INFORM_MUST_CONTAIN_POOL"

| "ERROR_AGENCY_INFORM_MUST_CONTAIN_MIN_PING"

| "ERROR_AGENCY_INFORM_MUST_CONTAIN_MAX_PING"

| "ERROR_AGENCY_INFORM_MUST_CONTAIN_TIMEOUT_MULT"

| "ERROR_AGENCY_INQUIRE_CLIENT_ID_MUST_BE_STRING"

| "ERROR_AGENCY_CANNOT_REBUILD_DBS"

| "ERROR_SUPERVISION_GENERAL_FAILURE"

| "ERROR_DISPATCHER_IS_STOPPING"

| "ERROR_QUEUE_UNKNOWN"

| "ERROR_QUEUE_FULL";

// Collection

type DocumentCollectionType = 2;

type EdgeCollectionType = 3;

type CollectionType = DocumentCollectionType | EdgeCollectionType;

interface CollectionChecksum {

checksum: string;

revision: string;

}

interface CollectionFigures {

alive: {

count: number;

size: number;

};

dead: {

count: number;

size: number;

deletion: number;

};

datafiles: {

count: number;

fileSize: number;

};

journals: {

count: number;

fileSize: number;

};

compactors: {

count: number;

fileSize: number;

};

shapefiles: {

count: number;

fileSize: number;

};

shapes: {

count: number;

size: number;

};

attributes: {

count: number;

size: number;

};

indexes: {

count: number;

size: number;

};

lastTick: number;

uncollectedLogfileEntries: number;

documentReferences: number;

waitingFor: string;

compactionStatus: {

time: string;

message: string;

count: number;

filesCombined: number;

bytesRead: number;

bytesWritten: number;

};

}

interface CollectionPropertiesOptions {

waitForSync?: boolean | undefined;

journalSize?: number | undefined;

indexBuckets?: number | undefined;

replicationFactor?: number | undefined;

}

interface CreateCollectionOptions {

waitForSync?: boolean | undefined;

journalSize?: number | undefined;

isVolatile?: boolean | undefined;

isSystem?: boolean | undefined;

keyOptions?: {

type?: KeyGeneratorType | undefined;

allowUserKeys?: boolean | undefined;

increment?: number | undefined;

offset?: number | undefined;

} | undefined;

numberOfShards?: number | undefined;

shardKeys?: string[] | undefined;

replicationFactor?: number | undefined;

}

interface CollectionProperties {

waitForSync: boolean;

journalSize: number;

isSystem: boolean;

isVolatile: boolean;

keyOptions?: {

type: KeyGeneratorType;

allowUserKeys: boolean;

increment?: number | undefined;

offset?: number | undefined;

} | undefined;

indexBuckets: number;

numberOfShards?: number | undefined;

shardKeys?: string[] | undefined;

replicationFactor?: number | undefined;

}

// Indexes

interface IndexLike {

[key: string]: any;

id: string;

}

interface IndexDescription<T> {

type: IndexType;

fields: ReadonlyArray<keyof T | string>;

sparse?: boolean | undefined;

unique?: boolean | undefined;

deduplicate?: boolean | undefined;

expireAfter?: number | undefined;

name?: string | undefined;

minLength?: number | undefined;

}

interface Index<T extends object = any> {

id: string;

name: string;

type: IndexType;

fields: Array<keyof T | string>;

sparse: boolean;

unique: boolean;

deduplicate: boolean;

expireAfter?: number | undefined;

isNewlyCreated: boolean;

selectivityEstimate: number;

code: number;

}

// Document

interface ObjectWithId {

[key: string]: any;

_id: string;

}

interface ObjectWithKey {

[key: string]: any;

_key: string;

}

type DocumentLike = ObjectWithId | ObjectWithKey;

type Patch<T> = { [K in keyof T]?: T[K] | Patch<T[K]> };

interface DocumentMetadata {

_key: string;

_id: string;

_rev: string;

}

interface UpdateMetadata extends DocumentMetadata {

_oldRev: string;

}

type Document<T extends object = any> =

& { [K in keyof T]: T[K] }

& DocumentMetadata

& { _from?: string | undefined; _to?: string | undefined }

& {

[key: string]: any;

};

type DocumentData<T extends object = any> =

& { [K in keyof T]: T[K] }

& Partial<DocumentMetadata>;

type Edge<T extends object = any> = Document<T> & {

_from: string;

_to: string;

};

interface InsertResult<T extends object = any> extends DocumentMetadata {

new?: Document<T> | undefined;

}

interface UpdateResult<T extends object = any> extends UpdateMetadata {

old?: Document<T> | undefined;

new?: Document<T> | undefined;

}

interface RemoveResult<T extends object = any> extends DocumentMetadata {

old?: Document<T> | undefined;

}

interface InsertOptions {

waitForSync?: boolean | undefined;

silent?: boolean | undefined;

returnNew?: boolean | undefined;

}

interface ReplaceOptions extends InsertOptions {

overwrite?: boolean | undefined;

returnOld?: boolean | undefined;

}

interface UpdateOptions extends ReplaceOptions {

keepNull?: boolean | undefined;

mergeObjects?: boolean | undefined;

}

interface UpdateByExampleOptions {

keepNull?: boolean | undefined;

waitForSync?: boolean | undefined;

limit?: number | undefined;

mergeObjects?: boolean | undefined;

}

interface RemoveOptions {

waitForSync?: boolean | undefined;

overwrite?: boolean | undefined;

returnOld?: boolean | undefined;

silent?: boolean | undefined;

}

interface RemoveByExampleOptions {

waitForSync?: boolean | undefined;

limit?: number | undefined;

}

interface IterateOptions {

limit?: number | undefined;

probability?: number | undefined;

}

type DocumentIterator<T extends object> = (

document: Document<T>,

number: number,

) => void;

interface Collection<T extends object = any> {

// Collection

name(): string;

checksum(

withRevisions?: boolean,

withData?: boolean,

): CollectionChecksum;

count(): number;

documentId(documentKey: string): string;

drop(options?: { isSystem?: boolean | undefined }): void;

figures(): CollectionFigures;

load(): void;

path(): string;

properties(

properties?: CollectionPropertiesOptions,

): CollectionProperties;

revision(): string;

rotate(): void;

toArray(): Array<Document<T>>;

truncate(): void;

type(): CollectionType;

unload(): void;

// Indexes

dropIndex(index: string | IndexLike): boolean;

ensureIndex(description: IndexDescription<T>): Index<T>;

getIndexes(): Array<Index<T>>;

index(index: string | IndexLike): Index<T> | null;

// Document

all(): Cursor<Document<T>>;

any(): Document<T>;

byExample(example: Partial<Document<T>>): Cursor<Document<T>>;

document(selector: string | DocumentLike): Document<T>;

document(

selectors: ReadonlyArray<string | DocumentLike>,

): Array<Document<T>>;

exists(name: string): DocumentMetadata | false;

firstExample(example: Partial<Document<T>>): Document<T> | null;

getResponsibleShard(document: DocumentLike): string;

insert(data: DocumentData<T>, options?: InsertOptions): InsertResult<T>;

insert(

array: ReadonlyArray<DocumentData<T>>,

options?: InsertOptions,

): Array<InsertResult<T>>;

insert(

from: string,

to: string,

data: DocumentData<T>,

options?: InsertOptions,

): InsertResult<T>;

edges(

vertex: string | ObjectWithId | ReadonlyArray<string | ObjectWithId>,

): Array<Edge<T>>;

inEdges(

vertex: string | ObjectWithId | ReadonlyArray<string | ObjectWithId>,

): Array<Edge<T>>;

outEdges(

vertex: string | ObjectWithId | ReadonlyArray<string | ObjectWithId>,

): Array<Edge<T>>;

iterate(iterator: DocumentIterator<T>, options?: IterateOptions): void;

remove(

selector: string | DocumentLike,

options?: RemoveOptions,

): RemoveResult;

remove(

selectors: ReadonlyArray<string | DocumentLike>,

options?: RemoveOptions,

): RemoveResult[];

removeByExample(

example: Partial<Document<T>>,

waitForSync?: boolean,

limit?: number,

): number;

removeByExample(

example: Partial<Document<T>>,

options?: RemoveByExampleOptions,

): number;

rename(newName: string): void;

replace(

selector: string | DocumentLike,

data: DocumentData<T>,

options?: ReplaceOptions,

): UpdateResult<T>;

replace(

selectors: ReadonlyArray<string | DocumentLike>,

data: ReadonlyArray<DocumentData<T>>,

options?: ReplaceOptions,

): Array<UpdateResult<T>>;

replaceByExample(

example: Partial<Document<T>>,

newValue: DocumentData<T>,

waitForSync?: boolean,

limit?: number,

): number;

replaceByExample(

example: Partial<Document<T>>,

newValue: DocumentData<T>,

options?: { waitForSync?: boolean | undefined; limit?: number | undefined },

): number;

save(data: DocumentData<T>, options?: InsertOptions): InsertResult<T>;

save(

array: ReadonlyArray<DocumentData<T>>,

options?: InsertOptions,

): Array<InsertResult<T>>;

save(

from: string,

to: string,

data: DocumentData<T>,

options?: InsertOptions,

): InsertResult<T>;

update(

selector: string | DocumentLike,

data: Patch<Document<T>>,

options?: UpdateOptions,

): UpdateResult<T>;

update(

selectors: ReadonlyArray<string | DocumentLike>,

data: ReadonlyArray<Patch<Document<T>>>,

options?: UpdateOptions,

): Array<UpdateResult<T>>;

updateByExample(

example: Partial<Document<T>>,

newValue: Patch<Document<T>>,

keepNull?: boolean,

waitForSync?: boolean,

limit?: number,

): number;

updateByExample(

example: Partial<Document<T>>,

newValue: Patch<Document<T>>,

options?: UpdateByExampleOptions,

): number;

}

// Database

interface DatabaseUser {

username: string;

passwd?: string | undefined;

active?: boolean | undefined;

extra?: object | undefined;

}

// AQL

interface Query {

query: string;

bindVars?: object | undefined;

options?: QueryOptions | undefined;

}

interface AqlLiteral {

toAQL: () => string;

}

interface Cursor<T = any> {

toArray(): T[];

hasNext(): boolean;

next(): T;

count(count?: boolean): number;

getExtra(): QueryExtra;

setBatchSize(size: number): void;

getBatchSize(): number;

execute(batchSize?: number): void;

dispose(): void;

}

interface Statement<T = any> {

bind(name: string, value: any): void;

setBatchSize(size: number): void;

getBatchSize(): number;

execute(): Cursor<T>;

}

interface QueryOptions {

memoryLimit?: number | undefined;

failOnWarning?: boolean | undefined;

cache?: boolean | undefined;

count?: boolean | undefined;

fullCount?: boolean | undefined;

profile?: boolean | undefined;

maxWarningCount?: number | undefined;

maxNumberOfPlans?: number | undefined;

stream?: boolean | undefined;

// RocksDB

maxTransactionsSize?: number | undefined;

intermediateCommitSize?: number | undefined;

intermediateCommitCount?: number | undefined;

// enterprise

skipInaccessibleCollections?: boolean | undefined;

}

interface QueryExtra {

stats: {

writesExecuted: number;

writesIgnored: number;

scannedFull: number;

scannedIndex: number;

filtered: number;

httpRequests: number;

fullCount: number;

executionTime: number;

};

warnings: string[];

}

interface QueryAstNode {

type: string;

subNodes?: QueryAstNode[] | undefined;

[key: string]: any;

}

interface ParsedQuery {

parsed: boolean;

collections: string[];

parameters: string[];

bindVars: string[];

ast: QueryAstNode[];

}

// Views

interface ArangoSearchView {

_dbName: string;

_id: string;

name(): string;

type(): ViewType;

rename(newName: string): void;

properties(

newProperties?: ArangoSearchViewPropertiesOptions,

): ArangoSearchViewProperties;

}

type ArangoSearchViewConsolidationType =

| "bytes"

| "bytes_accum"

| "count"

| "fill";

interface ArangoSearchViewCollectionLink {

analyzers?: string[] | undefined;

fields?: { [key: string]: ArangoSearchViewCollectionLink | undefined } | undefined;

includeAllFields?: boolean | undefined;

trackListPositions?: boolean | undefined;

storeValues?: "none" | "id" | undefined;

}

interface ArangoSearchViewProperties {

id: string;

name: string;

type: "arangosearch";

cleanupIntervalStep: number;

consolidationIntervalMsec: number;

consolidationPolicy: {

type: ArangoSearchViewConsolidationType;

segmentThreshold: number;

threshold: number;

};

links: {

[key: string]: ArangoSearchViewCollectionLink | undefined;

};

}

interface ArangoSearchViewPropertiesOptions {

cleanupIntervalStep?: number | undefined;

consolidationIntervalMsec?: number | undefined;

consolidationPolicy?: {

type?: ArangoSearchViewConsolidationType | undefined;

segmentThreshold?: number | undefined;

threshold?: number | undefined;

} | undefined;

links?: {

[key: string]: ArangoSearchViewCollectionLink | undefined;

} | undefined;

}

// Global

interface TransactionCollections {

read?: string | string[] | undefined;

write?: string | string[] | undefined;

allowImplicit?: boolean | undefined;

}

interface Transaction<ReturnType = any> {

collections: TransactionCollections | string[];

action: (params: object) => ReturnType;

waitForSync?: boolean | undefined;

lockTimeout?: number | undefined;

params?: object | undefined;

// RocksDB

maxTransactionsSize?: number | undefined;

intermediateCommitSize?: number | undefined;

intermediateCommitCount?: number | undefined;

}

interface Database {

// Database

_createDatabase(

name: string,

options?: never,

users?: DatabaseUser[],

): true;

_databases(): string[];

_dropDatabase(name: string): true;

_useDatabase(name: string): Database;

// Indexes

_index(index: string | IndexLike): Index | null;

_dropIndex(index: string | IndexLike): boolean;

// Properties

_id(): string;

_isSystem(): boolean;

_name(): string;

_path(): string;

_version(): string;

// Collection

_collection(name: string): Collection;

_collections(): Collection[];

_create(name: string, properties?: CreateCollectionOptions): Collection;

_createDocumentCollection(

name: string,

properties?: CreateCollectionOptions,

): Collection;

_createEdgeCollection(

name: string,

properties?: CreateCollectionOptions,

): Collection;

_drop(name: string): void;

_truncate(name: string): void;

// AQL

_createStatement(query: Query | string): Statement;

_query(query: Query, options?: QueryOptions): Cursor;

_query(

query: string,

bindVars?: object,

options?: QueryOptions,

): Cursor;

_explain(query: Query | string): void;

_parse(query: string): ParsedQuery;

// Document

_document(name: string): Document;

_exists(selector: string | ObjectWithId): DocumentMetadata;

_remove(selector: string | ObjectWithId): DocumentMetadata;

_replace(

selector: string | ObjectWithId,

data: object,

): DocumentMetadata;

_update(

selector: string | ObjectWithId,

data: object,

): DocumentMetadata;

// Views

_view(name: string): ArangoSearchView | null;

_views(): ArangoSearchView[];

_createView(

name: string,

type: ViewType,

properties: ArangoSearchViewPropertiesOptions,

): ArangoSearchView;

_dropView(name: string): void;

// Global

_engine(): EngineType;

_engineStats(): { [key: string]: any };

_executeTransaction<T>(transaction: Transaction<T>): T;

}

}

declare namespace Foxx {

interface Session {

uid: string | null;