text: #ifndef ARANGODB_BASICS_VOC_ERRORS_H
  #define ARANGODB_BASICS_VOC_ERRORS_H 1
  
  /// Error codes and meanings
  /// The following errors might be raised when running ArangoDB:
  
  
  /// 0: ERROR_NO_ERROR
  /// "no error"
  /// No error has occurred.
  constexpr int TRI_ERROR_NO_ERROR                                                = 0;
  
  /// 1: ERROR_FAILED
  /// "failed"
  /// Will be raised when a general error occurred.
  constexpr int TRI_ERROR_FAILED                                                  = 1;
  
  /// 2: ERROR_SYS_ERROR
  /// "system error"
  /// Will be raised when operating system error occurred.
  constexpr int TRI_ERROR_SYS_ERROR                                               = 2;
  
  /// 3: ERROR_OUT_OF_MEMORY
  /// "out of memory"
  /// Will be raised when there is a memory shortage.
  constexpr int TRI_ERROR_OUT_OF_MEMORY                                           = 3;
  
  /// 4: ERROR_INTERNAL
  /// "internal error"
  /// Will be raised when an internal error occurred.
  constexpr int TRI_ERROR_INTERNAL                                                = 4;
  
  /// 5: ERROR_ILLEGAL_NUMBER
  /// "illegal number"
  /// Will be raised when an illegal representation of a number was given.
  constexpr int TRI_ERROR_ILLEGAL_NUMBER                                          = 5;
  
  /// 6: ERROR_NUMERIC_OVERFLOW
  /// "numeric overflow"
  /// Will be raised when a numeric overflow occurred.
  constexpr int TRI_ERROR_NUMERIC_OVERFLOW                                        = 6;
  
  /// 7: ERROR_ILLEGAL_OPTION
  /// "illegal option"
  /// Will be raised when an unknown option was supplied by the user.
  constexpr int TRI_ERROR_ILLEGAL_OPTION                                          = 7;
  
  /// 8: ERROR_DEAD_PID
  /// "dead process identifier"
  /// Will be raised when a PID without a living process was found.
  constexpr int TRI_ERROR_DEAD_PID                                                = 8;
  
  /// 9: ERROR_NOT_IMPLEMENTED
  /// "not implemented"
  /// Will be raised when hitting an unimplemented feature.
  constexpr int TRI_ERROR_NOT_IMPLEMENTED                                         = 9;
  
  /// 10: ERROR_BAD_PARAMETER
  /// "bad parameter"
  /// Will be raised when the parameter does not fulfill the requirements.
  constexpr int TRI_ERROR_BAD_PARAMETER                                           = 10;
  
  /// 11: ERROR_FORBIDDEN
  /// "forbidden"
  /// Will be raised when you are missing permission for the operation.
  constexpr int TRI_ERROR_FORBIDDEN                                               = 11;
  
  /// 12: ERROR_OUT_OF_MEMORY_MMAP
  /// "out of memory in mmap"
  /// Will be raised when there is a memory shortage.
  constexpr int TRI_ERROR_OUT_OF_MEMORY_MMAP                                      = 12;
  
  /// 13: ERROR_CORRUPTED_CSV
  /// "csv is corrupt"
  /// Will be raised when encountering a corrupt csv line.
  constexpr int TRI_ERROR_CORRUPTED_CSV                                           = 13;
  
  /// 14: ERROR_FILE_NOT_FOUND
  /// "file not found"
  /// Will be raised when a file is not found.
  constexpr int TRI_ERROR_FILE_NOT_FOUND                                          = 14;
  
  /// 15: ERROR_CANNOT_WRITE_FILE
  /// "cannot write file"
  /// Will be raised when a file cannot be written.
  constexpr int TRI_ERROR_CANNOT_WRITE_FILE                                       = 15;
  
  /// 16: ERROR_CANNOT_OVERWRITE_FILE
  /// "cannot overwrite file"
  /// Will be raised when an attempt is made to overwrite an existing file.
  constexpr int TRI_ERROR_CANNOT_OVERWRITE_FILE                                   = 16;
  
  /// 17: ERROR_TYPE_ERROR
  /// "type error"
  /// Will be raised when a type error is encountered.
  constexpr int TRI_ERROR_TYPE_ERROR                                              = 17;
  
  /// 18: ERROR_LOCK_TIMEOUT
  /// "lock timeout"
  /// Will be raised when there's a timeout waiting for a lock.
  constexpr int TRI_ERROR_LOCK_TIMEOUT                                            = 18;
  
  /// 19: ERROR_CANNOT_CREATE_DIRECTORY
  /// "cannot create directory"
  /// Will be raised when an attempt to create a directory fails.
  constexpr int TRI_ERROR_CANNOT_CREATE_DIRECTORY                                 = 19;
  
  /// 20: ERROR_CANNOT_CREATE_TEMP_FILE
  /// "cannot create temporary file"
  /// Will be raised when an attempt to create a temporary file fails.
  constexpr int TRI_ERROR_CANNOT_CREATE_TEMP_FILE                                 = 20;
  
  /// 21: ERROR_REQUEST_CANCELED
  /// "canceled request"
  /// Will be raised when a request is canceled by the user.
  constexpr int TRI_ERROR_REQUEST_CANCELED                                        = 21;
  
  /// 22: ERROR_DEBUG
  /// "intentional debug error"
  /// Will be raised intentionally during debugging.
  constexpr int TRI_ERROR_DEBUG                                                   = 22;
  
  /// 25: ERROR_IP_ADDRESS_INVALID
  /// "IP address is invalid"
  /// Will be raised when the structure of an IP address is invalid.
  constexpr int TRI_ERROR_IP_ADDRESS_INVALID                                      = 25;
  
  /// 27: ERROR_FILE_EXISTS
  /// "file exists"
  /// Will be raised when a file already exists.
  constexpr int TRI_ERROR_FILE_EXISTS                                             = 27;
  
  /// 28: ERROR_LOCKED
  /// "locked"
  /// Will be raised when a resource or an operation is locked.
  constexpr int TRI_ERROR_LOCKED                                                  = 28;
  
  /// 29: ERROR_DEADLOCK
  /// "deadlock detected"
  /// Will be raised when a deadlock is detected when accessing collections.
  constexpr int TRI_ERROR_DEADLOCK                                                = 29;
  
  /// 30: ERROR_SHUTTING_DOWN
  /// "shutdown in progress"
  /// Will be raised when a call cannot succeed because a server shutdown is
  /// already in progress.
  constexpr int TRI_ERROR_SHUTTING_DOWN                                           = 30;
  
  /// 31: ERROR_ONLY_ENTERPRISE
  /// "only enterprise version"
  /// Will be raised when an enterprise-feature is requested from the community
  /// edition.
  constexpr int TRI_ERROR_ONLY_ENTERPRISE                                         = 31;
  
  /// 32: ERROR_RESOURCE_LIMIT
  /// "resource limit exceeded"
  /// Will be raised when the resources used by an operation exceed the
  /// configured maximum value.
  constexpr int TRI_ERROR_RESOURCE_LIMIT                                          = 32;
  
  /// 33: ERROR_ARANGO_ICU_ERROR
  /// "icu error: %s"
  /// will be raised if icu operations failed
  constexpr int TRI_ERROR_ARANGO_ICU_ERROR                                        = 33;
  
  /// 34: ERROR_CANNOT_READ_FILE
  /// "cannot read file"
  /// Will be raised when a file cannot be read.
  constexpr int TRI_ERROR_CANNOT_READ_FILE                                        = 34;
  
  /// 35: ERROR_INCOMPATIBLE_VERSION
  /// "incompatible server version"
  /// Will be raised when a server is running an incompatible version of ArangoDB.
  constexpr int TRI_ERROR_INCOMPATIBLE_VERSION                                    = 35;
  
  /// 36: ERROR_DISABLED
  /// "disabled"
  /// Will be raised when a requested resource is not enabled.
  constexpr int TRI_ERROR_DISABLED                                                = 36;
  
  /// 400: ERROR_HTTP_BAD_PARAMETER
  /// "bad parameter"
  /// Will be raised when the HTTP request does not fulfill the requirements.
  constexpr int TRI_ERROR_HTTP_BAD_PARAMETER                                      = 400;
  
  /// 401: ERROR_HTTP_UNAUTHORIZED
  /// "unauthorized"
  /// Will be raised when authorization is required but the user is not
  /// authorized.
  constexpr int TRI_ERROR_HTTP_UNAUTHORIZED                                       = 401;
  
  /// 403: ERROR_HTTP_FORBIDDEN
  /// "forbidden"
  /// Will be raised when the operation is forbidden.
  constexpr int TRI_ERROR_HTTP_FORBIDDEN                                          = 403;
  
  /// 404: ERROR_HTTP_NOT_FOUND
  /// "not found"
  /// Will be raised when an URI is unknown.
  constexpr int TRI_ERROR_HTTP_NOT_FOUND                                          = 404;
  
  /// 405: ERROR_HTTP_METHOD_NOT_ALLOWED
  /// "method not supported"
  /// Will be raised when an unsupported HTTP method is used for an operation.
  constexpr int TRI_ERROR_HTTP_METHOD_NOT_ALLOWED                                 = 405;
  
  /// 406: ERROR_HTTP_NOT_ACCEPTABLE
  /// "request not acceptable"
  /// Will be raised when an unsupported HTTP content type is used for an
  /// operation, or if a request is not acceptable for a leader or follower.
  constexpr int TRI_ERROR_HTTP_NOT_ACCEPTABLE                                     = 406;
  
  /// 412: ERROR_HTTP_PRECONDITION_FAILED
  /// "precondition failed"
  /// Will be raised when a precondition for an HTTP request is not met.
  constexpr int TRI_ERROR_HTTP_PRECONDITION_FAILED                                = 412;
  
  /// 500: ERROR_HTTP_SERVER_ERROR
  /// "internal server error"
  /// Will be raised when an internal server is encountered.
  constexpr int TRI_ERROR_HTTP_SERVER_ERROR                                       = 500;
  
  /// 503: ERROR_HTTP_SERVICE_UNAVAILABLE
  /// "service unavailable"
  /// Will be raised when a service is temporarily unavailable.
  constexpr int TRI_ERROR_HTTP_SERVICE_UNAVAILABLE                                = 503;
  
  /// 504: ERROR_HTTP_GATEWAY_TIMEOUT
  /// "gateway timeout"
  /// Will be raised when a service contacted by ArangoDB does not respond in a
  /// timely manner.
  constexpr int TRI_ERROR_HTTP_GATEWAY_TIMEOUT                                    = 504;
  
  /// 600: ERROR_HTTP_CORRUPTED_JSON
  /// "invalid JSON object"
  /// Will be raised when a string representation of a JSON object is corrupt.
  constexpr int TRI_ERROR_HTTP_CORRUPTED_JSON                                     = 600;
  
  /// 601: ERROR_HTTP_SUPERFLUOUS_SUFFICES
  /// "superfluous URL suffices"
  /// Will be raised when the URL contains superfluous suffices.
  constexpr int TRI_ERROR_HTTP_SUPERFLUOUS_SUFFICES                               = 601;
  
  /// 1000: ERROR_ARANGO_ILLEGAL_STATE
  /// "illegal state"
  /// Internal error that will be raised when the datafile is not in the required
  /// state.
  constexpr int TRI_ERROR_ARANGO_ILLEGAL_STATE                                    = 1000;
  
  /// 1002: ERROR_ARANGO_DATAFILE_SEALED
  /// "datafile sealed"
  /// Internal error that will be raised when trying to write to a datafile.
  constexpr int TRI_ERROR_ARANGO_DATAFILE_SEALED                                  = 1002;
  
  /// 1004: ERROR_ARANGO_READ_ONLY
  /// "read only"
  /// Internal error that will be raised when trying to write to a read-only
  /// datafile or collection.
  constexpr int TRI_ERROR_ARANGO_READ_ONLY                                        = 1004;
  
  /// 1005: ERROR_ARANGO_DUPLICATE_IDENTIFIER
  /// "duplicate identifier"
  /// Internal error that will be raised when a identifier duplicate is detected.
  constexpr int TRI_ERROR_ARANGO_DUPLICATE_IDENTIFIER                             = 1005;
  
  /// 1006: ERROR_ARANGO_DATAFILE_UNREADABLE
  /// "datafile unreadable"
  /// Internal error that will be raised when a datafile is unreadable.
  constexpr int TRI_ERROR_ARANGO_DATAFILE_UNREADABLE                              = 1006;
  
  /// 1007: ERROR_ARANGO_DATAFILE_EMPTY
  /// "datafile empty"
  /// Internal error that will be raised when a datafile is empty.
  constexpr int TRI_ERROR_ARANGO_DATAFILE_EMPTY                                   = 1007;
  
  /// 1008: ERROR_ARANGO_RECOVERY
  /// "logfile recovery error"
  /// Will be raised when an error occurred during WAL log file recovery.
  constexpr int TRI_ERROR_ARANGO_RECOVERY                                         = 1008;
  
  /// 1009: ERROR_ARANGO_DATAFILE_STATISTICS_NOT_FOUND
  /// "datafile statistics not found"
  /// Will be raised when a required datafile statistics object was not found.
  constexpr int TRI_ERROR_ARANGO_DATAFILE_STATISTICS_NOT_FOUND                    = 1009;
  
  /// 1100: ERROR_ARANGO_CORRUPTED_DATAFILE
  /// "corrupted datafile"
  /// Will be raised when a corruption is detected in a datafile.
  constexpr int TRI_ERROR_ARANGO_CORRUPTED_DATAFILE                               = 1100;
  
  /// 1101: ERROR_ARANGO_ILLEGAL_PARAMETER_FILE
  /// "illegal or unreadable parameter file"
  /// Will be raised if a parameter file is corrupted or cannot be read.
  constexpr int TRI_ERROR_ARANGO_ILLEGAL_PARAMETER_FILE                           = 1101;
  
  /// 1102: ERROR_ARANGO_CORRUPTED_COLLECTION
  /// "corrupted collection"
  /// Will be raised when a collection contains one or more corrupted data files.
  constexpr int TRI_ERROR_ARANGO_CORRUPTED_COLLECTION                             = 1102;
  
  /// 1103: ERROR_ARANGO_MMAP_FAILED
  /// "mmap failed"
  /// Will be raised when the system call mmap failed.
  constexpr int TRI_ERROR_ARANGO_MMAP_FAILED                                      = 1103;
  
  /// 1104: ERROR_ARANGO_FILESYSTEM_FULL
  /// "filesystem full"
  /// Will be raised when the filesystem is full.
  constexpr int TRI_ERROR_ARANGO_FILESYSTEM_FULL                                  = 1104;
  
  /// 1105: ERROR_ARANGO_NO_JOURNAL
  /// "no journal"
  /// Will be raised when a journal cannot be created.
  constexpr int TRI_ERROR_ARANGO_NO_JOURNAL                                       = 1105;
  
  /// 1106: ERROR_ARANGO_DATAFILE_ALREADY_EXISTS
  /// "cannot create/rename datafile because it already exists"
  /// Will be raised when the datafile cannot be created or renamed because a
  /// file of the same name already exists.
  constexpr int TRI_ERROR_ARANGO_DATAFILE_ALREADY_EXISTS                          = 1106;
  
  /// 1107: ERROR_ARANGO_DATADIR_LOCKED
  /// "database directory is locked"
  /// Will be raised when the database directory is locked by a different process.
  constexpr int TRI_ERROR_ARANGO_DATADIR_LOCKED                                   = 1107;
  
  /// 1108: ERROR_ARANGO_COLLECTION_DIRECTORY_ALREADY_EXISTS
  /// "cannot create/rename collection because directory already exists"
  /// Will be raised when the collection cannot be created because a directory of
  /// the same name already exists.
  constexpr int TRI_ERROR_ARANGO_COLLECTION_DIRECTORY_ALREADY_EXISTS              = 1108;
  
  /// 1109: ERROR_ARANGO_MSYNC_FAILED
  /// "msync failed"
  /// Will be raised when the system call msync failed.
  constexpr int TRI_ERROR_ARANGO_MSYNC_FAILED                                     = 1109;
  
  /// 1110: ERROR_ARANGO_DATADIR_UNLOCKABLE
  /// "cannot lock database directory"
  /// Will be raised when the server cannot lock the database directory on
  /// startup.
  constexpr int TRI_ERROR_ARANGO_DATADIR_UNLOCKABLE                               = 1110;
  
  /// 1111: ERROR_ARANGO_SYNC_TIMEOUT
  /// "sync timeout"
  /// Will be raised when the server waited too long for a datafile to be synced
  /// to disk.
  constexpr int TRI_ERROR_ARANGO_SYNC_TIMEOUT                                     = 1111;
  
  /// 1200: ERROR_ARANGO_CONFLICT
  /// "conflict"
  /// Will be raised when updating or deleting a document and a conflict has been
  /// detected.
  constexpr int TRI_ERROR_ARANGO_CONFLICT                                         = 1200;
  
  /// 1201: ERROR_ARANGO_DATADIR_INVALID
  /// "invalid database directory"
  /// Will be raised when a non-existing database directory was specified when
  /// starting the database.
  constexpr int TRI_ERROR_ARANGO_DATADIR_INVALID                                  = 1201;
  
  /// 1202: ERROR_ARANGO_DOCUMENT_NOT_FOUND
  /// "document not found"
  /// Will be raised when a document with a given identifier or handle is unknown.
  constexpr int TRI_ERROR_ARANGO_DOCUMENT_NOT_FOUND                               = 1202;
  
  /// 1203: ERROR_ARANGO_DATA_SOURCE_NOT_FOUND
  /// "collection or view not found"
  /// Will be raised when a collection with the given identifier or name is
  /// unknown.
  constexpr int TRI_ERROR_ARANGO_DATA_SOURCE_NOT_FOUND                            = 1203;
  
  /// 1204: ERROR_ARANGO_COLLECTION_PARAMETER_MISSING
  /// "parameter 'collection' not found"
  /// Will be raised when the collection parameter is missing.
  constexpr int TRI_ERROR_ARANGO_COLLECTION_PARAMETER_MISSING                     = 1204;
  
  /// 1205: ERROR_ARANGO_DOCUMENT_HANDLE_BAD
  /// "illegal document handle"
  /// Will be raised when a document handle is corrupt.
  constexpr int TRI_ERROR_ARANGO_DOCUMENT_HANDLE_BAD                              = 1205;
  
  /// 1206: ERROR_ARANGO_MAXIMAL_SIZE_TOO_SMALL
  /// "maximal size of journal too small"
  /// Will be raised when the maximal size of the journal is too small.
  constexpr int TRI_ERROR_ARANGO_MAXIMAL_SIZE_TOO_SMALL                           = 1206;
  
  /// 1207: ERROR_ARANGO_DUPLICATE_NAME
  /// "duplicate name"
  /// Will be raised when a name duplicate is detected.
  constexpr int TRI_ERROR_ARANGO_DUPLICATE_NAME                                   = 1207;
  
  /// 1208: ERROR_ARANGO_ILLEGAL_NAME
  /// "illegal name"
  /// Will be raised when an illegal name is detected.
  constexpr int TRI_ERROR_ARANGO_ILLEGAL_NAME                                     = 1208;
  
  /// 1209: ERROR_ARANGO_NO_INDEX
  /// "no suitable index known"
  /// Will be raised when no suitable index for the query is known.
  constexpr int TRI_ERROR_ARANGO_NO_INDEX                                         = 1209;
  
  /// 1210: ERROR_ARANGO_UNIQUE_CONSTRAINT_VIOLATED
  /// "unique constraint violated"
  /// Will be raised when there is a unique constraint violation.
  constexpr int TRI_ERROR_ARANGO_UNIQUE_CONSTRAINT_VIOLATED                       = 1210;
  
  /// 1212: ERROR_ARANGO_INDEX_NOT_FOUND
  /// "index not found"
  /// Will be raised when an index with a given identifier is unknown.
  constexpr int TRI_ERROR_ARANGO_INDEX_NOT_FOUND                                  = 1212;
  
  /// 1213: ERROR_ARANGO_CROSS_COLLECTION_REQUEST
  /// "cross collection request not allowed"
  /// Will be raised when a cross-collection is requested.
  constexpr int TRI_ERROR_ARANGO_CROSS_COLLECTION_REQUEST                         = 1213;
  
  /// 1214: ERROR_ARANGO_INDEX_HANDLE_BAD
  /// "illegal index handle"
  /// Will be raised when a index handle is corrupt.
  constexpr int TRI_ERROR_ARANGO_INDEX_HANDLE_BAD                                 = 1214;
  
  /// 1216: ERROR_ARANGO_DOCUMENT_TOO_LARGE
  /// "document too large"
  /// Will be raised when the document cannot fit into any datafile because of it
  /// is too large.
  constexpr int TRI_ERROR_ARANGO_DOCUMENT_TOO_LARGE                               = 1216;
  
  /// 1217: ERROR_ARANGO_COLLECTION_NOT_UNLOADED
  /// "collection must be unloaded"
  /// Will be raised when a collection should be unloaded, but has a different
  /// status.
  constexpr int TRI_ERROR_ARANGO_COLLECTION_NOT_UNLOADED                          = 1217;
  
  /// 1218: ERROR_ARANGO_COLLECTION_TYPE_INVALID
  /// "collection type invalid"
  /// Will be raised when an invalid collection type is used in a request.
  constexpr int TRI_ERROR_ARANGO_COLLECTION_TYPE_INVALID                          = 1218;
  
  /// 1220: ERROR_ARANGO_ATTRIBUTE_PARSER_FAILED
  /// "parsing attribute name definition failed"
  /// Will be raised when parsing an attribute name definition failed.
  constexpr int TRI_ERROR_ARANGO_ATTRIBUTE_PARSER_FAILED                          = 1220;
  
  /// 1221: ERROR_ARANGO_DOCUMENT_KEY_BAD
  /// "illegal document key"
  /// Will be raised when a document key is corrupt.
  constexpr int TRI_ERROR_ARANGO_DOCUMENT_KEY_BAD                                 = 1221;
  
  /// 1222: ERROR_ARANGO_DOCUMENT_KEY_UNEXPECTED
  /// "unexpected document key"
  /// Will be raised when a user-defined document key is supplied for collections
  /// with auto key generation.
  constexpr int TRI_ERROR_ARANGO_DOCUMENT_KEY_UNEXPECTED                          = 1222;
  
  /// 1224: ERROR_ARANGO_DATADIR_NOT_WRITABLE
  /// "server database directory not writable"
  /// Will be raised when the server's database directory is not writable for the
  /// current user.
  constexpr int TRI_ERROR_ARANGO_DATADIR_NOT_WRITABLE                             = 1224;
  
  /// 1225: ERROR_ARANGO_OUT_OF_KEYS
  /// "out of keys"
  /// Will be raised when a key generator runs out of keys.
  constexpr int TRI_ERROR_ARANGO_OUT_OF_KEYS                                      = 1225;
  
  /// 1226: ERROR_ARANGO_DOCUMENT_KEY_MISSING
  /// "missing document key"
  /// Will be raised when a document key is missing.
  constexpr int TRI_ERROR_ARANGO_DOCUMENT_KEY_MISSING                             = 1226;
  
  /// 1227: ERROR_ARANGO_DOCUMENT_TYPE_INVALID
  /// "invalid document type"
  /// Will be raised when there is an attempt to create a document with an
  /// invalid type.
  constexpr int TRI_ERROR_ARANGO_DOCUMENT_TYPE_INVALID                            = 1227;
  
  /// 1228: ERROR_ARANGO_DATABASE_NOT_FOUND
  /// "database not found"
  /// Will be raised when a non-existing database is accessed.
  constexpr int TRI_ERROR_ARANGO_DATABASE_NOT_FOUND                               = 1228;
  
  /// 1229: ERROR_ARANGO_DATABASE_NAME_INVALID
  /// "database name invalid"
  /// Will be raised when an invalid database name is used.
  constexpr int TRI_ERROR_ARANGO_DATABASE_NAME_INVALID                            = 1229;
  
  /// 1230: ERROR_ARANGO_USE_SYSTEM_DATABASE
  /// "operation only allowed in system database"
  /// Will be raised when an operation is requested in a database other than the
  /// system database.
  constexpr int TRI_ERROR_ARANGO_USE_SYSTEM_DATABASE                              = 1230;
  
  /// 1232: ERROR_ARANGO_INVALID_KEY_GENERATOR
  /// "invalid key generator"
  /// Will be raised when an invalid key generator description is used.
  constexpr int TRI_ERROR_ARANGO_INVALID_KEY_GENERATOR                            = 1232;
  
  /// 1233: ERROR_ARANGO_INVALID_EDGE_ATTRIBUTE
  /// "edge attribute missing or invalid"
  /// will be raised when the _from or _to values of an edge are undefined or
  /// contain an invalid value.
  constexpr int TRI_ERROR_ARANGO_INVALID_EDGE_ATTRIBUTE                           = 1233;
  
  /// 1235: ERROR_ARANGO_INDEX_CREATION_FAILED
  /// "index creation failed"
  /// Will be raised when an attempt to create an index has failed.
  constexpr int TRI_ERROR_ARANGO_INDEX_CREATION_FAILED                            = 1235;
  
  /// 1236: ERROR_ARANGO_WRITE_THROTTLE_TIMEOUT
  /// "write-throttling timeout"
  /// Will be raised when the server is write-throttled and a write operation has
  /// waited too long for the server to process queued operations.
  constexpr int TRI_ERROR_ARANGO_WRITE_THROTTLE_TIMEOUT                           = 1236;
  
  /// 1237: ERROR_ARANGO_COLLECTION_TYPE_MISMATCH
  /// "collection type mismatch"
  /// Will be raised when a collection has a different type from what has been
  /// expected.
  constexpr int TRI_ERROR_ARANGO_COLLECTION_TYPE_MISMATCH                         = 1237;
  
  /// 1238: ERROR_ARANGO_COLLECTION_NOT_LOADED
  /// "collection not loaded"
  /// Will be raised when a collection is accessed that is not yet loaded.
  constexpr int TRI_ERROR_ARANGO_COLLECTION_NOT_LOADED                            = 1238;
  
  /// 1239: ERROR_ARANGO_DOCUMENT_REV_BAD
  /// "illegal document revision"
  /// Will be raised when a document revision is corrupt or is missing where
  /// needed.
  constexpr int TRI_ERROR_ARANGO_DOCUMENT_REV_BAD                                 = 1239;
  
  /// 1240: ERROR_ARANGO_INCOMPLETE_READ
  /// "incomplete read"
  /// Will be raised by the storage engine when a read cannot be completed.
  constexpr int TRI_ERROR_ARANGO_INCOMPLETE_READ                                  = 1240;
  
  /// 1300: ERROR_ARANGO_DATAFILE_FULL
  /// "datafile full"
  /// Will be raised when the datafile reaches its limit.
  constexpr int TRI_ERROR_ARANGO_DATAFILE_FULL                                    = 1300;
  
  /// 1301: ERROR_ARANGO_EMPTY_DATADIR
  /// "server database directory is empty"
  /// Will be raised when encountering an empty server database directory.
  constexpr int TRI_ERROR_ARANGO_EMPTY_DATADIR                                    = 1301;
  
  /// 1302: ERROR_ARANGO_TRY_AGAIN
  /// "operation should be tried again"
  /// Will be raised when an operation should be retried.
  constexpr int TRI_ERROR_ARANGO_TRY_AGAIN                                        = 1302;
  
  /// 1303: ERROR_ARANGO_BUSY
  /// "engine is busy"
  /// Will be raised when storage engine is busy.
  constexpr int TRI_ERROR_ARANGO_BUSY                                             = 1303;
  
  /// 1304: ERROR_ARANGO_MERGE_IN_PROGRESS
  /// "merge in progress"
  /// Will be raised when storage engine has a datafile merge in progress and
  /// cannot complete the operation.
  constexpr int TRI_ERROR_ARANGO_MERGE_IN_PROGRESS                                = 1304;
  
  /// 1305: ERROR_ARANGO_IO_ERROR
  /// "storage engine I/O error"
  /// Will be raised when storage engine encounters an I/O error.
  constexpr int TRI_ERROR_ARANGO_IO_ERROR                                         = 1305;
  
  /// 1400: ERROR_REPLICATION_NO_RESPONSE
  /// "no response"
  /// Will be raised when the replication applier does not receive any or an
  /// incomplete response from the master.
  constexpr int TRI_ERROR_REPLICATION_NO_RESPONSE                                 = 1400;
  
  /// 1401: ERROR_REPLICATION_INVALID_RESPONSE
  /// "invalid response"
  /// Will be raised when the replication applier receives an invalid response
  /// from the master.
  constexpr int TRI_ERROR_REPLICATION_INVALID_RESPONSE                            = 1401;
  
  /// 1402: ERROR_REPLICATION_MASTER_ERROR
  /// "master error"
  /// Will be raised when the replication applier receives a server error from
  /// the master.
  constexpr int TRI_ERROR_REPLICATION_MASTER_ERROR                                = 1402;
  
  /// 1403: ERROR_REPLICATION_MASTER_INCOMPATIBLE
  /// "master incompatible"
  /// Will be raised when the replication applier connects to a master that has
  /// an incompatible version.
  constexpr int TRI_ERROR_REPLICATION_MASTER_INCOMPATIBLE                         = 1403;
  
  /// 1404: ERROR_REPLICATION_MASTER_CHANGE
  /// "master change"
  /// Will be raised when the replication applier connects to a different master
  /// than before.
  constexpr int TRI_ERROR_REPLICATION_MASTER_CHANGE                               = 1404;
  
  /// 1405: ERROR_REPLICATION_LOOP
  /// "loop detected"
  /// Will be raised when the replication applier is asked to connect to itself
  /// for replication.
  constexpr int TRI_ERROR_REPLICATION_LOOP                                        = 1405;
  
  /// 1406: ERROR_REPLICATION_UNEXPECTED_MARKER
  /// "unexpected marker"
  /// Will be raised when an unexpected marker is found in the replication log
  /// stream.
  constexpr int TRI_ERROR_REPLICATION_UNEXPECTED_MARKER                           = 1406;
  
  /// 1407: ERROR_REPLICATION_INVALID_APPLIER_STATE
  /// "invalid applier state"
  /// Will be raised when an invalid replication applier state file is found.
  constexpr int TRI_ERROR_REPLICATION_INVALID_APPLIER_STATE                       = 1407;
  
  /// 1408: ERROR_REPLICATION_UNEXPECTED_TRANSACTION
  /// "invalid transaction"
  /// Will be raised when an unexpected transaction id is found.
  constexpr int TRI_ERROR_REPLICATION_UNEXPECTED_TRANSACTION                      = 1408;
  
  /// 1410: ERROR_REPLICATION_INVALID_APPLIER_CONFIGURATION
  /// "invalid replication applier configuration"
  /// Will be raised when the configuration for the replication applier is
  /// invalid.
  constexpr int TRI_ERROR_REPLICATION_INVALID_APPLIER_CONFIGURATION               = 1410;
  
  /// 1411: ERROR_REPLICATION_RUNNING
  /// "cannot perform operation while applier is running"
  /// Will be raised when there is an attempt to perform an operation while the
  /// replication applier is running.
  constexpr int TRI_ERROR_REPLICATION_RUNNING                                     = 1411;
  
  /// 1412: ERROR_REPLICATION_APPLIER_STOPPED
  /// "replication stopped"
  /// Special error code used to indicate the replication applier was stopped by
  /// a user.
  constexpr int TRI_ERROR_REPLICATION_APPLIER_STOPPED                             = 1412;
  
  /// 1413: ERROR_REPLICATION_NO_START_TICK
  /// "no start tick"
  /// Will be raised when the replication applier is started without a known
  /// start tick value.
  constexpr int TRI_ERROR_REPLICATION_NO_START_TICK                               = 1413;
  
  /// 1414: ERROR_REPLICATION_START_TICK_NOT_PRESENT
  /// "start tick not present"
  /// Will be raised when the replication applier fetches data using a start
  /// tick, but that start tick is not present on the logger server anymore.
  constexpr int TRI_ERROR_REPLICATION_START_TICK_NOT_PRESENT                      = 1414;
  
  /// 1416: ERROR_REPLICATION_WRONG_CHECKSUM
  /// "wrong checksum"
  /// Will be raised when a new born follower submits a wrong checksum
  constexpr int TRI_ERROR_REPLICATION_WRONG_CHECKSUM                              = 1416;
  
  /// 1417: ERROR_REPLICATION_SHARD_NONEMPTY
  /// "shard not empty"
  /// Will be raised when a shard is not empty and the follower tries a shortcut
  constexpr int TRI_ERROR_REPLICATION_SHARD_NONEMPTY                              = 1417;
  
  /// 1449: ERROR_CLUSTER_SERVER_UNKNOWN
  /// "got a request from an unkown server"
  /// Will be raised on some occasions when one server gets a request from
  /// another, which has not (yet?) been made known via the agency.
  constexpr int TRI_ERROR_CLUSTER_SERVER_UNKNOWN                                  = 1449;
  
  /// 1450: ERROR_CLUSTER_TOO_MANY_SHARDS
  /// "too many shards"
  /// Will be raised when the number of shards for a collection is higher than
  /// allowed.
  constexpr int TRI_ERROR_CLUSTER_TOO_MANY_SHARDS                                 = 1450;
  
  /// 1453: ERROR_CLUSTER_COLLECTION_ID_EXISTS
  /// "collection ID already exists"
  /// Will be raised when a coordinator in a cluster tries to create a collection
  /// and the collection ID already exists.
  constexpr int TRI_ERROR_CLUSTER_COLLECTION_ID_EXISTS                            = 1453;
  
  /// 1454: ERROR_CLUSTER_COULD_NOT_CREATE_COLLECTION_IN_PLAN
  /// "could not create collection in plan"
  /// Will be raised when a coordinator in a cluster cannot create an entry for a
  /// new collection in the Plan hierarchy in the agency.
  constexpr int TRI_ERROR_CLUSTER_COULD_NOT_CREATE_COLLECTION_IN_PLAN             = 1454;
  
  /// 1456: ERROR_CLUSTER_COULD_NOT_CREATE_COLLECTION
  /// "could not create collection"
  /// Will be raised when a coordinator in a cluster notices that some DBServers
  /// report problems when creating shards for a new collection.
  constexpr int TRI_ERROR_CLUSTER_COULD_NOT_CREATE_COLLECTION                     = 1456;
  
  /// 1457: ERROR_CLUSTER_TIMEOUT
  /// "timeout in cluster operation"
  /// Will be raised when a coordinator in a cluster runs into a timeout for some
  /// cluster wide operation.
  constexpr int TRI_ERROR_CLUSTER_TIMEOUT                                         = 1457;
  
  /// 1458: ERROR_CLUSTER_COULD_NOT_REMOVE_COLLECTION_IN_PLAN
  /// "could not remove collection from plan"
  /// Will be raised when a coordinator in a cluster cannot remove an entry for a
  /// collection in the Plan hierarchy in the agency.
  constexpr int TRI_ERROR_CLUSTER_COULD_NOT_REMOVE_COLLECTION_IN_PLAN             = 1458;
  
  /// 1459: ERROR_CLUSTER_COULD_NOT_REMOVE_COLLECTION_IN_CURRENT
  /// "could not remove collection from current"
  /// Will be raised when a coordinator in a cluster cannot remove an entry for a
  /// collection in the Current hierarchy in the agency.
  constexpr int TRI_ERROR_CLUSTER_COULD_NOT_REMOVE_COLLECTION_IN_CURRENT          = 1459;
  
  /// 1460: ERROR_CLUSTER_COULD_NOT_CREATE_DATABASE_IN_PLAN
  /// "could not create database in plan"
  /// Will be raised when a coordinator in a cluster cannot create an entry for a
  /// new database in the Plan hierarchy in the agency.
  constexpr int TRI_ERROR_CLUSTER_COULD_NOT_CREATE_DATABASE_IN_PLAN               = 1460;
  
  /// 1461: ERROR_CLUSTER_COULD_NOT_CREATE_DATABASE
  /// "could not create database"
  /// Will be raised when a coordinator in a cluster notices that some DBServers
  /// report problems when creating databases for a new cluster wide database.
  constexpr int TRI_ERROR_CLUSTER_COULD_NOT_CREATE_DATABASE                       = 1461;
  
  /// 1462: ERROR_CLUSTER_COULD_NOT_REMOVE_DATABASE_IN_PLAN
  /// "could not remove database from plan"
  /// Will be raised when a coordinator in a cluster cannot remove an entry for a
  /// database in the Plan hierarchy in the agency.
  constexpr int TRI_ERROR_CLUSTER_COULD_NOT_REMOVE_DATABASE_IN_PLAN               = 1462;
  
  /// 1463: ERROR_CLUSTER_COULD_NOT_REMOVE_DATABASE_IN_CURRENT
  /// "could not remove database from current"
  /// Will be raised when a coordinator in a cluster cannot remove an entry for a
  /// database in the Current hierarchy in the agency.
  constexpr int TRI_ERROR_CLUSTER_COULD_NOT_REMOVE_DATABASE_IN_CURRENT            = 1463;
  
  /// 1464: ERROR_CLUSTER_SHARD_GONE
  /// "no responsible shard found"
  /// Will be raised when a coordinator in a cluster cannot determine the shard
  /// that is responsible for a given document.
  constexpr int TRI_ERROR_CLUSTER_SHARD_GONE                                      = 1464;
  
  /// 1465: ERROR_CLUSTER_CONNECTION_LOST
  /// "cluster internal HTTP connection broken"
  /// Will be raised when a coordinator in a cluster loses an HTTP connection to
  /// a DBserver in the cluster whilst transferring data.
  constexpr int TRI_ERROR_CLUSTER_CONNECTION_LOST                                 = 1465;
  
  /// 1466: ERROR_CLUSTER_MUST_NOT_SPECIFY_KEY
  /// "must not specify _key for this collection"
  /// Will be raised when a coordinator in a cluster finds that the _key
  /// attribute was specified in a sharded collection the uses not only _key as
  /// sharding attribute.
  constexpr int TRI_ERROR_CLUSTER_MUST_NOT_SPECIFY_KEY                            = 1466;
  
  /// 1467: ERROR_CLUSTER_GOT_CONTRADICTING_ANSWERS
  /// "got contradicting answers from different shards"
  /// Will be raised if a coordinator in a cluster gets conflicting results from
  /// different shards, which should never happen.
  constexpr int TRI_ERROR_CLUSTER_GOT_CONTRADICTING_ANSWERS                       = 1467;
  
  /// 1468: ERROR_CLUSTER_NOT_ALL_SHARDING_ATTRIBUTES_GIVEN
  /// "not all sharding attributes given"
  /// Will be raised if a coordinator tries to find out which shard is
  /// responsible for a partial document, but cannot do this because not all
  /// sharding attributes are specified.
  constexpr int TRI_ERROR_CLUSTER_NOT_ALL_SHARDING_ATTRIBUTES_GIVEN               = 1468;
  
  /// 1469: ERROR_CLUSTER_MUST_NOT_CHANGE_SHARDING_ATTRIBUTES
  /// "must not change the value of a shard key attribute"
  /// Will be raised if there is an attempt to update the value of a shard
  /// attribute.
  constexpr int TRI_ERROR_CLUSTER_MUST_NOT_CHANGE_SHARDING_ATTRIBUTES             = 1469;
  
  /// 1470: ERROR_CLUSTER_UNSUPPORTED
  /// "unsupported operation or parameter"
  /// Will be raised when there is an attempt to carry out an operation that is
  /// not supported in the context of a sharded collection.
  constexpr int TRI_ERROR_CLUSTER_UNSUPPORTED                                     = 1470;
  
  /// 1471: ERROR_CLUSTER_ONLY_ON_COORDINATOR
  /// "this operation is only valid on a coordinator in a cluster"
  /// Will be raised if there is an attempt to run a coordinator-only operation
  /// on a different type of node.
  constexpr int TRI_ERROR_CLUSTER_ONLY_ON_COORDINATOR                             = 1471;
  
  /// 1472: ERROR_CLUSTER_READING_PLAN_AGENCY
  /// "error reading Plan in agency"
  /// Will be raised if a coordinator or DBserver cannot read the Plan in the
  /// agency.
  constexpr int TRI_ERROR_CLUSTER_READING_PLAN_AGENCY                             = 1472;
  
  /// 1473: ERROR_CLUSTER_COULD_NOT_TRUNCATE_COLLECTION
  /// "could not truncate collection"
  /// Will be raised if a coordinator cannot truncate all shards of a cluster
  /// collection.
  constexpr int TRI_ERROR_CLUSTER_COULD_NOT_TRUNCATE_COLLECTION                   = 1473;
  
  /// 1474: ERROR_CLUSTER_AQL_COMMUNICATION
  /// "error in cluster internal communication for AQL"
  /// Will be raised if the internal communication of the cluster for AQL
  /// produces an error.
  constexpr int TRI_ERROR_CLUSTER_AQL_COMMUNICATION                               = 1474;
  
  /// 1477: ERROR_CLUSTER_ONLY_ON_DBSERVER
  /// "this operation is only valid on a DBserver in a cluster"
  /// Will be raised if there is an attempt to run a DBserver-only operation on a
  /// different type of node.
  constexpr int TRI_ERROR_CLUSTER_ONLY_ON_DBSERVER                                = 1477;
  
  /// 1478: ERROR_CLUSTER_BACKEND_UNAVAILABLE
  /// "A cluster backend which was required for the operation could not be reached"
  /// Will be raised if a required db server can't be reached.
  constexpr int TRI_ERROR_CLUSTER_BACKEND_UNAVAILABLE                             = 1478;
  
  /// 1481: ERROR_CLUSTER_AQL_COLLECTION_OUT_OF_SYNC
  /// "collection is out of sync"
  /// Will be raised if a collection needed during query execution is out of
  /// sync. This currently can only happen when using satellite collections
  constexpr int TRI_ERROR_CLUSTER_AQL_COLLECTION_OUT_OF_SYNC                      = 1481;
  
  /// 1482: ERROR_CLUSTER_COULD_NOT_CREATE_INDEX_IN_PLAN
  /// "could not create index in plan"
  /// Will be raised when a coordinator in a cluster cannot create an entry for a
  /// new index in the Plan hierarchy in the agency.
  constexpr int TRI_ERROR_CLUSTER_COULD_NOT_CREATE_INDEX_IN_PLAN                  = 1482;
  
  /// 1483: ERROR_CLUSTER_COULD_NOT_DROP_INDEX_IN_PLAN
  /// "could not drop index in plan"
  /// Will be raised when a coordinator in a cluster cannot remove an index from
  /// the Plan hierarchy in the agency.
  constexpr int TRI_ERROR_CLUSTER_COULD_NOT_DROP_INDEX_IN_PLAN                    = 1483;
  
  /// 1484: ERROR_CLUSTER_CHAIN_OF_DISTRIBUTESHARDSLIKE
  /// "chain of distributeShardsLike references"
  /// Will be raised if one tries to create a collection with a
  /// distributeShardsLike attribute which points to another collection that also
  /// has one.
  constexpr int TRI_ERROR_CLUSTER_CHAIN_OF_DISTRIBUTESHARDSLIKE                   = 1484;
  
  /// 1485: ERROR_CLUSTER_MUST_NOT_DROP_COLL_OTHER_DISTRIBUTESHARDSLIKE
  /// "must not drop collection while another has a distributeShardsLike
  /// "attribute pointing to it"
  /// Will be raised if one tries to drop a collection to which another
  /// collection points with its distributeShardsLike attribute.
  constexpr int TRI_ERROR_CLUSTER_MUST_NOT_DROP_COLL_OTHER_DISTRIBUTESHARDSLIKE   = 1485;
  
  /// 1486: ERROR_CLUSTER_UNKNOWN_DISTRIBUTESHARDSLIKE
  /// "must not have a distributeShardsLike attribute pointing to an unknown
  /// "collection"
  /// Will be raised if one tries to create a collection which points to an
  /// unknown collection in its distributeShardsLike attribute.
  constexpr int TRI_ERROR_CLUSTER_UNKNOWN_DISTRIBUTESHARDSLIKE                    = 1486;
  
  /// 1487: ERROR_CLUSTER_INSUFFICIENT_DBSERVERS
  /// "the number of current dbservers is lower than the requested
  /// "replicationFactor"
  /// Will be raised if one tries to create a collection with a replicationFactor
  /// greater than the available number of DBServers.
  constexpr int TRI_ERROR_CLUSTER_INSUFFICIENT_DBSERVERS                          = 1487;
  
  /// 1488: ERROR_CLUSTER_COULD_NOT_DROP_FOLLOWER
  /// "a follower could not be dropped in agency"
  /// Will be raised if a follower that ought to be dropped could not be dropped
  /// in the agency (under Current).
  constexpr int TRI_ERROR_CLUSTER_COULD_NOT_DROP_FOLLOWER                         = 1488;
  
  /// 1489: ERROR_CLUSTER_SHARD_LEADER_REFUSES_REPLICATION
  /// "a shard leader refuses to perform a replication operation"
  /// Will be raised if a replication operation is refused by a shard leader.
  constexpr int TRI_ERROR_CLUSTER_SHARD_LEADER_REFUSES_REPLICATION                = 1489;
  
  /// 1490: ERROR_CLUSTER_SHARD_FOLLOWER_REFUSES_OPERATION
  /// "a shard follower refuses to perform an operation that is not a replication"
  /// Will be raised if a non-replication operation is refused by a shard
  /// follower.
  constexpr int TRI_ERROR_CLUSTER_SHARD_FOLLOWER_REFUSES_OPERATION                = 1490;
  
  /// 1491: ERROR_CLUSTER_SHARD_LEADER_RESIGNED
  /// "a (former) shard leader refuses to perform an operation, because it has
  /// "resigned in the meantime"
  /// Will be raised if a non-replication operation is refused by a former shard
  /// leader that has found out that it is no longer the leader.
  constexpr int TRI_ERROR_CLUSTER_SHARD_LEADER_RESIGNED                           = 1491;
  
  /// 1492: ERROR_CLUSTER_AGENCY_COMMUNICATION_FAILED
  /// "some agency operation failed"
  /// Will be raised if after various retries an agency operation could not be
  /// performed successfully.
  constexpr int TRI_ERROR_CLUSTER_AGENCY_COMMUNICATION_FAILED                     = 1492;
  
  /// 1495: ERROR_CLUSTER_LEADERSHIP_CHALLENGE_ONGOING
  /// "leadership challenge is ongoing"
  /// Will be raised when servers are currently competing for leadership, and the
  /// result is still unknown.
  constexpr int TRI_ERROR_CLUSTER_LEADERSHIP_CHALLENGE_ONGOING                    = 1495;
  
  /// 1496: ERROR_CLUSTER_NOT_LEADER
  /// "not a leader"
  /// Will be raised when an operation is sent to a non-leading server.
  constexpr int TRI_ERROR_CLUSTER_NOT_LEADER                                      = 1496;
  
  /// 1497: ERROR_CLUSTER_COULD_NOT_CREATE_VIEW_IN_PLAN
  /// "could not create view in plan"
  /// Will be raised when a coordinator in a cluster cannot create an entry for a
  /// new view in the Plan hierarchy in the agency.
  constexpr int TRI_ERROR_CLUSTER_COULD_NOT_CREATE_VIEW_IN_PLAN                   = 1497;
  
  /// 1498: ERROR_CLUSTER_VIEW_ID_EXISTS
  /// "view ID already exists"
  /// Will be raised when a coordinator in a cluster tries to create a view and
  /// the view ID already exists.
  constexpr int TRI_ERROR_CLUSTER_VIEW_ID_EXISTS                                  = 1498;
  
  /// 1499: ERROR_CLUSTER_COULD_NOT_DROP_COLLECTION
  /// "could not drop collection in plan"
  /// Will be raised when a coordinator in a cluster cannot drop a collection
  /// entry in the Plan hierarchy in the agency.
  constexpr int TRI_ERROR_CLUSTER_COULD_NOT_DROP_COLLECTION                       = 1499;
  
  /// 1500: ERROR_QUERY_KILLED
  /// "query killed"
  /// Will be raised when a running query is killed by an explicit admin command.
  constexpr int TRI_ERROR_QUERY_KILLED                                            = 1500;
  
  /// 1501: ERROR_QUERY_PARSE
  /// "%s"
  /// Will be raised when query is parsed and is found to be syntactically
  /// invalid.
  constexpr int TRI_ERROR_QUERY_PARSE                                             = 1501;
  
  /// 1502: ERROR_QUERY_EMPTY
  /// "query is empty"
  /// Will be raised when an empty query is specified.
  constexpr int TRI_ERROR_QUERY_EMPTY                                             = 1502;
  
  /// 1503: ERROR_QUERY_SCRIPT
  /// "runtime error '%s'"
  /// Will be raised when a runtime error is caused by the query.
  constexpr int TRI_ERROR_QUERY_SCRIPT                                            = 1503;
  
  /// 1504: ERROR_QUERY_NUMBER_OUT_OF_RANGE
  /// "number out of range"
  /// Will be raised when a number is outside the expected range.
  constexpr int TRI_ERROR_QUERY_NUMBER_OUT_OF_RANGE                               = 1504;
  
  /// 1505: ERROR_QUERY_INVALID_GEO_VALUE
  /// "invalid geo coordinate value"
  /// Will be raised when a geo index coordinate is invalid or out of range.
  constexpr int TRI_ERROR_QUERY_INVALID_GEO_VALUE                                 = 1505;
  
  /// 1510: ERROR_QUERY_VARIABLE_NAME_INVALID
  /// "variable name '%s' has an invalid format"
  /// Will be raised when an invalid variable name is used.
  constexpr int TRI_ERROR_QUERY_VARIABLE_NAME_INVALID                             = 1510;
  
  /// 1511: ERROR_QUERY_VARIABLE_REDECLARED
  /// "variable '%s' is assigned multiple times"
  /// Will be raised when a variable gets re-assigned in a query.
  constexpr int TRI_ERROR_QUERY_VARIABLE_REDECLARED                               = 1511;
  
  /// 1512: ERROR_QUERY_VARIABLE_NAME_UNKNOWN
  /// "unknown variable '%s'"
  /// Will be raised when an unknown variable is used or the variable is
  /// undefined the context it is used.
  constexpr int TRI_ERROR_QUERY_VARIABLE_NAME_UNKNOWN                             = 1512;
  
  /// 1521: ERROR_QUERY_COLLECTION_LOCK_FAILED
  /// "unable to read-lock collection %s"
  /// Will be raised when a read lock on the collection cannot be acquired.
  constexpr int TRI_ERROR_QUERY_COLLECTION_LOCK_FAILED                            = 1521;
  
  /// 1522: ERROR_QUERY_TOO_MANY_COLLECTIONS
  /// "too many collections/shards"
  /// Will be raised when the number of collections or shards in a query is
  /// beyond the allowed value.
  constexpr int TRI_ERROR_QUERY_TOO_MANY_COLLECTIONS                              = 1522;
  
  /// 1530: ERROR_QUERY_DOCUMENT_ATTRIBUTE_REDECLARED
  /// "document attribute '%s' is assigned multiple times"
  /// Will be raised when a document attribute is re-assigned.
  constexpr int TRI_ERROR_QUERY_DOCUMENT_ATTRIBUTE_REDECLARED                     = 1530;
  
  /// 1540: ERROR_QUERY_FUNCTION_NAME_UNKNOWN
  /// "usage of unknown function '%s()'"
  /// Will be raised when an undefined function is called.
  constexpr int TRI_ERROR_QUERY_FUNCTION_NAME_UNKNOWN                             = 1540;
  
  /// 1541: ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH
  /// "invalid number of arguments for function '%s()', expected number of
  /// "arguments: minimum: %d, maximum: %d"
  /// Will be raised when the number of arguments used in a function call does
  /// not match the expected number of arguments for the function.
  constexpr int TRI_ERROR_QUERY_FUNCTION_ARGUMENT_NUMBER_MISMATCH                 = 1541;
  
  /// 1542: ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH
  /// "invalid argument type in call to function '%s()'"
  /// Will be raised when the type of an argument used in a function call does
  /// not match the expected argument type.
  constexpr int TRI_ERROR_QUERY_FUNCTION_ARGUMENT_TYPE_MISMATCH                   = 1542;
  
  /// 1543: ERROR_QUERY_INVALID_REGEX
  /// "invalid regex value"
  /// Will be raised when an invalid regex argument value is used in a call to a
  /// function that expects a regex.
  constexpr int TRI_ERROR_QUERY_INVALID_REGEX                                     = 1543;
  
  /// 1550: ERROR_QUERY_BIND_PARAMETERS_INVALID
  /// "invalid structure of bind parameters"
  /// Will be raised when the structure of bind parameters passed has an
  /// unexpected format.
  constexpr int TRI_ERROR_QUERY_BIND_PARAMETERS_INVALID                           = 1550;
  
  /// 1551: ERROR_QUERY_BIND_PARAMETER_MISSING
  /// "no value specified for declared bind parameter '%s'"
  /// Will be raised when a bind parameter was declared in the query but the
  /// query is being executed with no value for that parameter.
  constexpr int TRI_ERROR_QUERY_BIND_PARAMETER_MISSING                            = 1551;
  
  /// 1552: ERROR_QUERY_BIND_PARAMETER_UNDECLARED
  /// "bind parameter '%s' was not declared in the query"
  /// Will be raised when a value gets specified for an undeclared bind parameter.
  constexpr int TRI_ERROR_QUERY_BIND_PARAMETER_UNDECLARED                         = 1552;
  
  /// 1553: ERROR_QUERY_BIND_PARAMETER_TYPE
  /// "bind parameter '%s' has an invalid value or type"
  /// Will be raised when a bind parameter has an invalid value or type.
  constexpr int TRI_ERROR_QUERY_BIND_PARAMETER_TYPE                               = 1553;
  
  /// 1560: ERROR_QUERY_INVALID_LOGICAL_VALUE
  /// "invalid logical value"
  /// Will be raised when a non-boolean value is used in a logical operation.
  constexpr int TRI_ERROR_QUERY_INVALID_LOGICAL_VALUE                             = 1560;
  
  /// 1561: ERROR_QUERY_INVALID_ARITHMETIC_VALUE
  /// "invalid arithmetic value"
  /// Will be raised when a non-numeric value is used in an arithmetic operation.
  constexpr int TRI_ERROR_QUERY_INVALID_ARITHMETIC_VALUE                          = 1561;
  
  /// 1562: ERROR_QUERY_DIVISION_BY_ZERO
  /// "division by zero"
  /// Will be raised when there is an attempt to divide by zero.
  constexpr int TRI_ERROR_QUERY_DIVISION_BY_ZERO                                  = 1562;
  
  /// 1563: ERROR_QUERY_ARRAY_EXPECTED
  /// "array expected"
  /// Will be raised when a non-array operand is used for an operation that
  /// expects an array argument operand.
  constexpr int TRI_ERROR_QUERY_ARRAY_EXPECTED                                    = 1563;
  
  /// 1569: ERROR_QUERY_FAIL_CALLED
  /// "FAIL(%s) called"
  /// Will be raised when the function FAIL() is called from inside a query.
  constexpr int TRI_ERROR_QUERY_FAIL_CALLED                                       = 1569;
  
  /// 1570: ERROR_QUERY_GEO_INDEX_MISSING
  /// "no suitable geo index found for geo restriction on '%s'"
  /// Will be raised when a geo restriction was specified but no suitable geo
  /// index is found to resolve it.
  constexpr int TRI_ERROR_QUERY_GEO_INDEX_MISSING                                 = 1570;
  
  /// 1571: ERROR_QUERY_FULLTEXT_INDEX_MISSING
  /// "no suitable fulltext index found for fulltext query on '%s'"
  /// Will be raised when a fulltext query is performed on a collection without a
  /// suitable fulltext index.
  constexpr int TRI_ERROR_QUERY_FULLTEXT_INDEX_MISSING                            = 1571;
  
  /// 1572: ERROR_QUERY_INVALID_DATE_VALUE
  /// "invalid date value"
  /// Will be raised when a value cannot be converted to a date.
  constexpr int TRI_ERROR_QUERY_INVALID_DATE_VALUE                                = 1572;
  
  /// 1573: ERROR_QUERY_MULTI_MODIFY
  /// "multi-modify query"
  /// Will be raised when an AQL query contains more than one data-modifying
  /// operation.
  constexpr int TRI_ERROR_QUERY_MULTI_MODIFY                                      = 1573;
  
  /// 1574: ERROR_QUERY_INVALID_AGGREGATE_EXPRESSION
  /// "invalid aggregate expression"
  /// Will be raised when an AQL query contains an invalid aggregate expression.
  constexpr int TRI_ERROR_QUERY_INVALID_AGGREGATE_EXPRESSION                      = 1574;
  
  /// 1575: ERROR_QUERY_COMPILE_TIME_OPTIONS
  /// "query options must be readable at query compile time"
  /// Will be raised when an AQL data-modification query contains options that
  /// cannot be figured out at query compile time.
  constexpr int TRI_ERROR_QUERY_COMPILE_TIME_OPTIONS                              = 1575;
  
  /// 1576: ERROR_QUERY_EXCEPTION_OPTIONS
  /// "query options expected"
  /// Will be raised when an AQL data-modification query contains an invalid
  /// options specification.
  constexpr int TRI_ERROR_QUERY_EXCEPTION_OPTIONS                                 = 1576;
  
  /// 1577: ERROR_QUERY_FORCED_INDEX_HINT_UNUSABLE
  /// "could not use forced index hint"
  /// Will be raised when forceIndexHint is specified, and the hint cannot be
  /// used to serve the query.
  constexpr int TRI_ERROR_QUERY_FORCED_INDEX_HINT_UNUSABLE                        = 1577;
  
  /// 1578: ERROR_QUERY_DISALLOWED_DYNAMIC_CALL
  /// "disallowed dynamic call to '%s'"
  /// Will be raised when a dynamic function call is made to a function that
  /// cannot be called dynamically.
  constexpr int TRI_ERROR_QUERY_DISALLOWED_DYNAMIC_CALL                           = 1578;
  
  /// 1579: ERROR_QUERY_ACCESS_AFTER_MODIFICATION
  /// "access after data-modification by %s"
  /// Will be raised when collection data are accessed after a data-modification
  /// operation.
  constexpr int TRI_ERROR_QUERY_ACCESS_AFTER_MODIFICATION                         = 1579;
  
  /// 1580: ERROR_QUERY_FUNCTION_INVALID_NAME
  /// "invalid user function name"
  /// Will be raised when a user function with an invalid name is registered.
  constexpr int TRI_ERROR_QUERY_FUNCTION_INVALID_NAME                             = 1580;
  
  /// 1581: ERROR_QUERY_FUNCTION_INVALID_CODE
  /// "invalid user function code"
  /// Will be raised when a user function is registered with invalid code.
  constexpr int TRI_ERROR_QUERY_FUNCTION_INVALID_CODE                             = 1581;
  
  /// 1582: ERROR_QUERY_FUNCTION_NOT_FOUND
  /// "user function '%s()' not found"
  /// Will be raised when a user function is accessed but not found.
  constexpr int TRI_ERROR_QUERY_FUNCTION_NOT_FOUND                                = 1582;
  
  /// 1583: ERROR_QUERY_FUNCTION_RUNTIME_ERROR
  /// "user function runtime error: %s"
  /// Will be raised when a user function throws a runtime exception.
  constexpr int TRI_ERROR_QUERY_FUNCTION_RUNTIME_ERROR                            = 1583;
  
  /// 1590: ERROR_QUERY_BAD_JSON_PLAN
  /// "bad execution plan JSON"
  /// Will be raised when an HTTP API for a query got an invalid JSON object.
  constexpr int TRI_ERROR_QUERY_BAD_JSON_PLAN                                     = 1590;
  
  /// 1591: ERROR_QUERY_NOT_FOUND
  /// "query ID not found"
  /// Will be raised when an Id of a query is not found by the HTTP API.
  constexpr int TRI_ERROR_QUERY_NOT_FOUND                                         = 1591;
  
  /// 1593: ERROR_QUERY_USER_ASSERT
  /// "%s"
  /// Will be raised if and user provided expression fails to evalutate to true
  constexpr int TRI_ERROR_QUERY_USER_ASSERT                                       = 1593;
  
  /// 1594: ERROR_QUERY_USER_WARN
  /// "%s"
  /// Will be raised if and user provided expression fails to evalutate to true
  constexpr int TRI_ERROR_QUERY_USER_WARN                                         = 1594;
  
  /// 1600: ERROR_CURSOR_NOT_FOUND
  /// "cursor not found"
  /// Will be raised when a cursor is requested via its id but a cursor with that
  /// id cannot be found.
  constexpr int TRI_ERROR_CURSOR_NOT_FOUND                                        = 1600;
  
  /// 1601: ERROR_CURSOR_BUSY
  /// "cursor is busy"
  /// Will be raised when a cursor is requested via its id but a concurrent
  /// request is still using the cursor.
  constexpr int TRI_ERROR_CURSOR_BUSY                                             = 1601;
  
  /// 1650: ERROR_TRANSACTION_INTERNAL
  /// "internal transaction error"
  /// Will be raised when a wrong usage of transactions is detected. this is an
  /// internal error and indicates a bug in ArangoDB.
  constexpr int TRI_ERROR_TRANSACTION_INTERNAL                                    = 1650;
  
  /// 1651: ERROR_TRANSACTION_NESTED
  /// "nested transactions detected"
  /// Will be raised when transactions are nested.
  constexpr int TRI_ERROR_TRANSACTION_NESTED                                      = 1651;
  
  /// 1652: ERROR_TRANSACTION_UNREGISTERED_COLLECTION
  /// "unregistered collection used in transaction"
  /// Will be raised when a collection is used in the middle of a transaction but
  /// was not registered at transaction start.
  constexpr int TRI_ERROR_TRANSACTION_UNREGISTERED_COLLECTION                     = 1652;
  
  /// 1653: ERROR_TRANSACTION_DISALLOWED_OPERATION
  /// "disallowed operation inside transaction"
  /// Will be raised when a disallowed operation is carried out in a transaction.
  constexpr int TRI_ERROR_TRANSACTION_DISALLOWED_OPERATION                        = 1653;
  
  /// 1654: ERROR_TRANSACTION_ABORTED
  /// "transaction aborted"
  /// Will be raised when a transaction was aborted.
  constexpr int TRI_ERROR_TRANSACTION_ABORTED                                     = 1654;
  
  /// 1655: ERROR_TRANSACTION_NOT_FOUND
  /// "transaction not found"
  /// Will be raised when a transaction was not found.
  constexpr int TRI_ERROR_TRANSACTION_NOT_FOUND                                   = 1655;
  
  /// 1700: ERROR_USER_INVALID_NAME
  /// "invalid user name"
  /// Will be raised when an invalid user name is used.
  constexpr int TRI_ERROR_USER_INVALID_NAME                                       = 1700;
  
  /// 1702: ERROR_USER_DUPLICATE
  /// "duplicate user"
  /// Will be raised when a user name already exists.
  constexpr int TRI_ERROR_USER_DUPLICATE                                          = 1702;
  
  /// 1703: ERROR_USER_NOT_FOUND
  /// "user not found"
  /// Will be raised when a user name is updated that does not exist.
  constexpr int TRI_ERROR_USER_NOT_FOUND                                          = 1703;
  
  /// 1705: ERROR_USER_EXTERNAL
  /// "user is external"
  /// Will be raised when the user is authenicated by an external server.
  constexpr int TRI_ERROR_USER_EXTERNAL                                           = 1705;
  
  /// 1752: ERROR_SERVICE_DOWNLOAD_FAILED
  /// "service download failed"
  /// Will be raised when a service download from the central repository failed.
  constexpr int TRI_ERROR_SERVICE_DOWNLOAD_FAILED                                 = 1752;
  
  /// 1753: ERROR_SERVICE_UPLOAD_FAILED
  /// "service upload failed"
  /// Will be raised when a service upload from the client to the ArangoDB server
  /// failed.
  constexpr int TRI_ERROR_SERVICE_UPLOAD_FAILED                                   = 1753;
  
  /// 1800: ERROR_LDAP_CANNOT_INIT
  /// "cannot init a LDAP connection"
  /// can not init a LDAP connection
  constexpr int TRI_ERROR_LDAP_CANNOT_INIT                                        = 1800;
  
  /// 1801: ERROR_LDAP_CANNOT_SET_OPTION
  /// "cannot set a LDAP option"
  /// can not set a LDAP option
  constexpr int TRI_ERROR_LDAP_CANNOT_SET_OPTION                                  = 1801;
  
  /// 1802: ERROR_LDAP_CANNOT_BIND
  /// "cannot bind to a LDAP server"
  /// can not bind to a LDAP server
  constexpr int TRI_ERROR_LDAP_CANNOT_BIND                                        = 1802;
  
  /// 1803: ERROR_LDAP_CANNOT_UNBIND
  /// "cannot unbind from a LDAP server"
  /// can not unbind from a LDAP server
  constexpr int TRI_ERROR_LDAP_CANNOT_UNBIND                                      = 1803;
  
  /// 1804: ERROR_LDAP_CANNOT_SEARCH
  /// "cannot issue a LDAP search"
  /// can not search the LDAP server
  constexpr int TRI_ERROR_LDAP_CANNOT_SEARCH                                      = 1804;
  
  /// 1805: ERROR_LDAP_CANNOT_START_TLS
  /// "cannot start a TLS LDAP session"
  /// can not star a TLS LDAP session
  constexpr int TRI_ERROR_LDAP_CANNOT_START_TLS                                   = 1805;
  
  /// 1806: ERROR_LDAP_FOUND_NO_OBJECTS
  /// "LDAP didn't found any objects"
  /// LDAP didn't found any objects with the specified search query
  constexpr int TRI_ERROR_LDAP_FOUND_NO_OBJECTS                                   = 1806;
  
  /// 1807: ERROR_LDAP_NOT_ONE_USER_FOUND
  /// "LDAP found zero ore more than one user"
  /// LDAP found zero ore more than one user
  constexpr int TRI_ERROR_LDAP_NOT_ONE_USER_FOUND                                 = 1807;
  
  /// 1808: ERROR_LDAP_USER_NOT_IDENTIFIED
  /// "LDAP found a user, but its not the desired one"
  /// LDAP found a user, but its not the desired one
  constexpr int TRI_ERROR_LDAP_USER_NOT_IDENTIFIED                                = 1808;
  
  /// 1820: ERROR_LDAP_INVALID_MODE
  /// "invalid ldap mode"
  /// cant distinguish a valid mode for provided ldap configuration
  constexpr int TRI_ERROR_LDAP_INVALID_MODE                                       = 1820;
  
  /// 1850: ERROR_TASK_INVALID_ID
  /// "invalid task id"
  /// Will be raised when a task is created with an invalid id.
  constexpr int TRI_ERROR_TASK_INVALID_ID                                         = 1850;
  
  /// 1851: ERROR_TASK_DUPLICATE_ID
  /// "duplicate task id"
  /// Will be raised when a task id is created with a duplicate id.
  constexpr int TRI_ERROR_TASK_DUPLICATE_ID                                       = 1851;
  
  /// 1852: ERROR_TASK_NOT_FOUND
  /// "task not found"
  /// Will be raised when a task with the specified id could not be found.
  constexpr int TRI_ERROR_TASK_NOT_FOUND                                          = 1852;
  
  /// 1901: ERROR_GRAPH_INVALID_GRAPH
  /// "invalid graph"
  /// Will be raised when an invalid name is passed to the server.
  constexpr int TRI_ERROR_GRAPH_INVALID_GRAPH                                     = 1901;
  
  /// 1902: ERROR_GRAPH_COULD_NOT_CREATE_GRAPH
  /// "could not create graph"
  /// Will be raised when an invalid name, vertices or edges is passed to the
  /// server.
  constexpr int TRI_ERROR_GRAPH_COULD_NOT_CREATE_GRAPH                            = 1902;
  
  /// 1903: ERROR_GRAPH_INVALID_VERTEX
  /// "invalid vertex"
  /// Will be raised when an invalid vertex id is passed to the server.
  constexpr int TRI_ERROR_GRAPH_INVALID_VERTEX                                    = 1903;
  
  /// 1904: ERROR_GRAPH_COULD_NOT_CREATE_VERTEX
  /// "could not create vertex"
  /// Will be raised when the vertex could not be created.
  constexpr int TRI_ERROR_GRAPH_COULD_NOT_CREATE_VERTEX                           = 1904;
  
  /// 1905: ERROR_GRAPH_COULD_NOT_CHANGE_VERTEX
  /// "could not change vertex"
  /// Will be raised when the vertex could not be changed.
  constexpr int TRI_ERROR_GRAPH_COULD_NOT_CHANGE_VERTEX                           = 1905;
  
  /// 1906: ERROR_GRAPH_INVALID_EDGE
  /// "invalid edge"
  /// Will be raised when an invalid edge id is passed to the server.
  constexpr int TRI_ERROR_GRAPH_INVALID_EDGE                                      = 1906;
  
  /// 1907: ERROR_GRAPH_COULD_NOT_CREATE_EDGE
  /// "could not create edge"
  /// Will be raised when the edge could not be created.
  constexpr int TRI_ERROR_GRAPH_COULD_NOT_CREATE_EDGE                             = 1907;
  
  /// 1908: ERROR_GRAPH_COULD_NOT_CHANGE_EDGE
  /// "could not change edge"
  /// Will be raised when the edge could not be changed.
  constexpr int TRI_ERROR_GRAPH_COULD_NOT_CHANGE_EDGE                             = 1908;
  
  /// 1909: ERROR_GRAPH_TOO_MANY_ITERATIONS
  /// "too many iterations - try increasing the value of 'maxIterations'"
  /// Will be raised when too many iterations are done in a graph traversal.
  constexpr int TRI_ERROR_GRAPH_TOO_MANY_ITERATIONS                               = 1909;
  
  /// 1910: ERROR_GRAPH_INVALID_FILTER_RESULT
  /// "invalid filter result"
  /// Will be raised when an invalid filter result is returned in a graph
  /// traversal.
  constexpr int TRI_ERROR_GRAPH_INVALID_FILTER_RESULT                             = 1910;
  
  /// 1920: ERROR_GRAPH_COLLECTION_MULTI_USE
  /// "multi use of edge collection in edge def"
  /// an edge collection may only be used once in one edge definition of a graph.
  constexpr int TRI_ERROR_GRAPH_COLLECTION_MULTI_USE                              = 1920;
  
  /// 1921: ERROR_GRAPH_COLLECTION_USE_IN_MULTI_GRAPHS
  /// "edge collection already used in edge def"
  ///  is already used by another graph in a different edge definition.
  constexpr int TRI_ERROR_GRAPH_COLLECTION_USE_IN_MULTI_GRAPHS                    = 1921;
  
  /// 1922: ERROR_GRAPH_CREATE_MISSING_NAME
  /// "missing graph name"
  /// a graph name is required to create a graph.
  constexpr int TRI_ERROR_GRAPH_CREATE_MISSING_NAME                               = 1922;
  
  /// 1923: ERROR_GRAPH_CREATE_MALFORMED_EDGE_DEFINITION
  /// "malformed edge definition"
  /// the edge definition is malformed. It has to be an array of objects.
  constexpr int TRI_ERROR_GRAPH_CREATE_MALFORMED_EDGE_DEFINITION                  = 1923;
  
  /// 1924: ERROR_GRAPH_NOT_FOUND
  /// "graph '%s' not found"
  /// a graph with this name could not be found.
  constexpr int TRI_ERROR_GRAPH_NOT_FOUND                                         = 1924;
  
  /// 1925: ERROR_GRAPH_DUPLICATE
  /// "graph already exists"
  /// a graph with this name already exists.
  constexpr int TRI_ERROR_GRAPH_DUPLICATE                                         = 1925;
  
  /// 1926: ERROR_GRAPH_VERTEX_COL_DOES_NOT_EXIST
  /// "vertex collection does not exist or is not part of the graph"
  /// the specified vertex collection does not exist or is not part of the graph.
  constexpr int TRI_ERROR_GRAPH_VERTEX_COL_DOES_NOT_EXIST                         = 1926;
  
  /// 1927: ERROR_GRAPH_WRONG_COLLECTION_TYPE_VERTEX
  /// "collection not a vertex collection"
  /// the collection is not a vertex collection.
  constexpr int TRI_ERROR_GRAPH_WRONG_COLLECTION_TYPE_VERTEX                      = 1927;
  
  /// 1928: ERROR_GRAPH_NOT_IN_ORPHAN_COLLECTION
  /// "collection is not in list of orphan collections"
  /// Vertex collection not in list of orphan collections of the graph.
  constexpr int TRI_ERROR_GRAPH_NOT_IN_ORPHAN_COLLECTION                          = 1928;
  
  /// 1929: ERROR_GRAPH_COLLECTION_USED_IN_EDGE_DEF
  /// "collection already used in edge def"
  /// The collection is already used in an edge definition of the graph.
  constexpr int TRI_ERROR_GRAPH_COLLECTION_USED_IN_EDGE_DEF                       = 1929;
  
  /// 1930: ERROR_GRAPH_EDGE_COLLECTION_NOT_USED
  /// "edge collection not used in graph"
  /// The edge collection is not used in any edge definition of the graph.
  constexpr int TRI_ERROR_GRAPH_EDGE_COLLECTION_NOT_USED                          = 1930;
  
  /// 1932: ERROR_GRAPH_NO_GRAPH_COLLECTION
  /// "collection _graphs does not exist"
  /// collection _graphs does not exist.
  constexpr int TRI_ERROR_GRAPH_NO_GRAPH_COLLECTION                               = 1932;
  
  /// 1933: ERROR_GRAPH_INVALID_EXAMPLE_ARRAY_OBJECT_STRING
  /// "Invalid example type. Has to be String, Array or Object"
  /// Invalid example type. Has to be String, Array or Object.
  constexpr int TRI_ERROR_GRAPH_INVALID_EXAMPLE_ARRAY_OBJECT_STRING               = 1933;
  
  /// 1934: ERROR_GRAPH_INVALID_EXAMPLE_ARRAY_OBJECT
  /// "Invalid example type. Has to be Array or Object"
  /// Invalid example type. Has to be Array or Object.
  constexpr int TRI_ERROR_GRAPH_INVALID_EXAMPLE_ARRAY_OBJECT                      = 1934;
  
  /// 1935: ERROR_GRAPH_INVALID_NUMBER_OF_ARGUMENTS
  /// "Invalid number of arguments. Expected: "
  /// Invalid number of arguments. Expected: 
  constexpr int TRI_ERROR_GRAPH_INVALID_NUMBER_OF_ARGUMENTS                       = 1935;
  
  /// 1936: ERROR_GRAPH_INVALID_PARAMETER
  /// "Invalid parameter type."
  /// Invalid parameter type.
  constexpr int TRI_ERROR_GRAPH_INVALID_PARAMETER                                 = 1936;
  
  /// 1937: ERROR_GRAPH_INVALID_ID
  /// "Invalid id"
  /// Invalid id
  constexpr int TRI_ERROR_GRAPH_INVALID_ID                                        = 1937;
  
  /// 1938: ERROR_GRAPH_COLLECTION_USED_IN_ORPHANS
  /// "collection used in orphans"
  /// The collection is already used in the orphans of the graph.
  constexpr int TRI_ERROR_GRAPH_COLLECTION_USED_IN_ORPHANS                        = 1938;
  
  /// 1939: ERROR_GRAPH_EDGE_COL_DOES_NOT_EXIST
  /// "edge collection does not exist or is not part of the graph"
  /// the specified edge collection does not exist or is not part of the graph.
  constexpr int TRI_ERROR_GRAPH_EDGE_COL_DOES_NOT_EXIST                           = 1939;
  
  /// 1940: ERROR_GRAPH_EMPTY
  /// "empty graph"
  /// The requested graph has no edge collections.
  constexpr int TRI_ERROR_GRAPH_EMPTY                                             = 1940;
  
  /// 1941: ERROR_GRAPH_INTERNAL_DATA_CORRUPT
  /// "internal graph data corrupt"
  /// The _graphs collection contains invalid data.
  constexpr int TRI_ERROR_GRAPH_INTERNAL_DATA_CORRUPT                             = 1941;
  
  /// 1942: ERROR_GRAPH_INTERNAL_EDGE_COLLECTION_ALREADY_SET
  /// "edge collection already set"
  /// Tried to add an edge collection which is already defined.
  constexpr int TRI_ERROR_GRAPH_INTERNAL_EDGE_COLLECTION_ALREADY_SET              = 1942;
  
  /// 1943: ERROR_GRAPH_CREATE_MALFORMED_ORPHAN_LIST
  /// "malformed orphan list"
  /// the orphan list argument is malformed. It has to be an array of strings.
  constexpr int TRI_ERROR_GRAPH_CREATE_MALFORMED_ORPHAN_LIST                      = 1943;
  
  /// 1944: ERROR_GRAPH_EDGE_DEFINITION_IS_DOCUMENT
  /// "edge definition collection is a document collection"
  /// the collection used as a relation is existing, but is a document
  /// collection, it cannot be used here.
  constexpr int TRI_ERROR_GRAPH_EDGE_DEFINITION_IS_DOCUMENT                       = 1944;
  
  /// 1950: ERROR_SESSION_UNKNOWN
  /// "unknown session"
  /// Will be raised when an invalid/unknown session id is passed to the server.
  constexpr int TRI_ERROR_SESSION_UNKNOWN                                         = 1950;
  
  /// 1951: ERROR_SESSION_EXPIRED
  /// "session expired"
  /// Will be raised when a session is expired.
  constexpr int TRI_ERROR_SESSION_EXPIRED                                         = 1951;
  
  /// 2000: ERROR_SIMPLE_CLIENT_UNKNOWN_ERROR
  /// "unknown client error"
  /// This error should not happen.
  constexpr int TRI_ERROR_SIMPLE_CLIENT_UNKNOWN_ERROR                             = 2000;
  
  /// 2001: ERROR_SIMPLE_CLIENT_COULD_NOT_CONNECT
  /// "could not connect to server"
  /// Will be raised when the client could not connect to the server.
  constexpr int TRI_ERROR_SIMPLE_CLIENT_COULD_NOT_CONNECT                         = 2001;
  
  /// 2002: ERROR_SIMPLE_CLIENT_COULD_NOT_WRITE
  /// "could not write to server"
  /// Will be raised when the client could not write data.
  constexpr int TRI_ERROR_SIMPLE_CLIENT_COULD_NOT_WRITE                           = 2002;
  
  /// 2003: ERROR_SIMPLE_CLIENT_COULD_NOT_READ
  /// "could not read from server"
  /// Will be raised when the client could not read data.
  constexpr int TRI_ERROR_SIMPLE_CLIENT_COULD_NOT_READ                            = 2003;
  
  /// 2019: ERROR_WAS_ERLAUBE
  /// "was erlaube?!"
  /// Will be raised if was erlaube?!
  constexpr int TRI_ERROR_WAS_ERLAUBE                                             = 2019;
  
  /// 2100: ERROR_COMMUNICATOR_REQUEST_ABORTED
  /// "Request aborted"
  /// Request was aborted.
  constexpr int TRI_ERROR_COMMUNICATOR_REQUEST_ABORTED                            = 2100;
  
  /// 2101: ERROR_COMMUNICATOR_DISABLED
  /// "Communication was disabled"
  /// Communication was disabled.
  constexpr int TRI_ERROR_COMMUNICATOR_DISABLED                                   = 2101;
  
  /// 2200: ERROR_INTERNAL_AQL
  /// "General internal AQL error"
  /// Internal error during AQL execution
  constexpr int TRI_ERROR_INTERNAL_AQL                                            = 2200;
  
  /// 2201: ERROR_WROTE_TOO_FEW_OUTPUT_REGISTERS
  /// "An AQL block wrote too few output registers"
  /// An AQL block wrote too few output registers
  constexpr int TRI_ERROR_WROTE_TOO_FEW_OUTPUT_REGISTERS                          = 2201;
  
  /// 2202: ERROR_WROTE_TOO_MANY_OUTPUT_REGISTERS
  /// "An AQL block wrote too many output registers"
  /// An AQL block wrote too many output registers
  constexpr int TRI_ERROR_WROTE_TOO_MANY_OUTPUT_REGISTERS                         = 2202;
  
  /// 2203: ERROR_WROTE_OUTPUT_REGISTER_TWICE
  /// "An AQL block wrote an output register twice"
  /// An AQL block wrote an output register twice
  constexpr int TRI_ERROR_WROTE_OUTPUT_REGISTER_TWICE                             = 2203;
  
  /// 2204: ERROR_WROTE_IN_WRONG_REGISTER
  /// "An AQL block wrote in a register that is not its output"
  /// An AQL block wrote in a register that is not its output
  constexpr int TRI_ERROR_WROTE_IN_WRONG_REGISTER                                 = 2204;
  
  /// 2205: ERROR_INPUT_REGISTERS_NOT_COPIED
  /// "An AQL block did not copy its input registers"
  /// An AQL block did not copy its input registers
  constexpr int TRI_ERROR_INPUT_REGISTERS_NOT_COPIED                              = 2205;
  
  /// 3000: ERROR_MALFORMED_MANIFEST_FILE
  /// "failed to parse manifest file"
  /// The service manifest file is not well-formed JSON.
  constexpr int TRI_ERROR_MALFORMED_MANIFEST_FILE                                 = 3000;
  
  /// 3001: ERROR_INVALID_SERVICE_MANIFEST
  /// "manifest file is invalid"
  /// The service manifest contains invalid values.
  constexpr int TRI_ERROR_INVALID_SERVICE_MANIFEST                                = 3001;
  
  /// 3002: ERROR_SERVICE_FILES_MISSING
  /// "service files missing"
  /// The service folder or bundle does not exist on this server.
  constexpr int TRI_ERROR_SERVICE_FILES_MISSING                                   = 3002;
  
  /// 3003: ERROR_SERVICE_FILES_OUTDATED
  /// "service files outdated"
  /// The local service bundle does not match the checksum in the database.
  constexpr int TRI_ERROR_SERVICE_FILES_OUTDATED                                  = 3003;
  
  /// 3004: ERROR_INVALID_FOXX_OPTIONS
  /// "service options are invalid"
  /// The service options contain invalid values.
  constexpr int TRI_ERROR_INVALID_FOXX_OPTIONS                                    = 3004;
  
  /// 3007: ERROR_INVALID_MOUNTPOINT
  /// "invalid mountpath"
  /// The service mountpath contains invalid characters.
  constexpr int TRI_ERROR_INVALID_MOUNTPOINT                                      = 3007;
  
  /// 3009: ERROR_SERVICE_NOT_FOUND
  /// "service not found"
  /// No service found at the given mountpath.
  constexpr int TRI_ERROR_SERVICE_NOT_FOUND                                       = 3009;
  
  /// 3010: ERROR_SERVICE_NEEDS_CONFIGURATION
  /// "service needs configuration"
  /// The service is missing configuration or dependencies.
  constexpr int TRI_ERROR_SERVICE_NEEDS_CONFIGURATION                             = 3010;
  
  /// 3011: ERROR_SERVICE_MOUNTPOINT_CONFLICT
  /// "service already exists"
  /// A service already exists at the given mountpath.
  constexpr int TRI_ERROR_SERVICE_MOUNTPOINT_CONFLICT                             = 3011;
  
  /// 3012: ERROR_SERVICE_MANIFEST_NOT_FOUND
  /// "missing manifest file"
  /// The service directory does not contain a manifest file.
  constexpr int TRI_ERROR_SERVICE_MANIFEST_NOT_FOUND                              = 3012;
  
  /// 3013: ERROR_SERVICE_OPTIONS_MALFORMED
  /// "failed to parse service options"
  /// The service options are not well-formed JSON.
  constexpr int TRI_ERROR_SERVICE_OPTIONS_MALFORMED                               = 3013;
  
  /// 3014: ERROR_SERVICE_SOURCE_NOT_FOUND
  /// "source path not found"
  /// The source path does not match a file or directory.
  constexpr int TRI_ERROR_SERVICE_SOURCE_NOT_FOUND                                = 3014;
  
  /// 3015: ERROR_SERVICE_SOURCE_ERROR
  /// "error resolving source"
  /// The source path could not be resolved.
  constexpr int TRI_ERROR_SERVICE_SOURCE_ERROR                                    = 3015;
  
  /// 3016: ERROR_SERVICE_UNKNOWN_SCRIPT
  /// "unknown script"
  /// The service does not have a script with this name.
  constexpr int TRI_ERROR_SERVICE_UNKNOWN_SCRIPT                                  = 3016;
  
  /// 3099: ERROR_SERVICE_API_DISABLED
  /// "service api disabled"
  /// The API for managing Foxx services has been disabled on this server.
  constexpr int TRI_ERROR_SERVICE_API_DISABLED                                    = 3099;
  
  /// 3100: ERROR_MODULE_NOT_FOUND
  /// "cannot locate module"
  /// The module path could not be resolved.
  constexpr int TRI_ERROR_MODULE_NOT_FOUND                                        = 3100;
  
  /// 3101: ERROR_MODULE_SYNTAX_ERROR
  /// "syntax error in module"
  /// The module could not be parsed because of a syntax error.
  constexpr int TRI_ERROR_MODULE_SYNTAX_ERROR                                     = 3101;
  
  /// 3103: ERROR_MODULE_FAILURE
  /// "failed to invoke module"
  /// Failed to invoke the module in its context.
  constexpr int TRI_ERROR_MODULE_FAILURE                                          = 3103;
  
  /// 4000: ERROR_NO_SMART_COLLECTION
  /// "collection is not smart"
  /// The requested collection needs to be smart, but it ain't
  constexpr int TRI_ERROR_NO_SMART_COLLECTION                                     = 4000;
  
  /// 4001: ERROR_NO_SMART_GRAPH_ATTRIBUTE
  /// "smart graph attribute not given"
  /// The given document does not have the smart graph attribute set.
  constexpr int TRI_ERROR_NO_SMART_GRAPH_ATTRIBUTE                                = 4001;
  
  /// 4002: ERROR_CANNOT_DROP_SMART_COLLECTION
  /// "cannot drop this smart collection"
  /// This smart collection cannot be dropped, it dictates sharding in the graph.
  constexpr int TRI_ERROR_CANNOT_DROP_SMART_COLLECTION                            = 4002;
  
  /// 4003: ERROR_KEY_MUST_BE_PREFIXED_WITH_SMART_GRAPH_ATTRIBUTE
  /// "in smart vertex collections _key must be prefixed with the value of the
  /// "smart graph attribute"
  /// In a smart vertex collection _key must be prefixed with the value of the
  /// smart graph attribute.
  constexpr int TRI_ERROR_KEY_MUST_BE_PREFIXED_WITH_SMART_GRAPH_ATTRIBUTE         = 4003;
  
  /// 4004: ERROR_ILLEGAL_SMART_GRAPH_ATTRIBUTE
  /// "attribute cannot be used as smart graph attribute"
  /// The given smartGraph attribute is illegal and connot be used for sharding.
  /// All system attributes are forbidden.
  constexpr int TRI_ERROR_ILLEGAL_SMART_GRAPH_ATTRIBUTE                           = 4004;
  
  /// 4005: ERROR_SMART_GRAPH_ATTRIBUTE_MISMATCH
  /// "smart graph attribute mismatch"
  /// The smart graph attribute of the given collection does not match the smart
  /// graph attribute of the graph.
  constexpr int TRI_ERROR_SMART_GRAPH_ATTRIBUTE_MISMATCH                          = 4005;
  
  /// 4006: ERROR_INVALID_SMART_JOIN_ATTRIBUTE
  /// "invalid smart join attribute declaration"
  /// Will be raised when the smartJoinAttribute declaration is invalid.
  constexpr int TRI_ERROR_INVALID_SMART_JOIN_ATTRIBUTE                            = 4006;
  
  /// 4007: ERROR_KEY_MUST_BE_PREFIXED_WITH_SMART_JOIN_ATTRIBUTE
  /// "shard key value must be prefixed with the value of the smart join attribute"
  /// when using smartJoinAttribute for a collection, the shard key value must be
  /// prefixed with the value of the smart join attribute.
  constexpr int TRI_ERROR_KEY_MUST_BE_PREFIXED_WITH_SMART_JOIN_ATTRIBUTE          = 4007;
  
  /// 4008: ERROR_NO_SMART_JOIN_ATTRIBUTE
  /// "smart join attribute not given or invalid"
  /// The given document does not have the required smart join attribute set or
  /// it has an invalid value.
  constexpr int TRI_ERROR_NO_SMART_JOIN_ATTRIBUTE                                 = 4008;
  
  /// 4009: ERROR_CLUSTER_MUST_NOT_CHANGE_SMART_JOIN_ATTRIBUTE
  /// "must not change the value of the smartJoinAttribute"
  /// Will be raised if there is an attempt to update the value of the
  /// smartJoinAttribute.
  constexpr int TRI_ERROR_CLUSTER_MUST_NOT_CHANGE_SMART_JOIN_ATTRIBUTE            = 4009;
  
  /// 5000: ERROR_CLUSTER_REPAIRS_FAILED
  /// "error during cluster repairs"
  /// General error during cluster repairs
  constexpr int TRI_ERROR_CLUSTER_REPAIRS_FAILED                                  = 5000;
  
  /// 5001: ERROR_CLUSTER_REPAIRS_NOT_ENOUGH_HEALTHY
  /// "not enough (healthy) db servers"
  /// Will be raised when, during repairDistributeShardsLike, there must be a
  /// free db server to move a shard, but there is no candidate or none is
  /// healthy.
  constexpr int TRI_ERROR_CLUSTER_REPAIRS_NOT_ENOUGH_HEALTHY                      = 5001;
  
  /// 5002: ERROR_CLUSTER_REPAIRS_REPLICATION_FACTOR_VIOLATED
  /// "replication factor violated during cluster repairs"
  /// Will be raised on various inconsistencies regarding the replication factor
  constexpr int TRI_ERROR_CLUSTER_REPAIRS_REPLICATION_FACTOR_VIOLATED             = 5002;
  
  /// 5003: ERROR_CLUSTER_REPAIRS_NO_DBSERVERS
  /// "no dbservers during cluster repairs"
  /// Will be raised if a collection that is fixed has some shard without DB
  /// Servers
  constexpr int TRI_ERROR_CLUSTER_REPAIRS_NO_DBSERVERS                            = 5003;
  
  /// 5004: ERROR_CLUSTER_REPAIRS_MISMATCHING_LEADERS
  /// "mismatching leaders during cluster repairs"
  /// Will be raised if a shard in collection and its prototype in the
  /// corresponding distributeShardsLike collection have mismatching leaders
  /// (when they should already have been fixed)
  constexpr int TRI_ERROR_CLUSTER_REPAIRS_MISMATCHING_LEADERS                     = 5004;
  
  /// 5005: ERROR_CLUSTER_REPAIRS_MISMATCHING_FOLLOWERS
  /// "mismatching followers during cluster repairs"
  /// Will be raised if a shard in collection and its prototype in the
  /// corresponding distributeShardsLike collection don't have the same followers
  /// (when they should already have been adjusted)
  constexpr int TRI_ERROR_CLUSTER_REPAIRS_MISMATCHING_FOLLOWERS                   = 5005;
  
  /// 5006: ERROR_CLUSTER_REPAIRS_INCONSISTENT_ATTRIBUTES
  /// "inconsistent attributes during cluster repairs"
  /// Will be raised if a collection that is fixed does (not) have
  /// distributeShardsLike when it is expected, or does (not) have
  /// repairingDistributeShardsLike when it is expected
  constexpr int TRI_ERROR_CLUSTER_REPAIRS_INCONSISTENT_ATTRIBUTES                 = 5006;
  
  /// 5007: ERROR_CLUSTER_REPAIRS_MISMATCHING_SHARDS
  /// "mismatching shards during cluster repairs"
  /// Will be raised if in a collection and its distributeShardsLike prototype
  /// collection some shard and its prototype have an unequal number of DB Servers
  constexpr int TRI_ERROR_CLUSTER_REPAIRS_MISMATCHING_SHARDS                      = 5007;
  
  /// 5008: ERROR_CLUSTER_REPAIRS_JOB_FAILED
  /// "move shard job failed during cluster repairs"
  /// Will be raised if a move shard job in the agency failed during cluster
  /// repairs
  constexpr int TRI_ERROR_CLUSTER_REPAIRS_JOB_FAILED                              = 5008;
  
  /// 5009: ERROR_CLUSTER_REPAIRS_JOB_DISAPPEARED
  /// "move shard job disappeared during cluster repairs"
  /// Will be raised if a move shard job in the agency cannot be found anymore
  /// before it finished
  constexpr int TRI_ERROR_CLUSTER_REPAIRS_JOB_DISAPPEARED                         = 5009;
  
  /// 5010: ERROR_CLUSTER_REPAIRS_OPERATION_FAILED
  /// "agency transaction failed during cluster repairs"
  /// Will be raised if an agency transaction failed during either sending or
  /// executing it.
  constexpr int TRI_ERROR_CLUSTER_REPAIRS_OPERATION_FAILED                        = 5010;
  
  /// 20011: ERROR_AGENCY_INFORM_MUST_BE_OBJECT
  /// "Inform message must be an object."
  /// The inform message in the agency must be an object.
  constexpr int TRI_ERROR_AGENCY_INFORM_MUST_BE_OBJECT                            = 20011;
  
  /// 20012: ERROR_AGENCY_INFORM_MUST_CONTAIN_TERM
  /// "Inform message must contain uint parameter 'term'"
  /// The inform message in the agency must contain a uint parameter 'term'.
  constexpr int TRI_ERROR_AGENCY_INFORM_MUST_CONTAIN_TERM                         = 20012;
  
  /// 20013: ERROR_AGENCY_INFORM_MUST_CONTAIN_ID
  /// "Inform message must contain string parameter 'id'"
  /// The inform message in the agency must contain a string parameter 'id'.
  constexpr int TRI_ERROR_AGENCY_INFORM_MUST_CONTAIN_ID                           = 20013;
  
  /// 20014: ERROR_AGENCY_INFORM_MUST_CONTAIN_ACTIVE
  /// "Inform message must contain array 'active'"
  /// The inform message in the agency must contain an array 'active'.
  constexpr int TRI_ERROR_AGENCY_INFORM_MUST_CONTAIN_ACTIVE                       = 20014;
  
  /// 20015: ERROR_AGENCY_INFORM_MUST_CONTAIN_POOL
  /// "Inform message must contain object 'pool'"
  /// The inform message in the agency must contain an object 'pool'.
  constexpr int TRI_ERROR_AGENCY_INFORM_MUST_CONTAIN_POOL                         = 20015;
  
  /// 20016: ERROR_AGENCY_INFORM_MUST_CONTAIN_MIN_PING
  /// "Inform message must contain object 'min ping'"
  /// The inform message in the agency must contain an object 'min ping'.
  constexpr int TRI_ERROR_AGENCY_INFORM_MUST_CONTAIN_MIN_PING                     = 20016;
  
  /// 20017: ERROR_AGENCY_INFORM_MUST_CONTAIN_MAX_PING
  /// "Inform message must contain object 'max ping'"
  /// The inform message in the agency must contain an object 'max ping'.
  constexpr int TRI_ERROR_AGENCY_INFORM_MUST_CONTAIN_MAX_PING                     = 20017;
  
  /// 20018: ERROR_AGENCY_INFORM_MUST_CONTAIN_TIMEOUT_MULT
  /// "Inform message must contain object 'timeoutMult'"
  /// The inform message in the agency must contain an object 'timeoutMult'.
  constexpr int TRI_ERROR_AGENCY_INFORM_MUST_CONTAIN_TIMEOUT_MULT                 = 20018;
  
  /// 20021: ERROR_AGENCY_CANNOT_REBUILD_DBS
  /// "Cannot rebuild readDB and spearHead"
  /// Will be raised if the readDB or the spearHead cannot be rebuilt from the
  /// replicated log.
  constexpr int TRI_ERROR_AGENCY_CANNOT_REBUILD_DBS                               = 20021;
  
  /// 20501: ERROR_SUPERVISION_GENERAL_FAILURE
  /// "general supervision failure"
  /// General supervision failure.
  constexpr int TRI_ERROR_SUPERVISION_GENERAL_FAILURE                             = 20501;
  
  /// 21003: ERROR_QUEUE_FULL
  /// "named queue is full"
  /// Will be returned if a queue with this name is full.
  constexpr int TRI_ERROR_QUEUE_FULL                                              = 21003;
  
  /// 6002: ERROR_ACTION_OPERATION_UNABORTABLE
  /// "this maintenance action cannot be stopped"
  /// This maintenance action cannot be stopped once it is started
  constexpr int TRI_ERROR_ACTION_OPERATION_UNABORTABLE                            = 6002;
  
  /// 6003: ERROR_ACTION_UNFINISHED
  /// "maintenance action still processing"
  /// This maintenance action is still processing
  constexpr int TRI_ERROR_ACTION_UNFINISHED                                       = 6003;
  
  /// 6004: ERROR_NO_SUCH_ACTION
  /// "no such maintenance action"
  /// No such maintenance action exists
  constexpr int TRI_ERROR_NO_SUCH_ACTION                                          = 6004;
  
  ///  7001: ERROR_HOT_BACKUP_INTERNAL
  /// " "internal hot backup error""
  ///  "Failed to create hot backup set"
  constexpr int TRI_ERROR_HOT_BACKUP_INTERNAL                                     =  7001;
  
  ///  7002: ERROR_HOT_RESTORE_INTERNAL
  /// " "internal hot restore error""
  ///  "Failed to restore to hot backup set"
  constexpr int TRI_ERROR_HOT_RESTORE_INTERNAL                                    =  7002;
  
  ///  7003: ERROR_BACKUP_TOPOLOGY
  /// " "backup does not match this topology""
  ///  "The hot backup set cannot be restored on non matching cluster topology"
  constexpr int TRI_ERROR_BACKUP_TOPOLOGY                                         =  7003;
  
  ///  7004: ERROR_NO_SPACE_LEFT_ON_DEVICE
  /// " "no space left on device""
  ///  "No space left on device"
  constexpr int TRI_ERROR_NO_SPACE_LEFT_ON_DEVICE                                 =  7004;
  
  ///  7005: ERROR_FAILED_TO_UPLOAD_BACKUP
  /// " "failed to upload hot backup set to remote target""
  ///  "Failed to upload hot backup set to remote target"
  constexpr int TRI_ERROR_FAILED_TO_UPLOAD_BACKUP                                 =  7005;
  
  ///  7006: ERROR_FAILED_TO_DOWNLOAD_BACKUP
  /// " "failed to download hot backup set from remote source""
  ///  "Failed to downloadload hot backup set from remote source"
  constexpr int TRI_ERROR_FAILED_TO_DOWNLOAD_BACKUP                               =  7006;
  
  ///  7007: ERROR_NO_SUCH_HOT_BACKUP
  /// " "no such hot backup set can be found"
  ///  "Cannot find a hot backup set with this Id"
  constexpr int TRI_ERROR_NO_SUCH_HOT_BACKUP                                      =  7007;
  
  ///  7008: ERROR_REMOTE_REPOSITORY_CONFIG_BAD
  /// " "remote hotback repository configuration error""
  ///  "The configuration given for upload or download operation to/from remote
  /// hotback repositories is wrong."
  constexpr int TRI_ERROR_REMOTE_REPOSITORY_CONFIG_BAD                            =  7008;
  
  ///  7009: ERROR_LOCAL_LOCK_FAILED
  /// " "some db servers cannot be reached for transaction locks""
  ///  "Some of the db servers cannot be reached for transaction locks."
  constexpr int TRI_ERROR_LOCAL_LOCK_FAILED                                       =  7009;
  
  ///  7010: ERROR_LOCAL_LOCK_RETRY
  /// " "some db servers cannot be reached for transaction locks""
  ///  "Some of the db servers cannot be reached for transaction locks."
  constexpr int TRI_ERROR_LOCAL_LOCK_RETRY                                        =  7010;
  
  ///  7011: ERROR_HOT_BACKUP_CONFLICT
  /// " "hot backup conflict""
  ///  "Conflict of multiple hot backup processes."
  constexpr int TRI_ERROR_HOT_BACKUP_CONFLICT                                     =  7011;
  
  ///  7012: ERROR_HOT_BACKUP_DBSERVERS_AWOL
  /// " "hot backup not all db servers reachable""
  ///  "One or more db servers could not be reached for hot backup inquiry"
  constexpr int TRI_ERROR_HOT_BACKUP_DBSERVERS_AWOL                               =  7012;
  
  
  /// register all errors for ArangoDB
  void TRI_InitializeErrorMessages();
  
  #endif
  