arangodb

type AbortTransactionOptions struct{}

type Analyzer interface {
	Name() string
	Database() Database

	// Type returns the analyzer type
	Type() ArangoSearchAnalyzerType

	// UniqueName returns the unique name: <database>::<analyzer-name>
	UniqueName() string

	// Definition returns the analyzer definition
	Definition() AnalyzerDefinition

	// Remove the analyzer
	Remove(ctx context.Context, force bool) error
}

type AnalyzerDefinition struct {
	// The Analyzer name.
	Name string `json:"name,omitempty"`

	// The Analyzer type.
	Type ArangoSearchAnalyzerType `json:"type,omitempty"`

	// The properties used to configure the specified Analyzer type.
	Properties ArangoSearchAnalyzerProperties `json:"properties,omitempty"`

	// The set of features to set on the Analyzer generated fields.
	// The default value is an empty array.
	Features []ArangoSearchFeature `json:"features,omitempty"`
}

type AnalyzersResponseReader interface {
	// Read returns next Analyzer. If no Analyzers left, shared.NoMoreDocumentsError returned
	Read() (Analyzer, error)
}

type ArangoSearchAliasIndex struct {
	// Collection The name of a collection.
	Collection string `json:"collection"`

	// Index The name of an inverted index of the collection, or the index ID without the <collection>/ prefix.
	Index string `json:"index"`
}

type ArangoSearchAliasOperation string

type ArangoSearchAliasUpdateOpts struct {
	// Indexes A list of inverted indexes to add to the View.
	Indexes []ArangoSearchAliasIndex `json:"indexes,omitempty"`

	// Operation Whether to add or remove the index to the stored indexes property of the View.
	// Possible values: "add", "del".
	// The default is "add".
	Operation ArangoSearchAliasOperation `json:"operation,omitempty"`
}

type ArangoSearchAliasViewProperties struct {
	// ViewBase field is available only in read operations
	ViewBase

	// Indexes A list of inverted indexes to add to the View.
	Indexes []ArangoSearchAliasIndex `json:"indexes,omitempty"`
}

type ArangoSearchAnalyzerAQLReturnType string

type ArangoSearchAnalyzerGeoJSONType string

type ArangoSearchAnalyzerGeoOptions struct {
	// MaxCells define maximum number of S2 cells.
	MaxCells *int `json:"maxCells,omitempty"`

	// MinLevel define the least precise S2 level.
	MinLevel *int `json:"minLevel,omitempty"`

	// MaxLevel define the most precise S2 level
	MaxLevel *int `json:"maxLevel,omitempty"`
}

type ArangoSearchAnalyzerPipeline struct {
	// Type of the Pipeline Analyzer
	Type ArangoSearchAnalyzerType `json:"type"`

	// Properties of the Pipeline Analyzer
	Properties ArangoSearchAnalyzerProperties `json:"properties,omitempty"`
}

type ArangoSearchAnalyzerProperties struct {
	IsSystem bool `json:"isSystem,omitempty"`

	// Locale used by ArangoSearchAnalyzerTypeStem, ArangoSearchAnalyzerTypeNorm, Text
	Locale string `json:"locale,omitempty"`

	// Delimiter used by ArangoSearchAnalyzerTypeDelimiter
	Delimiter string `json:"delimiter,omitempty"`

	// Delimiters used by ArangoSearchAnalyzerTypeMultiDelimiter
	Delimiters []string `json:"delimiters,omitempty"`

	// Accent used by ArangoSearchAnalyzerTypeNorm, ArangoSearchAnalyzerTypeText
	Accent *bool `json:"accent,omitempty"`

	// Case used by ArangoSearchAnalyzerTypeNorm, ArangoSearchAnalyzerTypeText, ArangoSearchAnalyzerTypeSegmentation
	Case ArangoSearchCaseType `json:"case,omitempty"`

	// EdgeNGram used by ArangoSearchAnalyzerTypeText
	EdgeNGram *ArangoSearchEdgeNGram `json:"edgeNgram,omitempty"`

	// Min used by ArangoSearchAnalyzerTypeNGram
	Min *int64 `json:"min,omitempty"`

	Max *int64 `json:"max,omitempty"`
	// PreserveOriginal used by ArangoSearchAnalyzerTypeNGram
	PreserveOriginal *bool `json:"preserveOriginal,omitempty"`

	// StartMarker used by ArangoSearchAnalyzerTypeNGram
	StartMarker *string `json:"startMarker,omitempty"`

	// EndMarker used by ArangoSearchAnalyzerTypeNGram
	EndMarker *string `json:"endMarker,omitempty"`

	// StreamType used by ArangoSearchAnalyzerTypeNGram
	StreamType *ArangoSearchNGramStreamType `json:"streamType,omitempty"`

	// Stemming used by ArangoSearchAnalyzerTypeText
	Stemming *bool `json:"stemming,omitempty"`

	// Stopwords used by ArangoSearchAnalyzerTypeText and ArangoSearchAnalyzerTypeStopwords.
	// This field is not mandatory since version 3.7 of arangod so it can not be omitted in 3.6.
	Stopwords []string `json:"stopwords"`

	// StopwordsPath used by ArangoSearchAnalyzerTypeText
	StopwordsPath []string `json:"stopwordsPath,omitempty"`

	// QueryString used by ArangoSearchAnalyzerTypeAQL.
	QueryString string `json:"queryString,omitempty"`

	// CollapsePositions used by ArangoSearchAnalyzerTypeAQL.
	CollapsePositions *bool `json:"collapsePositions,omitempty"`

	// KeepNull used by ArangoSearchAnalyzerTypeAQL.
	KeepNull *bool `json:"keepNull,omitempty"`

	// BatchSize used by ArangoSearchAnalyzerTypeAQL.
	BatchSize *int `json:"batchSize,omitempty"`

	// MemoryLimit used by ArangoSearchAnalyzerTypeAQL.
	MemoryLimit *int `json:"memoryLimit,omitempty"`

	// ReturnType used by ArangoSearchAnalyzerTypeAQL.
	ReturnType *ArangoSearchAnalyzerAQLReturnType `json:"returnType,omitempty"`

	// Pipeline used by ArangoSearchAnalyzerTypePipeline.
	Pipeline []ArangoSearchAnalyzerPipeline `json:"pipeline,omitempty"`

	// Type used by ArangoSearchAnalyzerTypeGeoJSON.
	Type *ArangoSearchAnalyzerGeoJSONType `json:"type,omitempty"`

	// Options used by ArangoSearchAnalyzerTypeGeoJSON and ArangoSearchAnalyzerTypeGeoPoint
	Options *ArangoSearchAnalyzerGeoOptions `json:"options,omitempty"`

	// Latitude used by ArangoSearchAnalyzerTypeGeoPoint.
	Latitude []string `json:"latitude,omitempty"`

	// Longitude used by ArangoSearchAnalyzerTypeGeoPoint.
	Longitude []string `json:"longitude,omitempty"`

	// Break used by ArangoSearchAnalyzerTypeSegmentation
	Break ArangoSearchBreakType `json:"break,omitempty"`

	// Hex used by ArangoSearchAnalyzerTypeStopwords.
	// If false then each string in stopwords is used verbatim.
	// If true, then each string in stopwords needs to be hex-encoded.
	Hex *bool `json:"hex,omitempty"`

	// ModelLocation used by ArangoSearchAnalyzerTypeClassification, ArangoSearchAnalyzerTypeNearestNeighbors
	// The on-disk path to the trained fastText supervised model.
	// Note: if you are running this in an ArangoDB cluster, this model must exist on every machine in the cluster.
	ModelLocation string `json:"model_location,omitempty"`

	// TopK  used by ArangoSearchAnalyzerTypeClassification, ArangoSearchAnalyzerTypeNearestNeighbors
	// The number of class labels that will be produced per input (default: 1)
	TopK *uint64 `json:"top_k,omitempty"`

	// Threshold  used by ArangoSearchAnalyzerTypeClassification
	// The probability threshold for which a label will be assigned to an input.
	// A fastText model produces a probability per class label, and this is what will be filtered (default: 0.99).
	Threshold *float64 `json:"threshold,omitempty"`

	// Analyzer used by ArangoSearchAnalyzerTypeMinhash
	// Definition of inner analyzer to use for incoming data. In case if omitted field or empty object falls back to 'identity' analyzer.
	Analyzer *AnalyzerDefinition `json:"analyzer,omitempty"`

	// NumHashes used by ArangoSearchAnalyzerTypeMinhash
	// Size of min hash signature. Must be greater or equal to 1.
	NumHashes *uint64 `json:"numHashes,omitempty"`

	// Format is the internal binary representation to use for storing the geo-spatial data in an index.
	Format *ArangoSearchFormat `json:"format,omitempty"`

	// NGramSize used by ArangoSearchAnalyzerTypeWildcard
	// It is an unsigned integer for the n-gram length, needs to be at least 2.
	// It can be greater than the substrings between wildcards that you want to search for, e.g. 4 with an expected
	// search pattern of %up%if%ref% (substrings of length 2 and 3 between %), but this leads to a slower search
	// (for ref% with post-validation using the ICU regular expression engine).
	// A value of 3 is a good default, 2 is better for short strings
	NGramSize uint `json:"ngramSize"`
}

type ArangoSearchAnalyzerType string

type ArangoSearchBreakType string

type ArangoSearchCaseType string

type ArangoSearchConsolidationPolicy struct {
	// Type returns the type of the ConsolidationPolicy. This interface can then be casted to the corresponding ArangoSearchConsolidationPolicy* struct.
	Type ArangoSearchConsolidationPolicyType `json:"type,omitempty"`

	ArangoSearchConsolidationPolicyBytesAccum
	ArangoSearchConsolidationPolicyTier
}

type ArangoSearchConsolidationPolicyBytesAccum struct {
	// Threshold, see ArangoSearchConsolidationTypeBytesAccum
	Threshold *float64 `json:"threshold,omitempty"`
}

type ArangoSearchConsolidationPolicyTier struct {
	MinScore *int64 `json:"minScore,omitempty"`

	// MinSegments specifies the minimum number of segments that will be evaluated as candidates for consolidation.
	MinSegments *int64 `json:"segmentsMin,omitempty"`

	// MaxSegments specifies the maximum number of segments that will be evaluated as candidates for consolidation.
	MaxSegments *int64 `json:"segmentsMax,omitempty"`

	// SegmentsBytesMax specifies the maxinum allowed size of all consolidated segments in bytes.
	SegmentsBytesMax *int64 `json:"segmentsBytesMax,omitempty"`

	// SegmentsBytesFloor defines the value (in bytes) to treat all smaller segments as equal for consolidation selection.
	SegmentsBytesFloor *int64 `json:"segmentsBytesFloor,omitempty"`
}

type ArangoSearchConsolidationPolicyType string

type ArangoSearchEdgeNGram struct {
	// Min used by Text
	Min *int64 `json:"min,omitempty"`

	// Max used by Text
	Max *int64 `json:"max,omitempty"`

	// PreserveOriginal used by Text
	PreserveOriginal *bool `json:"preserveOriginal,omitempty"`
}

type ArangoSearchElementProperties struct {
	AnalyzerDefinitions []AnalyzerDefinition `json:"analyzerDefinitions,omitempty"`

	// The list of analyzers to be used for indexing of string values. Defaults to ["identify"].
	Analyzers []string `json:"analyzers,omitempty"`

	// If set to true, all fields of this element will be indexed. Defaults to false.
	IncludeAllFields *bool `json:"includeAllFields,omitempty"`

	// If set to true, values in a listed are treated as separate values. Defaults to false.
	TrackListPositions *bool `json:"trackListPositions,omitempty"`

	// This values specifies how the view should track values.
	StoreValues ArangoSearchStoreValues `json:"storeValues,omitempty"`

	// Fields contains the properties for individual fields of the element.
	// The key of the map are field names.
	Fields ArangoSearchFields `json:"fields,omitempty"`

	// If set to true, then no exclusive lock is used on the source collection during View index creation,
	// so that it remains basically available. inBackground is an option that can be set when adding links.
	// It does not get persisted as it is not a View property, but only a one-off option
	InBackground *bool `json:"inBackground,omitempty"`

	// Nested contains the properties for nested fields (sub-objects) of the element
	// Enterprise Edition only
	Nested ArangoSearchFields `json:"nested,omitempty"`

	// Cache If you enable this option, then field normalization values are always cached in memory.
	// Introduced in v3.9.5, Enterprise Edition only
	Cache *bool `json:"cache,omitempty"`
}

type ArangoSearchFeature string

type ArangoSearchFields map[string]ArangoSearchElementProperties

type ArangoSearchFormat string

type ArangoSearchLinks map[string]ArangoSearchElementProperties

type ArangoSearchNGramStreamType string

type ArangoSearchPrimarySortEntry struct {
	Field     string `json:"field,omitempty"`
	Ascending *bool  `json:"asc,omitempty"`
}

type ArangoSearchStoreValues string

type ArangoSearchView interface {
	// View Includes generic View functions
	View

	// Properties fetches extended information about the view.
	Properties(ctx context.Context) (ArangoSearchViewProperties, error)

	// SetProperties Changes all properties of a View by replacing them.
	SetProperties(ctx context.Context, options ArangoSearchViewProperties) error

	// UpdateProperties Partially changes the properties of a View by updating the specified attributes.
	UpdateProperties(ctx context.Context, options ArangoSearchViewProperties) error
}

type ArangoSearchViewAlias interface {
	// View Includes generic View functions
	View

	// Properties fetches extended information about the view.
	Properties(ctx context.Context) (ArangoSearchAliasViewProperties, error)

	// SetProperties Replaces the list of indexes of a search-alias View.
	SetProperties(ctx context.Context, options ArangoSearchAliasViewProperties) error

	// UpdateProperties Updates the list of indexes of a search-alias View.
	UpdateProperties(ctx context.Context, options ArangoSearchAliasUpdateOpts) error
}

type ArangoSearchViewProperties struct {
	ViewBase

	// CleanupIntervalStep Wait at least this many commits between removing unused files in the ArangoSearch data
	// directory (default: 2, to disable use: 0). For the case where the consolidation policies merge segments
	// often (i.e. a lot of commit+consolidate), a lower value causes a lot of disk space to be wasted.
	// For the case where the consolidation policies rarely merge segments (i.e. few inserts/deletes),
	// a higher value impacts performance without any added benefits.
	//
	// Background: With every “commit” or “consolidate” operation, a new state of the View’s internal data structures
	// is created on disk. Old states/snapshots are released once there are no longer any users remaining.
	// However, the files for the released states/snapshots are left on disk, and only removed by “cleanup” operation.
	CleanupIntervalStep *int64 `json:"cleanupIntervalStep,omitempty"`

	// ConsolidationInterval specifies the minimum number of milliseconds that must be waited
	// between committing index data changes and making them visible to queries.
	// Defaults to 60000.
	// Use 0 to disable.
	// For the case where there are a lot of inserts/updates, a lower value,
	// until commit, will cause the index not to account for them and memory usage
	// would continue to grow.
	// For the case where there are a few inserts/updates, a higher value will
	// impact performance and waste disk space for each commit call without
	// any added benefits.
	ConsolidationInterval *int64 `json:"consolidationIntervalMsec,omitempty"`

	// ConsolidationPolicy specifies thresholds for consolidation.
	ConsolidationPolicy *ArangoSearchConsolidationPolicy `json:"consolidationPolicy,omitempty"`

	// CommitInterval ArangoSearch waits at least this many milliseconds between committing view data store changes and making documents visible to queries
	CommitInterval *int64 `json:"commitIntervalMsec,omitempty"`

	// WriteBufferIdle specifies the maximum number of writers (segments) cached in the pool.
	// 0 value turns off caching, default value is 64.
	WriteBufferIdle *int64 `json:"writebufferIdle,omitempty"`

	// WriteBufferActive specifies the maximum number of concurrent active writers (segments) performs (a transaction).
	// Other writers (segments) are wait till current active writers (segments) finish.
	// 0 value turns off this limit and used by default.
	WriteBufferActive *int64 `json:"writebufferActive,omitempty"`

	// WriteBufferSizeMax specifies maximum memory byte size per writer (segment) before a writer (segment) flush is triggered.
	// 0 value turns off this limit fon any writer (buffer) and will be flushed only after a period defined for special thread during ArangoDB server startup.
	// 0 value should be used with carefully due to high potential memory consumption.
	WriteBufferSizeMax *int64 `json:"writebufferSizeMax,omitempty"`

	// Links contains the properties for how individual collections
	// are indexed in the view.
	// The key of the map are collection names.
	Links ArangoSearchLinks `json:"links,omitempty"`

	// OptimizeTopK is an array of strings defining optimized sort expressions.
	// Introduced in v3.11.0, Enterprise Edition only.
	OptimizeTopK []string `json:"optimizeTopK,omitempty"`

	// PrimarySort describes how individual fields are sorted
	PrimarySort []ArangoSearchPrimarySortEntry `json:"primarySort,omitempty"`

	// PrimarySortCompression Defines how to compress the primary sort data (introduced in v3.7.1).
	// ArangoDB v3.5 and v3.6 always compress the index using LZ4. This option is immutable.
	PrimarySortCompression PrimarySortCompression `json:"primarySortCompression,omitempty"`

	// PrimarySortCache If you enable this option, then the primary sort columns are always cached in memory.
	// Can't be changed after creating View.
	// Introduced in v3.9.5, Enterprise Edition only
	PrimarySortCache *bool `json:"primarySortCache,omitempty"`

	// PrimaryKeyCache If you enable this option, then the primary key columns are always cached in memory.
	// Introduced in v3.9.6, Enterprise Edition only
	// Can't be changed after creating View.
	PrimaryKeyCache *bool `json:"primaryKeyCache,omitempty"`

	// StoredValues An array of objects to describe which document attributes to store in the View index (introduced in v3.7.1).
	// It can then cover search queries, which means the data can be taken from the index directly and accessing the storage engine can be avoided.
	// This option is immutable.
	StoredValues []StoredValue `json:"storedValues,omitempty"`
}

type AsyncJobDeleteOptions struct {
	// JobID The id of the job to delete. Works only if type is set to 'single'.
	JobID string `json:"id,omitempty"`

	// Stamp A Unix timestamp specifying the expiration threshold for when the type is set to 'expired'.
	Stamp time.Time `json:"stamp,omitempty"`
}

type AsyncJobDeleteType string

type AsyncJobListOptions struct {
	// Count The maximum number of ids to return per call.
	// If not specified, a server-defined maximum value will be used.
	Count int `json:"count,omitempty"`
}

type AsyncJobStatusType string

type BackupCreateOptions struct {
	// The label for this backup.
	// The label is used together with a timestamp string create a unique backup identifier, <timestamp>_<label>.
	// Default: If omitted or empty, a UUID will be generated.
	Label string `json:"label,omitempty"`

	// The time in seconds that the operation tries to get a consistent snapshot. The default is 120 seconds.
	Timeout *uint `json:"timeout,omitempty"`

	// If set to `true` and no global transaction lock can be acquired within the
	// given timeout, a possibly inconsistent backup is taken.
	AllowInconsistent *bool `json:"allowInconsistent,omitempty"`

	// (Enterprise Edition cluster only.) If set to `true` and no global transaction lock can be acquired within the
	// given timeout, all running transactions are forcefully aborted to ensure that a consistent backup can be created.
	Force *bool `json:"force,omitempty"`
}

type BackupListOptions struct {
	// Set to receive info about specific single backup
	ID string `json:"id,omitempty"`
}

type BackupMeta struct {
	BackupResponse

	Version               string             `json:"version,omitempty"`
	Available             bool               `json:"available,omitempty"`
	NumberOfPiecesPresent uint               `json:"nrPiecesPresent,omitempty"`
	Keys                  []BackupMetaSha256 `json:"keys,omitempty"`
}

type BackupMetaSha256 struct {
	SHA256 string `json:"sha256"`
}

type BackupResponse struct {
	ID                      string    `json:"id,omitempty"`
	PotentiallyInconsistent bool      `json:"potentiallyInconsistent,omitempty"`
	NumberOfFiles           uint      `json:"nrFiles,omitempty"`
	NumberOfDBServers       uint      `json:"nrDBServers,omitempty"`
	SizeInBytes             uint64    `json:"sizeInBytes,omitempty"`
	CreationTime            time.Time `json:"datetime,omitempty"`
}

type BackupRestoreResponse struct {
	Previous string `json:"previous,omitempty"`
}

type BackupTransferProgressResponse struct {
	BackupID  string                          `json:"BackupId,omitempty"`
	Cancelled bool                            `json:"Cancelled,omitempty"`
	Timestamp string                          `json:"Timestamp,omitempty"`
	DBServers map[string]BackupTransferReport `json:"DBServers,omitempty"`
}

type BackupTransferReport struct {
	Status       BackupTransferStatus `json:"Status,omitempty"`
	Error        int                  `json:"Error,omitempty"`
	ErrorMessage string               `json:"ErrorMessage,omitempty"`
	Progress     struct {
		Total     int    `json:"Total,omitempty"`
		Done      int    `json:"Done,omitempty"`
		Timestamp string `json:"Timestamp,omitempty"`
	} `json:"Progress,omitempty"`
}

type BackupTransferStatus string

type BeginTransactionOptions struct {
	// Set this to true to allow the Coordinator to ask any shard replica for the data, not only the shard leader.
	// This may result in “dirty reads”.
	AllowDirtyReads *bool `json:"-"`

	// Allow reading from undeclared collections.
	AllowImplicit bool `json:"allowImplicit,omitempty"`

	// An optional numeric value that can be used to set a timeout in seconds for waiting on collection locks.
	// This option is only meaningful when using exclusive locks. If not specified, a default value will be used.
	// Setting lockTimeout to 0 will make ArangoDB not time out waiting for a lock.
	LockTimeout float64 `json:"lockTimeout,omitempty"`

	// Transaction size limit in bytes.
	MaxTransactionSize uint64 `json:"maxTransactionSize,omitempty"`

	// Whether to disable fast locking for write operations.
	//
	// Skipping the fast lock round can be faster overall if there are many concurrent Stream Transactions queued that
	// all try to lock the same collection exclusively. It avoids deadlocking and retrying which can occur with the fast
	// locking by guaranteeing a deterministic locking order at the expense of each actual locking operation taking longer.
	//
	// Fast locking should not be skipped for read-only Stream Transactions because it degrades performance if there
	// are no concurrent transactions that use exclusive locks on the same collection.
	SkipFastLockRound bool `json:"skipFastLockRound,omitempty"`

	// An optional boolean flag that, if set, will force the transaction to write all data to disk before returning.
	WaitForSync bool `json:"waitForSync,omitempty"`

	LockTimeoutDuration time.Duration `json:"-"`
}

type CacheRespObject struct {
	// BindVars are the bind variables used in the query.
	BindVars map[string]interface{} `json:"bindVars,omitempty"`
	// DataSources is a list of data sources used in the query.
	DataSources *[]string `json:"dataSources,omitempty"`
	// Hash is the plan cache key.
	Hash *string `json:"hash,omitempty"`
	// Hits is the number of times the cached plan has been utilized so far.
	Hits *uint32 `json:"hits,omitempty"`
	// Query is the AQL query string.
	Query *string `json:"query,omitempty"`
}

type Client interface {
	// Connection returns current Driver Connection
	Connection() connection.Connection

	Requests

	ClientDatabase
	ClientUsers
	ClientServerInfo
	ClientAdmin
	ClientAsyncJob
	ClientFoxx
	ClientTasks
}

type ClientAdmin interface {
	ClientAdminLog
	ClientAdminBackup
	ClientAdminLicense
	ClientAdminCluster

	// ServerMode returns the current mode in which the server/cluster is operating.
	// This call needs ArangoDB 3.3 and up.
	ServerMode(ctx context.Context) (ServerMode, error)

	// SetServerMode changes the current mode in which the server/cluster is operating.
	// This call needs a client that uses JWT authentication.
	// This call needs ArangoDB 3.3 and up.
	SetServerMode(ctx context.Context, mode ServerMode) error

	// CheckAvailability checks if the particular server is available.
	// Use ClientAdminCluster.Health() to fetch the Endpoint list.
	// For ActiveFailover, it will return an error (503 code) if the server is not the leader.
	CheckAvailability(ctx context.Context, serverEndpoint string) error
}

type ClientAdminBackup interface {
	// BackupCreate creates a new backup and returns its id
	BackupCreate(ctx context.Context, opt *BackupCreateOptions) (BackupResponse, error)

	// BackupRestore restores the backup with given id
	BackupRestore(ctx context.Context, id string) (BackupRestoreResponse, error)

	// BackupDelete deletes the backup with given id
	BackupDelete(ctx context.Context, id string) error

	// BackupList returns meta data about some/all backups available
	BackupList(ctx context.Context, opt *BackupListOptions) (ListBackupsResponse, error)

	// BackupUpload triggers an upload of backup into the remote repository using the given config
	BackupUpload(ctx context.Context, backupId string, remoteRepository string, config interface{}) (TransferMonitor, error)

	// BackupDownload triggers a download of backup into the remote repository using the given config
	BackupDownload(ctx context.Context, backupId string, remoteRepository string, config interface{}) (TransferMonitor, error)

	TransferMonitor(jobId string, transferType TransferType) (TransferMonitor, error)
}

type ClientAdminCluster interface {
	// Health returns the cluster configuration & health. Not available in single server deployments (403 Forbidden).
	Health(ctx context.Context) (ClusterHealth, error)

	// DatabaseInventory the inventory of the cluster collections (with entire details) from a specific database.
	DatabaseInventory(ctx context.Context, dbName string) (DatabaseInventory, error)

	// MoveShard moves a single shard of the given collection between `fromServer` and `toServer`.
	MoveShard(ctx context.Context, col Collection, shard ShardID, fromServer, toServer ServerID) (string, error)

	// CleanOutServer triggers activities to clean out a DBServer.
	CleanOutServer(ctx context.Context, serverID ServerID) (string, error)

	// ResignServer triggers activities to let a DBServer resign for all shards.
	ResignServer(ctx context.Context, serverID ServerID) (string, error)

	// NumberOfServers returns the number of coordinators & dbServers in a clusters and the ID's of cleanedOut servers.
	NumberOfServers(ctx context.Context) (NumberOfServersResponse, error)

	// IsCleanedOut checks if the dbServer with given ID has been cleaned out.
	IsCleanedOut(ctx context.Context, serverID ServerID) (bool, error)

	// RemoveServer is a low-level option to remove a server from a cluster.
	// This function is suitable for servers of type coordinator or dbServer.
	// The use of `ClientServerAdmin.Shutdown` is highly recommended above this function.
	RemoveServer(ctx context.Context, serverID ServerID) error
}

type ClientAdminLicense interface {
	// GetLicense returns license of an ArangoDB deployment.
	GetLicense(ctx context.Context) (License, error)

	// SetLicense Set a new license for an Enterprise Edition instance.
	// Can be called on single servers, Coordinators, and DB-Servers.
	SetLicense(ctx context.Context, license string, force bool) error
}

type ClientAdminLog interface {
	// GetLogLevels returns log levels for topics.
	GetLogLevels(ctx context.Context, opts *LogLevelsGetOptions) (LogLevels, error)

	// SetLogLevels sets log levels for a given topics.
	SetLogLevels(ctx context.Context, logLevels LogLevels, opts *LogLevelsSetOptions) error
}

type ClientAsyncJob interface {
	// AsyncJobList Returns the ids of job results with a specific status
	AsyncJobList(ctx context.Context, jobType AsyncJobStatusType, opts *AsyncJobListOptions) ([]string, error)
	// AsyncJobStatus Returns the status of a specific job
	AsyncJobStatus(ctx context.Context, jobID string) (AsyncJobStatusType, error)
	// AsyncJobCancel Cancels a specific async job
	AsyncJobCancel(ctx context.Context, jobID string) (bool, error)
	// AsyncJobDelete Deletes async job result
	AsyncJobDelete(ctx context.Context, deleteType AsyncJobDeleteType, opts *AsyncJobDeleteOptions) (bool, error)
}

type ClientDatabase interface {
	// GetDatabase opens a connection to an existing database.
	// If no database with given name exists, an NotFoundError is returned.
	GetDatabase(ctx context.Context, name string, options *GetDatabaseOptions) (Database, error)

	// DatabaseExists returns true if a database with given name exists.
	DatabaseExists(ctx context.Context, name string) (bool, error)

	// Databases returns a list of all databases found by the client.
	Databases(ctx context.Context) ([]Database, error)

	// AccessibleDatabases returns a list of all databases that can be accessed by the authenticated user.
	AccessibleDatabases(ctx context.Context) ([]Database, error)

	// CreateDatabase creates a new database with given name and opens a connection to it.
	// If the a database with given name already exists, a DuplicateError is returned.
	CreateDatabase(ctx context.Context, name string, options *CreateDatabaseOptions) (Database, error)
}

type ClientFoxx interface {
	ClientFoxxService
}

type ClientFoxxService interface {
	// InstallFoxxService installs a new service at a given mount path.
	InstallFoxxService(ctx context.Context, dbName string, zipFile string, options *FoxxDeploymentOptions) error
	// UninstallFoxxService uninstalls service at a given mount path.
	UninstallFoxxService(ctx context.Context, dbName string, options *FoxxDeleteOptions) error
	// ListInstalledFoxxServices retrieves the list of Foxx services installed in the specified database.
	// If excludeSystem is true, system services (like _admin/aardvark) will be excluded from the result,
	// returning only custom-installed Foxx services.
	ListInstalledFoxxServices(ctx context.Context, dbName string, excludeSystem *bool) ([]FoxxServiceListItem, error)
	// GetInstalledFoxxService retrieves detailed information about a specific Foxx service
	// installed in the specified database.
	// The service is identified by its mount path, which must be provided and non-empty.
	// If the mount path is missing or empty, a RequiredFieldError is returned.
	// The returned FoxxServiceObject contains the full metadata and configuration details
	// for the specified service.
	GetInstalledFoxxService(ctx context.Context, dbName string, mount *string) (FoxxServiceObject, error)
	// ReplaceFoxxService removes the service at the given mount path from the database and file system
	// and installs the given new service at the same mount path.
	ReplaceFoxxService(ctx context.Context, dbName string, zipFile string, opts *FoxxDeploymentOptions) error
	// UpgradeFoxxService installs the given new service on top of the service currently installed
	// at the specified mount path, retaining the existing service’s configuration and dependencies.
	// This should be used only when upgrading to a newer or equivalent version of the same service.
	UpgradeFoxxService(ctx context.Context, dbName string, zipFile string, opts *FoxxDeploymentOptions) error
	// GetFoxxServiceConfiguration retrieves the configuration values for the Foxx service
	// mounted at the specified path in the given database.
	// The mount parameter must not be nil or empty.
	// Returns a map containing the current configuration key-value pairs.
	GetFoxxServiceConfiguration(ctx context.Context, dbName string, mount *string) (map[string]interface{}, error)
	// UpdateFoxxServiceConfiguration updates the configuration of a specific Foxx service.
	// If the Foxx service does not allow a particular configuration key, it will appear
	// in the response warnings.
	// The caller is responsible for validating allowed keys before calling this method.
	UpdateFoxxServiceConfiguration(ctx context.Context, dbName string, mount *string, opt map[string]interface{}) (map[string]interface{}, error)
	// ReplaceFoxxServiceConfiguration replaces the given Foxx service's dependencies entirely.
	// If the Foxx service does not allow a particular configuration key, it will appear
	// in the response warnings.
	// The caller is responsible for validating allowed keys before calling this method.
	ReplaceFoxxServiceConfiguration(ctx context.Context, dbName string, mount *string, opt map[string]interface{}) (map[string]interface{}, error)

	// GetFoxxServiceDependencies retrieves the configured dependencies for a specific Foxx service.
	// Returns:
	// A map where each key is a dependency name and the value is an object containing:
	// 	* title: Human-readable title of the dependency
	//  * mount: Current mount path of the dependency service (if set)
	// An error if the request fails or the mount is missing.
	GetFoxxServiceDependencies(ctx context.Context, dbName string, mount *string) (map[string]interface{}, error)
	// UpdateFoxxServiceDependencies updates the configured dependencies of a specific Foxx service.
	// If the Foxx service does not allow a particular dependency key, it will appear
	// in the "warnings" field of the response.
	// The caller is responsible for ensuring that only allowed dependency keys are provided.
	UpdateFoxxServiceDependencies(ctx context.Context, dbName string, mount *string, opt map[string]interface{}) (map[string]interface{}, error)
	// ReplaceFoxxServiceDependencies replaces the given Foxx service's dependencies entirely.
	// If the Foxx service does not allow a particular dependency key, it will appear
	// in the "warnings" field of the response.
	// The caller is responsible for validating allowed keys before calling this method.
	ReplaceFoxxServiceDependencies(ctx context.Context, dbName string, mount *string, opt map[string]interface{}) (map[string]interface{}, error)
	// GetFoxxServiceScripts retrieves the scripts associated with a specific Foxx service.
	GetFoxxServiceScripts(ctx context.Context, dbName string, mount *string) (map[string]interface{}, error)
	// RunFoxxServiceScript executes a specific script associated with a Foxx service.
	RunFoxxServiceScript(ctx context.Context, dbName string, name string, mount *string, body map[string]interface{}) (map[string]interface{}, error)
	// RunFoxxServiceTests executes the test suite of a specific Foxx service
	// deployed in an ArangoDB database.
	RunFoxxServiceTests(ctx context.Context, dbName string, opt FoxxTestOptions) (map[string]interface{}, error)
	// EnableDevelopmentMode enables the development mode for a specific Foxx service.
	// Development mode causes the Foxx service to be reloaded from the filesystem and its setup
	// script (if present) to be re-executed every time the service handles a request.
	EnableDevelopmentMode(ctx context.Context, dbName string, mount *string) (map[string]interface{}, error)
	// DisableDevelopmentMode disables the development mode for a specific Foxx service.
	DisableDevelopmentMode(ctx context.Context, dbName string, mount *string) (map[string]interface{}, error)
	// GetFoxxServiceReadme retrieves the README file for a specific Foxx service.
	GetFoxxServiceReadme(ctx context.Context, dbName string, mount *string) ([]byte, error)
	// GetFoxxServiceSwagger retrieves the Swagger specification
	// for a specific Foxx service mounted in the given database.
	GetFoxxServiceSwagger(ctx context.Context, dbName string, mount *string) (SwaggerResponse, error)
	// CommitFoxxService commits the local Foxx service state of the Coordinator
	// to the database. This can resolve service conflicts between Coordinators.
	CommitFoxxService(ctx context.Context, dbName string, replace *bool) error
	// DownloadFoxxServiceBundle downloads a zip bundle of the Foxx service directory
	// from the specified database and mount point.
	// Note: The response is the raw zip data (binary).
	DownloadFoxxServiceBundle(ctx context.Context, dbName string, mount *string) ([]byte, error)
}

type ClientServerInfo interface {
	// Version returns version information from the connected database server.
	Version(ctx context.Context) (VersionInfo, error)

	// VersionWithOptions returns version information from the connected database server.
	VersionWithOptions(ctx context.Context, opts *GetVersionOptions) (VersionInfo, error)

	// ServerRole returns the role of the server that answers the request.
	ServerRole(ctx context.Context) (ServerRole, error)

	// ServerID Gets the ID of this server in the cluster.
	// An error is returned when calling this to a server that is not part of a cluster.
	ServerID(ctx context.Context) (string, error)
}

type ClientTasks interface {
	// Task retrieves an existing task by its ID.
	// If no task with the given ID exists, a NotFoundError is returned.
	Task(ctx context.Context, databaseName string, id string) (Task, error)

	// Tasks returns a list of all tasks on the server.
	Tasks(ctx context.Context, databaseName string) ([]Task, error)

	// CreateTask creates a new task with the specified options.
	CreateTask(ctx context.Context, databaseName string, options TaskOptions) (Task, error)

	// If a task with the given ID already exists, a Conflict error is returned.
	CreateTaskWithID(ctx context.Context, databaseName string, id string, options TaskOptions) (Task, error)

	// RemoveTask deletes an existing task by its ID.
	RemoveTask(ctx context.Context, databaseName string, id string) error
}

type ClientUsers interface {
	// User opens a connection to an existing user.
	// If no user with given name exists, an NotFoundError is returned.
	User(ctx context.Context, name string) (User, error)

	// UserExists returns true if a user with a given name exists.
	UserExists(ctx context.Context, name string) (bool, error)

	// Users return a list of all users found by the client.
	Users(ctx context.Context) ([]User, error)

	// CreateUser creates a new user with a given name and opens a connection to it.
	// If a user with a given name already exists, a Conflict error is returned.
	CreateUser(ctx context.Context, name string, options *UserOptions) (User, error)

	// ReplaceUser Replaces the data of an existing user.
	ReplaceUser(ctx context.Context, name string, options *UserOptions) (User, error)

	// UpdateUser Partially modifies the data of an existing user
	UpdateUser(ctx context.Context, name string, options *UserOptions) (User, error)

	// RemoveUser removes an existing user.
	RemoveUser(ctx context.Context, name string) error
}

type ClusterHealth struct {
	// Unique identifier of the entire cluster.
	// This ID is created when the cluster was first created.
	ID string `json:"ClusterId"`

	// Health per server
	Health map[ServerID]ServerHealth `json:"Health"`
}

type Collection interface {
	Name() string
	Database() Database

	// Shards fetches shards information of the collection.
	Shards(ctx context.Context, details bool) (CollectionShards, error)

	// Remove removes the entire collection.
	// If the collection does not exist, a NotFoundError is returned.
	Remove(ctx context.Context) error

	// RemoveWithOptions removes the entire collection.
	// If the collection does not exist, a NotFoundError is returned.
	RemoveWithOptions(ctx context.Context, opts *RemoveCollectionOptions) error

	// Truncate removes all documents from the collection, but leaves the indexes intact.
	Truncate(ctx context.Context) error

	// Properties fetches extended information about the collection.
	Properties(ctx context.Context) (CollectionProperties, error)

	// SetProperties allows modifying collection parameters
	SetPropertiesV2(ctx context.Context, options SetCollectionPropertiesOptionsV2) error

	// Count fetches the number of document in the collection.
	Count(ctx context.Context) (int64, error)

	// Statistics returns the number of documents and additional statistical information about the collection.
	Statistics(ctx context.Context, details bool) (CollectionFigures, error)

	// Revision fetches the revision ID of the collection.
	// The revision ID is a server-generated string that clients can use to check whether data
	// in a collection has changed since the last revision check.
	Revision(ctx context.Context) (CollectionProperties, error)

	// Checksum returns a checksum for the specified collection
	// withRevisions - Whether to include document revision ids in the checksum calculation.
	// withData - Whether to include document body data in the checksum calculation.
	Checksum(ctx context.Context, withRevisions *bool, withData *bool) (CollectionChecksum, error)

	// ResponsibleShard returns the shard responsible for the given options.
	ResponsibleShard(ctx context.Context, options map[string]interface{}) (string, error)

	// LoadIndexesIntoMemory loads all indexes of the collection into memory.
	LoadIndexesIntoMemory(ctx context.Context) (bool, error)

	// Renaming collections is not supported in cluster deployments.
	// Renaming collections is only supported in single server deployments.
	Rename(ctx context.Context, req RenameCollectionRequest) (CollectionInfo, error)

	// RecalculateCount recalculates the count of documents in the collection.
	RecalculateCount(ctx context.Context) (bool, *int64, error)

	//Compacts the data of a collection in order to reclaim disk space.
	// This operation is only supported in single server deployments.
	// In cluster deployments, the compaction is done automatically by the server.
	Compact(ctx context.Context) (CollectionInfo, error)

	CollectionDocuments
	CollectionIndexes
}

type CollectionChecksum struct {
	CollectionInfo
	// The collection revision id as a string.
	Revision string `json:"revision,omitempty"`
}

type CollectionDocumentCreate interface {

	// CreateDocument creates a single document in the collection.
	// The document data is loaded from the given document, the document metadata is returned.
	// If the document data already contains a `_key` field, this will be used as key of the new document,
	// otherwise a unique key is created.
	// A ConflictError is returned when a `_key` field contains a duplicate key, other any other field violates an index constraint.
	// SmartGraphs and EnterpriseGraphs cannot use existing collections and cannot use the document interface
	CreateDocument(ctx context.Context, document interface{}) (CollectionDocumentCreateResponse, error)

	// CreateDocumentWithOptions creates a single document in the collection.
	// The document data is loaded from the given document, the document metadata is returned.
	// If the document data already contains a `_key` field, this will be used as key of the new document,
	// otherwise a unique key is created.
	// A ConflictError is returned when a `_key` field contains a duplicate key, other any other field violates an index constraint.
	// SmartGraphs and EnterpriseGraphs cannot use existing collections and cannot use the document interface
	CreateDocumentWithOptions(ctx context.Context, document interface{}, options *CollectionDocumentCreateOptions) (CollectionDocumentCreateResponse, error)

	// CreateDocuments creates multiple documents in the collection.
	// The document data is loaded from the given documents slice, the documents metadata is returned.
	// If a document element already contains a `_key` field, this will be used as key of the new document,
	// otherwise a unique key is created.
	// If a document element contains a `_key` field with a duplicate key, or any other field that violates an index constraint,
	// then the ConflictError for a specific document will be returned only while reading from CollectionDocumentCreateResponseReader
	// and not as the error output of this function.
	// If the create request itself fails or one of the arguments is invalid, an error is returned.
	// SmartGraphs and EnterpriseGraphs cannot use existing collections and cannot use the document interface
	CreateDocuments(ctx context.Context, documents interface{}) (CollectionDocumentCreateResponseReader, error)

	// CreateDocumentsWithOptions creates multiple documents in the collection.
	// The document data is loaded from the given documents slice, the documents metadata is returned.
	// If a document element already contains a `_key` field, this will be used as key of the new document,
	// otherwise a unique key is created.
	// If a document element contains a `_key` field with a duplicate key, or any other field that violates an index constraint,
	// then the ConflictError for a specific document will be returned only while reading from CollectionDocumentCreateResponseReader
	// and not as the error output of this function.
	// If the create request itself fails or one of the arguments is invalid, an error is returned.
	// SmartGraphs and EnterpriseGraphs cannot use existing collections and cannot use the document interface
	CreateDocumentsWithOptions(ctx context.Context, documents interface{}, opts *CollectionDocumentCreateOptions) (CollectionDocumentCreateResponseReader, error)
}

type CollectionDocumentCreateOptions struct {
	// Wait until document has been synced to disk.
	WithWaitForSync *bool

	// If set to true, the insert becomes a replace-insert.
	// If a document with the same _key already exists,
	// the new document is not rejected with unique constraint violation error but replaces the old document.
	// Note that operations with overwrite parameter require a _key attribute in the request payload,
	// therefore they can only be performed on collections sharded by _key.
	Overwrite *bool

	// This option supersedes `overwrite` option.
	OverwriteMode *CollectionDocumentCreateOverwriteMode

	// If set to true, an empty object is returned as response if the document operation succeeds.
	// No meta-data is returned for the created document. If the operation raises an error, an error object is returned.
	// You can use this option to save network traffic.
	Silent *bool

	// Additionally return the complete new document
	NewObject interface{}

	// Additionally return the complete old document under the attribute.
	// Only available if the overwrite option is used.
	OldObject interface{}

	// RefillIndexCaches if set to true then refills the in-memory index caches.
	RefillIndexCaches *bool

	// If the intention is to delete existing attributes with the update-insert command, set it to false.
	// This modifies the behavior of the patch command to remove top-level attributes and sub-attributes from
	// the existing document that are contained in the patch document with an attribute value of null
	// (but not attributes of objects that are nested inside of arrays).
	// This option controls the update-insert behavior only (CollectionDocumentCreateOverwriteModeUpdate).
	KeepNull *bool

	// Controls whether objects (not arrays) are merged if present in both, the existing and the update-insert document.
	// If set to false, the value in the patch document overwrites the existing document’s value.
	// If set to true, objects are merged. The default is true. This option controls the update-insert behavior only.
	// This option controls the update-insert behavior only (CollectionDocumentCreateOverwriteModeUpdate).
	MergeObjects *bool

	// By default, or if this is set to true, the _rev attributes in the given document are ignored.
	// If this is set to false, then the _rev attribute given in the body document is taken as a precondition.
	// The document is only removed if the current revision is the one specified.
	// This works only with multiple documents removal method CollectionDocumentDelete.DeleteDocumentsWithOptions
	IgnoreRevs *bool

	// IsRestore is used to make insert functions use the "isRestore=<value>" setting.
	// Note: This option is intended for internal (replication) use.
	// It is NOT intended to be used by normal client. Use on your own risk!
	IsRestore *bool

	// Specify any top-level attribute to compare whether the version number is higher
	// than the currently stored one when updating or replacing documents.
	//
	// Only applicable if `Overwrite` is set to `true` or `OverwriteMode` is set to `update` or `replace`.
	VersionAttribute string

	// To make this operation a part of a Stream Transaction, set this header to the transaction ID returned by the
	// DatabaseTransaction.BeginTransaction() method.
	TransactionID string
}

type CollectionDocumentCreateOverwriteMode string

type CollectionDocumentCreateResponse struct {
	DocumentMeta
	shared.ResponseStruct `json:",inline"`
	Old, New              interface{}
}

type CollectionDocumentCreateResponseReader interface {
	Read() (CollectionDocumentCreateResponse, error)
}

type CollectionDocumentDelete interface {
	// DeleteDocument removes a single document with given key from the collection.
	// The document metadata is returned.
	// If no document exists with given key, a NotFoundError is returned.
	// SmartGraphs and EnterpriseGraphs cannot use existing collections and cannot use the document interface
	DeleteDocument(ctx context.Context, key string) (CollectionDocumentDeleteResponse, error)

	// DeleteDocumentWithOptions removes a single document with given key from the collection.
	// The document metadata is returned.
	// If no document exists with given key, a NotFoundError is returned.
	// SmartGraphs and EnterpriseGraphs cannot use existing collections and cannot use the document interface
	DeleteDocumentWithOptions(ctx context.Context, key string, opts *CollectionDocumentDeleteOptions) (CollectionDocumentDeleteResponse, error)

	// DeleteDocuments removes multiple documents with given keys from the collection.
	// The document metadata are returned.
	// If no document exists with a given key, a NotFoundError is returned at its errors index.
	// SmartGraphs and EnterpriseGraphs cannot use existing collections and cannot use the document interface
	DeleteDocuments(ctx context.Context, keys []string) (CollectionDocumentDeleteResponseReader, error)

	// DeleteDocumentsWithOptions removes multiple documents with given keys from the collection.
	// The document metadata are returned.
	// If no document exists with a given key, a NotFoundError is returned at its errors index.
	// 'documents' must be a slice of structs with a `_key` field or a slice of keys.
	// SmartGraphs and EnterpriseGraphs cannot use existing collections and cannot use the document interface
	DeleteDocumentsWithOptions(ctx context.Context, documents interface{}, opts *CollectionDocumentDeleteOptions) (CollectionDocumentDeleteResponseReader, error)
}

type CollectionDocumentDeleteOptions struct {
	// Conditionally delete a document based on a target revision id
	// IMPORTANT: This will work only for single document delete operations (CollectionDocumentDelete.DeleteDocument,
	// CollectionDocumentDelete.DeleteDocumentWithOptions)
	IfMatch string

	// By default, or if this is set to true, the _rev attributes in the given document are ignored.
	// If this is set to false, then the _rev attribute given in the body document is taken as a precondition.
	// The document is only removed if the current revision is the one specified.
	// This works only with multiple documents removal method CollectionDocumentDelete.DeleteDocumentsWithOptions
	IgnoreRevs *bool

	// Wait until the deletion operation has been synced to disk.
	WithWaitForSync *bool

	// Return additionally the complete previous revision of the changed document
	OldObject interface{}

	// If set to true, an empty object is returned as response if the document operation succeeds.
	// No meta-data is returned for the deleted document. If the operation raises an error, an error object is returned.
	// You can use this option to save network traffic.
	Silent *bool

	// RefillIndexCaches if set to true then refills the in-memory index caches.
	RefillIndexCaches *bool

	// To make this operation a part of a Stream Transaction, set this header to the transaction ID returned by the
	// DatabaseTransaction.BeginTransaction() method.
	TransactionID string
}

type CollectionDocumentDeleteResponse struct {
	DocumentMeta          `json:",inline"`
	shared.ResponseStruct `json:",inline"`
	Old                   interface{} `json:"old,omitempty"`
}

type CollectionDocumentDeleteResponseReader interface {
	Read(i interface{}) (CollectionDocumentDeleteResponse, error)
}

type CollectionDocumentImport interface {

	// ImportDocuments imports one or more documents into the collection.
	// The document data is loaded from the given documents argument, statistics are returned.
	// The documents argument can be one of the following:
	// - An array of structs: All structs will be imported as individual documents.
	// - An array of maps: All maps will be imported as individual documents.
	// To wait until all documents have been synced to disk, prepare a context with `WithWaitForSync`.
	// To return details about documents that could not be imported, prepare a context with `WithImportDetails`.
	ImportDocuments(ctx context.Context, documents string, documentsType CollectionDocumentImportDocumentType) (CollectionDocumentImportResponse, error)
	ImportDocumentsWithOptions(ctx context.Context, documents string, documentsType CollectionDocumentImportDocumentType, options *CollectionDocumentImportOptions) (CollectionDocumentImportResponse, error)
}

type CollectionDocumentImportDocumentType string

type CollectionDocumentImportOnDuplicate string

type CollectionDocumentImportOptions struct {
	// FromPrefix is an optional prefix for the values in _from attributes. If specified, the value is automatically
	// prepended to each _from input value. This allows specifying just the keys for _from.
	FromPrefix *string `json:"fromPrefix,omitempty"`
	// ToPrefix is an optional prefix for the values in _to attributes. If specified, the value is automatically
	// prepended to each _to input value. This allows specifying just the keys for _to.
	ToPrefix *string `json:"toPrefix,omitempty"`
	// Overwrite is a flag that if set, then all data in the collection will be removed prior to the import.
	// Note that any existing index definitions will be preseved.
	Overwrite *bool `json:"overwrite,omitempty"`
	// OnDuplicate controls what action is carried out in case of a unique key constraint violation.
	// Possible values are:
	// - ImportOnDuplicateError
	// - ImportOnDuplicateUpdate
	// - ImportOnDuplicateReplace
	// - ImportOnDuplicateIgnore
	OnDuplicate *CollectionDocumentImportOnDuplicate `json:"onDuplicate,omitempty"`
	// Complete is a flag that if set, will make the whole import fail if any error occurs.
	// Otherwise the import will continue even if some documents cannot be imported.
	Complete *bool `json:"complete,omitempty"`

	// Wait until the deletion operation has been synced to disk.
	WithWaitForSync *bool
}

type CollectionDocumentImportRequest struct {
	CollectionDocumentImportOptions `json:",inline"`
	Collection                      *string                               `json:"collection,inline"`
	Type                            *CollectionDocumentImportDocumentType `json:"type,inline"`
}

type CollectionDocumentImportResponse struct {
	CollectionDocumentImportStatistics `json:",inline"`
}

type CollectionDocumentImportStatistics struct {
	// Created holds the number of documents imported.
	Created int64 `json:"created,omitempty"`
	// Errors holds the number of documents that were not imported due to an error.
	Errors int64 `json:"errors,omitempty"`
	// Empty holds the number of empty lines found in the input (will only contain a value greater zero for types documents or auto).
	Empty int64 `json:"empty,omitempty"`
	// Updated holds the number of updated/replaced documents (in case onDuplicate was set to either update or replace).
	Updated int64 `json:"updated,omitempty"`
	// Ignored holds the number of failed but ignored insert operations (in case onDuplicate was set to ignore).
	Ignored int64 `json:"ignored,omitempty"`
	// if query parameter details is set to true, the result will contain a details attribute which is an array
	// with more detailed information about which documents could not be inserted.
	Details []string
}

type CollectionDocumentRead interface {
	// ReadDocument reads a single document with given key from the collection.
	// The document data is stored into result, the document metadata is returned.
	// If no document exists with given key, a NotFoundError is returned.
	// SmartGraphs and EnterpriseGraphs cannot use existing collections and cannot use the document interface
	ReadDocument(ctx context.Context, key string, result interface{}) (DocumentMeta, error)

	// ReadDocumentWithOptions reads a single document with given key from the collection.
	// The document data is stored into result, the document metadata is returned.
	// If no document exists with given key, a NotFoundError is returned.
	// SmartGraphs and EnterpriseGraphs cannot use existing collections and cannot use the document interface
	ReadDocumentWithOptions(ctx context.Context, key string, result interface{}, opts *CollectionDocumentReadOptions) (DocumentMeta, error)

	// ReadDocuments reads multiple documents with given keys from the collection.
	// The documents data is stored into elements of the given results slice,
	// the documents metadata is returned.
	// If no document exists with a given key, a NotFoundError is returned at its errors index.
	// SmartGraphs and EnterpriseGraphs cannot use existing collections and cannot use the document interface
	ReadDocuments(ctx context.Context, keys []string) (CollectionDocumentReadResponseReader, error)

	// ReadDocumentsWithOptions reads multiple documents with given keys from the collection.
	// The documents data is stored into elements of the given results slice and the documents metadata is returned.
	// If no document exists with a given key, a NotFoundError is returned at its errors index.
	// 'documents' must be a slice of structs with a `_key` field or a slice of keys.
	// SmartGraphs and EnterpriseGraphs cannot use existing collections and cannot use the document interface
	ReadDocumentsWithOptions(ctx context.Context, documents interface{}, opts *CollectionDocumentReadOptions) (CollectionDocumentReadResponseReader, error)
}

type CollectionDocumentReadOptions struct {
	// If the “If-Match” header is given, then it must contain exactly one ETag (_rev).
	// The document is returned, if it has the same revision as the given ETag
	// IMPORTANT: This will work only for single document read operations (CollectionDocumentRead.ReadDocument,
	// CollectionDocumentRead.ReadDocumentWithOptions)
	IfMatch string

	// If the “If-None-Match” header is given, then it must contain exactly one ETag (_rev).
	// The document is returned, if it has a different revision than the given ETag
	// IMPORTANT: This will work only for single document read operations (CollectionDocumentRead.ReadDocument,
	// CollectionDocumentRead.ReadDocumentWithOptions)
	IfNoneMatch string

	// By default, or if this is set to true, the _rev attributes in the given document is ignored.
	// If this is set to false, then the _rev attribute given in the body document is taken as a precondition.
	// The document is only removed if the current revision is the one specified.
	// This works only with multiple documents removal method CollectionDocumentRead.ReadDocumentsWithOptions
	IgnoreRevs *bool

	// Set this to true to allow the Coordinator to ask any shard replica for the data, not only the shard leader.
	// This may result in “dirty reads”.
	// This option is ignored if this operation is part of a DatabaseTransaction (TransactionID option).
	// The header set when creating the transaction decides about dirty reads for the entire transaction,
	// not the individual read operations.
	AllowDirtyReads *bool

	// To make this operation a part of a Stream Transaction, set this header to the transaction ID returned by the
	// DatabaseTransaction.BeginTransaction() method.
	TransactionID string
}

type CollectionDocumentReadResponse struct {
	DocumentMeta          `json:",inline"`
	shared.ResponseStruct `json:",inline"`
}

type CollectionDocumentReadResponseReader interface {
	Read(i interface{}) (CollectionDocumentReadResponse, error)
}

type CollectionDocumentReplace interface {

	// ReplaceDocument replaces a single document with given key in the collection.
	// If no document exists with given key, a NotFoundError is returned.
	// If `_id` field is present in the document body, it is always ignored.
	// SmartGraphs and EnterpriseGraphs cannot use existing collections and cannot use the document interface
	ReplaceDocument(ctx context.Context, key string, document interface{}) (CollectionDocumentReplaceResponse, error)

	// ReplaceDocumentWithOptions replaces a single document with given key in the collection.
	// If no document exists with given key, a NotFoundError is returned.
	// If `_id` field is present in the document body, it is always ignored.
	// SmartGraphs and EnterpriseGraphs cannot use existing collections and cannot use the document interface
	ReplaceDocumentWithOptions(ctx context.Context, key string, document interface{}, options *CollectionDocumentReplaceOptions) (CollectionDocumentReplaceResponse, error)

	// ReplaceDocuments replaces multiple document with given keys in the collection.
	// The replaces are loaded from the given replaces slice, the documents metadata are returned.
	// If no document exists with a given key, a NotFoundError is returned at its errors index.
	// Each element in the replaces slice must contain a `_key` field.
	// If `_id` field is present in the document body, it is always ignored.
	// SmartGraphs and EnterpriseGraphs cannot use existing collections and cannot use the document interface
	ReplaceDocuments(ctx context.Context, documents interface{}) (CollectionDocumentReplaceResponseReader, error)

	// ReplaceDocumentsWithOptions replaces multiple document with given keys in the collection.
	// The replaces are loaded from the given replaces slice, the documents metadata are returned.
	// If no document exists with a given key, a NotFoundError is returned at its errors index.
	// Each element in the replaces slice must contain a `_key` field.
	// If `_id` field is present in the document body, it is always ignored.
	// SmartGraphs and EnterpriseGraphs cannot use existing collections and cannot use the document interface
	ReplaceDocumentsWithOptions(ctx context.Context, documents interface{}, opts *CollectionDocumentReplaceOptions) (CollectionDocumentReplaceResponseReader, error)
}

type CollectionDocumentReplaceOptions struct {
	// Conditionally replace a document based on a target revision id
	// IMPORTANT: This will work only for single document replace operations (CollectionDocumentReplace.ReplaceDocument,
	// CollectionDocumentReplace.ReplaceDocumentWithOptions)
	IfMatch string `json:"ifMatch,omitempty"`

	// By default, or if this is set to true, the _rev attributes in the given document is ignored.
	// If this is set to false, then the _rev attribute given in the body document is taken as a precondition.
	// The document is only replaced if the current revision is the one specified.
	IgnoreRevs *bool

	// Wait until document has been synced to disk.
	WithWaitForSync *bool

	// If set to true, an empty object is returned as response if the document operation succeeds.
	// No meta-data is returned for the created document. If the operation raises an error, an error object is returned.
	// You can use this option to save network traffic.
	Silent *bool

	// Additionally return the complete new document
	NewObject interface{}

	// Additionally return the complete old document under the attribute.
	// Only available if the overwrite option is used.
	OldObject interface{}

	// RefillIndexCaches if set to true then refills the in-memory index caches.
	RefillIndexCaches *bool

	// IsRestore is used to make insert functions use the "isRestore=<value>" setting.
	// Note: This option is intended for internal (replication) use.
	// It is NOT intended to be used by normal client. Use on your own risk!
	IsRestore *bool

	// Specify any top-level attribute to compare whether the version number is higher
	// than the currently stored one when updating or replacing documents.
	VersionAttribute string

	// To make this operation a part of a Stream Transaction, set this header to the transaction ID returned by the
	// DatabaseTransaction.BeginTransaction() method.
	TransactionID string
}

type CollectionDocumentReplaceResponse struct {
	DocumentMetaWithOldRev
	shared.ResponseStruct `json:",inline"`
	Old, New              interface{}
}

type CollectionDocumentReplaceResponseReader interface {
	Read() (CollectionDocumentReplaceResponse, error)
}

type CollectionDocumentUpdate interface {
	// UpdateDocument updates a single document with a given key in the collection.
	// The document metadata is returned.
	// If no document exists with a given key, a NotFoundError is returned.
	// If `_id` field is present in the document body, it is always ignored.
	// SmartGraphs and EnterpriseGraphs cannot use existing collections and cannot use the document interface
	UpdateDocument(ctx context.Context, key string, document interface{}) (CollectionDocumentUpdateResponse, error)

	// UpdateDocumentWithOptions updates a single document with a given key in the collection.
	// The document metadata is returned.
	// If no document exists with a given key, a NotFoundError is returned.
	// If `_id` field is present in the document body, it is always ignored.
	// SmartGraphs and EnterpriseGraphs cannot use existing collections and cannot use the document interface
	UpdateDocumentWithOptions(ctx context.Context, key string, document interface{}, options *CollectionDocumentUpdateOptions) (CollectionDocumentUpdateResponse, error)

	// UpdateDocuments updates multiple documents
	// The updates are loaded from the given updates slice, the documents metadata are returned.
	// If no document exists with a given key, a NotFoundError is returned at its errors index.
	// Each element in the update slice must contain a `_key` field.
	// If `_id` field is present in the document body, it is always ignored.
	// SmartGraphs and EnterpriseGraphs cannot use existing collections and cannot use the document interface
	UpdateDocuments(ctx context.Context, documents interface{}) (CollectionDocumentUpdateResponseReader, error)

	// UpdateDocumentsWithOptions updates multiple documents
	// The updates are loaded from the given updates slice, the documents metadata are returned.
	// If no document exists with a given key, a NotFoundError is returned at its errors index.
	// Each element in the update slice must contain a `_key` field.
	// If `_id` field is present in the document body, it is always ignored.
	// SmartGraphs and EnterpriseGraphs cannot use existing collections and cannot use the document interface
	UpdateDocumentsWithOptions(ctx context.Context, documents interface{}, opts *CollectionDocumentUpdateOptions) (CollectionDocumentUpdateResponseReader, error)
}

type CollectionDocumentUpdateOptions struct {
	// Conditionally update a document based on a target revision id
	// IMPORTANT: This will work only for single document updates operations (CollectionDocumentUpdate.UpdateDocument,
	// CollectionDocumentUpdate.UpdateDocumentWithOptions)
	IfMatch string

	// By default, or if this is set to true, the _rev attributes in the given document is ignored.
	// If this is set to false, then the _rev attribute given in the body document is taken as a precondition.
	// The document is only updated if the current revision is the one specified.
	IgnoreRevs *bool

	// Wait until document has been synced to disk.
	WithWaitForSync *bool

	// If set to true, an empty object is returned as response if the document operation succeeds.
	// No meta-data is returned for the created document. If the operation raises an error, an error object is returned.
	// You can use this option to save network traffic.
	Silent *bool

	// Additionally return the complete new document
	NewObject interface{}

	// Additionally return the complete old document under the attribute.
	// Only available if the overwrite option is used.
	OldObject interface{}

	// RefillIndexCaches if set to true then refills the in-memory index caches.
	RefillIndexCaches *bool

	// If the intention is to delete existing attributes with the update-insert command, set it to false.
	// This modifies the behavior of the patch command to remove top-level attributes and sub-attributes from
	// the existing document that are contained in the patch document with an attribute value of null
	// (but not attributes of objects that are nested inside of arrays).
	// This option controls the update-insert behavior only.
	KeepNull *bool

	// Controls whether objects (not arrays) are merged if present in both, the existing and the update-insert document.
	// If set to false, the value in the patch document overwrites the existing document’s value.
	// If set to true, objects are merged. The default is true. This option controls the update-insert behavior only.
	MergeObjects *bool

	// Specify any top-level attribute to compare whether the version number is higher
	// than the currently stored one when updating or replacing documents.
	VersionAttribute string

	// To make this operation a part of a Stream Transaction, set this header to the transaction ID returned by the
	// DatabaseTransaction.BeginTransaction() method.
	TransactionID string
}

type CollectionDocumentUpdateResponse struct {
	DocumentMetaWithOldRev
	shared.ResponseStruct `json:",inline"`
	Old, New              interface{}
}

type CollectionDocumentUpdateResponseReader interface {
	Read() (CollectionDocumentUpdateResponse, error)
}

type CollectionDocuments interface {
	// DocumentExists checks if a document with given key exists in the collection.
	DocumentExists(ctx context.Context, key string) (bool, error)

	CollectionDocumentCreate
	CollectionDocumentRead
	CollectionDocumentUpdate
	CollectionDocumentReplace
	CollectionDocumentDelete

	CollectionDocumentImport
}

type CollectionExtendedInfo struct {
	CollectionInfo

	// CacheEnabled set cacheEnabled option in collection properties.
	CacheEnabled bool `json:"cacheEnabled,omitempty"`

	KeyOptions struct {
		// Type specifies the type of the key generator. The currently available generators are traditional and autoincrement.
		Type KeyGeneratorType `json:"type,omitempty"`

		// AllowUserKeys; if set to true, then it is allowed to supply own key values in the _key attribute of a document.
		// If set to false, then the key generator is solely responsible for generating keys and supplying own key values in
		// the _key attribute of documents is considered an error.
		AllowUserKeys bool `json:"allowUserKeys,omitempty"`
		// The initial value for the key generator. This is only used for autoincrement key generators.
		LastValue *uint64 `json:"lastValue,omitempty"`
	} `json:"keyOptions,omitempty"`

	// NumberOfShards is the number of shards of the collection.
	// Only available in cluster setup.
	NumberOfShards int `json:"numberOfShards,omitempty"`

	// This attribute specifies the name of the sharding strategy to use for the collection.
	// Can not be changed after creation.
	ShardingStrategy ShardingStrategy `json:"shardingStrategy,omitempty"`

	// ShardKeys contains the names of document attributes that are used to determine the target shard for documents.
	// Only available in cluster setup.
	ShardKeys []string `json:"shardKeys,omitempty"`

	// ReplicationFactor contains how many copies of each shard are kept on different DBServers.
	// Only available in cluster setup.
	ReplicationFactor ReplicationFactor `json:"replicationFactor,omitempty"`

	// WaitForSync; If true then creating, changing or removing documents will wait
	// until the data has been synchronized to disk.
	WaitForSync bool `json:"waitForSync,omitempty"`

	// WriteConcern contains how many copies must be available before a collection can be written.
	// It is required that 1 <= WriteConcern <= ReplicationFactor.
	// Default is 1. Not available for SatelliteCollections.
	// Available from 3.6 arangod version.
	WriteConcern int `json:"writeConcern,omitempty"`

	// Available from 3.9 ArangoD version.
	InternalValidatorType int `json:"internalValidatorType,omitempty"`

	// IsDisjoint set isDisjoint flag for Graph. Required ArangoDB 3.7+
	IsDisjoint bool `json:"isDisjoint,omitempty"`

	// Available from 3.7 ArangoD version.
	IsSmartChild bool `json:"isSmartChild,omitempty"`

	// Set to create a smart edge or vertex collection.
	// This requires ArangoDB Enterprise Edition.
	IsSmart bool `json:"isSmart,omitempty"`

	// ComputedValues let configure collections to generate document attributes when documents are created or modified, using an AQL expression
	ComputedValues []ComputedValue `json:"computedValues,omitempty"`
}

type CollectionFigures struct {
	CollectionProperties
	CollectionStatistics
}

type CollectionIndexes interface {
	// Index opens a connection to an existing index within the collection.
	// If no index with given name exists, an NotFoundError is returned.
	Index(ctx context.Context, name string) (IndexResponse, error)

	// IndexExists returns true if an index with given name exists within the collection.
	IndexExists(ctx context.Context, name string) (bool, error)

	// Indexes returns a list of all indexes in the collection.
	Indexes(ctx context.Context) ([]IndexResponse, error)

	// EnsurePersistentIndex creates a persistent index in the collection, if it does not already exist.
	// Fields is a slice of attribute paths.
	// The index is returned, together with a boolean indicating if the index was newly created (true) or pre-existing (false).
	// NOTE: 'hash' and 'skiplist' being mere aliases for the persistent index type nowadays
	EnsurePersistentIndex(ctx context.Context, fields []string, options *CreatePersistentIndexOptions) (IndexResponse, bool, error)

	// EnsureGeoIndex creates a hash index in the collection, if it does not already exist.
	// Fields is a slice with one or two attribute paths. If it is a slice with one attribute path location,
	// then a geo-spatial index on all documents is created using location as path to the coordinates.
	// The value of the attribute must be a slice with at least two double values. The slice must contain the latitude (first value)
	// and the longitude (second value). All documents, which do not have the attribute path or with value that are not suitable, are ignored.
	// If it is a slice with two attribute paths latitude and longitude, then a geo-spatial index on all documents is created
	// using latitude and longitude as paths the latitude and the longitude. The value of the attribute latitude and of the
	// attribute longitude must a double. All documents, which do not have the attribute paths or which values are not suitable, are ignored.
	// The index is returned, together with a boolean indicating if the index was newly created (true) or pre-existing (false).
	EnsureGeoIndex(ctx context.Context, fields []string, options *CreateGeoIndexOptions) (IndexResponse, bool, error)

	// EnsureTTLIndex creates a TLL collection, if it does not already exist.
	// expireAfter is the time interval (in seconds) from the point in time stored in the fields attribute after which the documents count as expired.
	// Can be set to 0 to let documents expire as soon as the server time passes the point in time stored in the document attribute, or to a higher number to delay the expiration.
	// fields The index is returned, together with a boolean indicating if the index was newly created (true) or pre-existing (false).
	EnsureTTLIndex(ctx context.Context, fields []string, expireAfter int, options *CreateTTLIndexOptions) (IndexResponse, bool, error)

	// EnsureMDIIndex creates a multidimensional index for the collection, if it does not already exist.
	// The index is returned, together with a boolean indicating if the index was newly created (true) or pre-existing (false).
	// Available in ArangoDB 3.12 and later.
	EnsureMDIIndex(ctx context.Context, fields []string, options *CreateMDIIndexOptions) (IndexResponse, bool, error)

	// EnsureMDIPrefixedIndex creates is an additional index variant of mdi index that lets you specify additional
	// attributes for the index to narrow down the search space using equality checks.
	// Available in ArangoDB 3.12 and later.
	EnsureMDIPrefixedIndex(ctx context.Context, fields []string, options *CreateMDIPrefixedIndexOptions) (IndexResponse, bool, error)

	// EnsureInvertedIndex creates an inverted index in the collection, if it does not already exist.
	// The index is returned, together with a boolean indicating if the index was newly created (true) or pre-existing (false).
	// Available in ArangoDB 3.10 and later.
	// InvertedIndexOptions is an obligatory parameter and must contain at least `Fields` field
	EnsureInvertedIndex(ctx context.Context, options *InvertedIndexOptions) (IndexResponse, bool, error)

	// DeleteIndex deletes an index from the collection.
	DeleteIndex(ctx context.Context, name string) error

	// DeleteIndexByID deletes an index from the collection.
	DeleteIndexByID(ctx context.Context, id string) error
}

type CollectionInfo struct {
	// The identifier of the collection.
	ID string `json:"id,omitempty"`

	// The name of the collection.
	Name string `json:"name,omitempty"`

	// The status of the collection
	Status CollectionStatus `json:"status,omitempty"`

	// StatusString represents status as a string.
	StatusString string `json:"statusString,omitempty"`

	// The type of the collection
	Type CollectionType `json:"type,omitempty"`

	// If true then the collection is a system collection.
	IsSystem bool `json:"isSystem,omitempty"`

	// Global unique name for the collection
	GloballyUniqueId string `json:"globallyUniqueId,omitempty"`
}

type CollectionKeyOptions struct {
	// If set to true, then it is allowed to supply own key values in the _key attribute of a document.
	// If set to false, then the key generator will solely be responsible for generating keys and supplying own
	// key values in the _key attribute of documents is considered an error.
	// If set to true, then it is allowed to supply own key values in the _key attribute of a document.
	// If set to false, then the key generator will solely be responsible for generating keys and supplying own
	// key values in the _key attribute of documents is considered an error.
	AllowUserKeysPtr *bool `json:"allowUserKeys,omitempty"`
	// Specifies the type of the key generator. The currently available generators are traditional and autoincrement.
	Type KeyGeneratorType `json:"type,omitempty"`
	// increment value for autoincrement key generator. Not used for other key generator types.
	Increment int `json:"increment,omitempty"`
	// Initial offset value for autoincrement key generator. Not used for other key generator types.
	Offset int `json:"offset,omitempty"`
}

type CollectionProperties struct {
	CollectionExtendedInfo

	// JournalSize is the maximal size setting for journals / datafiles in bytes.
	JournalSize int64 `json:"journalSize,omitempty"`

	// SmartJoinAttribute
	// See documentation for SmartJoins.
	// This requires ArangoDB Enterprise Edition.
	SmartJoinAttribute string `json:"smartJoinAttribute,omitempty"`

	// This field must be set to the attribute that will be used for sharding or SmartGraphs.
	// All vertices are required to have this attribute set. Edges derive the attribute from their connected vertices.
	// This requires ArangoDB Enterprise Edition.
	SmartGraphAttribute string `json:"smartGraphAttribute,omitempty"`

	// This attribute specifies that the sharding of a collection follows that of another
	// one.
	DistributeShardsLike string `json:"distributeShardsLike,omitempty"`

	// This attribute specifies if the new format introduced in 3.7 is used for this
	// collection.
	UsesRevisionsAsDocumentIds bool `json:"usesRevisionsAsDocumentIds,omitempty"`

	// The following attribute specifies if the new MerkleTree based sync protocol
	// can be used on the collection.
	SyncByRevision bool `json:"syncByRevision,omitempty"`

	// Schema for collection validation
	Schema *CollectionSchemaOptions `json:"schema,omitempty"`

	// The collection revision id as a string.
	Revision string `json:"revision,omitempty"`
}

type CollectionSchemaLevel string

type CollectionSchemaOptions struct {
	Rule    interface{}           `json:"rule,omitempty"`
	Level   CollectionSchemaLevel `json:"level,omitempty"`
	Message string                `json:"message,omitempty"`
}

type CollectionShards struct {
	CollectionExtendedInfo

	// Shards is a list of shards that belong to the collection.
	// Each shard contains a list of DB servers where the first one is the leader and the rest are followers.
	Shards map[ShardID][]ServerID `json:"shards,omitempty"`
}

type CollectionStatistics struct {
	//The number of documents currently present in the collection.
	Count int64 `json:"count,omitempty"`

	// The maximal size of a journal or datafile in bytes.
	JournalSize int64 `json:"journalSize,omitempty"`

	Figures struct {
		DataFiles struct {
			// The number of datafiles.
			Count int64 `json:"count,omitempty"`

			// The total filesize of datafiles (in bytes).
			FileSize int64 `json:"fileSize,omitempty"`
		} `json:"datafiles"`

		// The number of markers in the write-ahead log for this collection that have not been transferred to journals or datafiles.
		UncollectedLogfileEntries int64 `json:"uncollectedLogfileEntries,omitempty"`

		// The number of references to documents in datafiles that JavaScript code currently holds. This information can be used for debugging compaction and unload issues.
		DocumentReferences int64 `json:"documentReferences,omitempty"`

		CompactionStatus struct {
			// The action that was performed when the compaction was last run for the collection. This information can be used for debugging compaction issues.
			Message string `json:"message,omitempty"`

			// The point in time the compaction for the collection was last executed. This information can be used for debugging compaction issues.
			Time time.Time `json:"time,omitempty"`
		} `json:"compactionStatus"`

		Compactors struct {
			// The number of compactor files.
			Count int64 `json:"count,omitempty"`

			// The total filesize of all compactor files (in bytes).
			FileSize int64 `json:"fileSize,omitempty"`
		} `json:"compactors"`

		Dead struct {
			// The number of dead documents. This includes document versions that have been deleted or replaced by a newer version. Documents deleted or replaced that are contained the write-ahead log only are not reported in this figure.
			Count int64 `json:"count,omitempty"`

			// The total number of deletion markers. Deletion markers only contained in the write-ahead log are not reporting in this figure.
			Deletion int64 `json:"deletion,omitempty"`

			// The total size in bytes used by all dead documents.
			Size int64 `json:"size,omitempty"`
		} `json:"dead"`

		Indexes struct {
			// The total number of indexes defined for the collection, including the pre-defined indexes (e.g. primary index).
			Count int64 `json:"count,omitempty"`

			// The total memory allocated for indexes in bytes.
			Size int64 `json:"size,omitempty"`
		} `json:"indexes"`

		ReadCache struct {
			// The number of revisions of this collection stored in the document revisions cache.
			Count int64 `json:"count,omitempty"`

			// The memory used for storing the revisions of this collection in the document revisions cache (in bytes). This figure does not include the document data but only mappings from document revision ids to cache entry locations.
			Size int64 `json:"size,omitempty"`
		} `json:"readcache"`

		// An optional string value that contains information about which object type is at the head of the collection's cleanup queue. This information can be used for debugging compaction and unload issues.
		WaitingFor string `json:"waitingFor,omitempty"`

		Alive struct {
			// The number of currently active documents in all datafiles and journals of the collection. Documents that are contained in the write-ahead log only are not reported in this figure.
			Count int64 `json:"count,omitempty"`

			// The total size in bytes used by all active documents of the collection. Documents that are contained in the write-ahead log only are not reported in this figure.
			Size int64 `json:"size,omitempty"`
		} `json:"alive"`

		// The tick of the last marker that was stored in a journal of the collection. This might be 0 if the collection does not yet have a journal.
		LastTick int64 `json:"lastTick,omitempty"`

		Journals struct {
			// The number of journal files.
			Count int64 `json:"count,omitempty"`

			// The total filesize of all journal files (in bytes).
			FileSize int64 `json:"fileSize,omitempty"`
		} `json:"journals"`

		Revisions struct {
			// The number of revisions of this collection managed by the storage engine.
			Count int64 `json:"count,omitempty"`

			// The memory used for storing the revisions of this collection in the storage engine (in bytes). This figure does not include the document data but only mappings from document revision ids to storage engine datafile positions.
			Size int64 `json:"size,omitempty"`
		} `json:"revisions"`

		DocumentsSize int64 `json:"documentsSize,omitempty"`

		// RocksDB cache statistics
		CacheInUse *bool  `json:"cacheInUse,omitempty"`
		CacheSize  *int64 `json:"cacheSize,omitempty"`
		CacheUsage *int64 `json:"cacheUsage,omitempty"`
	} `json:"figures"`
}

type CollectionStatus int

type CollectionType int

type CommitTransactionOptions struct{}

type CommonFoxxServiceFields struct {
	// Mount is the mount path of the Foxx service in the database (e.g., "/my-service").
	// This determines the URL path at which the service can be accessed.
	Mount *string `json:"mount"`

	// Development indicates whether the service is in development mode.
	// When true, the service is not cached and changes are applied immediately.
	Development *bool `json:"development"`

	// Legacy indicates whether the service uses a legacy format or API.
	// This may be used for backward compatibility checks.
	Legacy *bool `json:"legacy"`
	// Name is the name of the Foxx service (optional).
	// This may be defined in the service manifest (manifest.json).
	Name *string `json:"name,omitempty"`

	// Version is the version of the Foxx service (optional).
	// This is useful for managing service upgrades or deployments.
	Version *string `json:"version,omitempty"`
}

type ComputeOn string

type ComputedValue struct {
	//  The name of the target attribute. Can only be a top-level attribute, but you
	//   may return a nested object. Cannot be `_key`, `_id`, `_rev`, `_from`, `_to`,
	//   or a shard key attribute.
	Name string `json:"name"`

	// An AQL `RETURN` operation with an expression that computes the desired value.
	Expression string `json:"expression"`

	// An array of strings to define on which write operations the value shall be
	// computed. The possible values are `"insert"`, `"update"`, and `"replace"`.
	// The default is `["insert", "update", "replace"]`.
	ComputeOn []ComputeOn `json:"computeOn,omitempty"`

	// Whether the computed value shall take precedence over a user-provided or existing attribute.
	Overwrite bool `json:"overwrite"`

	// Whether to let the write operation fail if the expression produces a warning. The default is false.
	FailOnWarning *bool `json:"failOnWarning,omitempty"`

	// Whether the result of the expression shall be stored if it evaluates to `null`.
	// This can be used to skip the value computation if any pre-conditions are not met.
	KeepNull *bool `json:"keepNull,omitempty"`
}

type ConsolidationPolicy struct {
	// Type returns the type of the ConsolidationPolicy. This interface can then be casted to the corresponding ConsolidationPolicy struct.
	Type ConsolidationPolicyType `json:"type,omitempty"`

	ConsolidationPolicyBytesAccum
	ConsolidationPolicyTier
}

type ConsolidationPolicyBytesAccum struct {
	// Threshold, see ConsolidationTypeBytesAccum
	Threshold *float64 `json:"threshold,omitempty"`
}

type ConsolidationPolicyTier struct {
	// MinScore Filter out consolidation candidates with a score less than this. Default: 0
	MinScore *int64 `json:"minScore,omitempty"`

	// SegmentsMin The minimum number of segments that are evaluated as candidates for consolidation. Default: 1
	SegmentsMin *int64 `json:"segmentsMin,omitempty"`

	// SegmentsMax The maximum number of segments that are evaluated as candidates for consolidation. Default: 10
	SegmentsMax *int64 `json:"segmentsMax,omitempty"`

	// SegmentsBytesMax  The maximum allowed size of all consolidated segments in bytes. Default: 5368709120
	SegmentsBytesMax *int64 `json:"segmentsBytesMax,omitempty"`

	// SegmentsBytesFloor Defines the value (in bytes) to treat all smaller segments as equal for consolidation selection. Default: 2097152
	SegmentsBytesFloor *int64 `json:"segmentsBytesFloor,omitempty"`
}

type ConsolidationPolicyType string

type Contributor struct {
	// Name is the contributor's name.
	Name *string `json:"name,omitempty"`

	// Email is the contributor's contact email.
	Email *string `json:"email,omitempty"`
}

type CreateCollectionOptions struct {
	// EnforceReplicationFactor the default is true, which means the server checks if there are enough replicas available
	// at creation time and bail out otherwise. Set it to false to disable this extra check.
	EnforceReplicationFactor *bool
}

type CreateCollectionPropertiesV2 struct {
	// CacheEnabled set cacheEnabled option in collection properties
	CacheEnabled *bool `json:"cacheEnabled,omitempty"`
	// This field is used for internal purposes only. DO NOT USE.
	DistributeShardsLike *string `json:"distributeShardsLike,omitempty"`
	// DoCompact checks if the collection will be compacted (default is true)
	DoCompact *bool `json:"doCompact,omitempty"`
	// The number of buckets into which indexes using a hash table are split. The default is 16 and this number has to be a power
	// of 2 and less than or equal to 1024. For very large collections one should increase this to avoid long pauses when the hash
	// table has to be initially built or resized, since buckets are resized individually and can be initially built in parallel.
	// For example, 64 might be a sensible value for a collection with 100 000 000 documents.
	// Currently, only the edge index respects this value, but other index types might follow in future ArangoDB versions.
	// Changes are applied when the collection is loaded the next time.
	IndexBuckets *int `json:"indexBuckets,omitempty"`
	// Available from 3.9 ArangoD version.
	InternalValidatorType *int `json:"internalValidatorType,omitempty"`
	// IsDisjoint set isDisjoint flag for Graph. Required ArangoDB 3.7+
	IsDisjoint *bool `json:"isDisjoint,omitempty"`
	// Set to create a smart edge or vertex collection.
	// This requires ArangoDB Enterprise Edition.
	IsSmart *bool `json:"isSmart,omitempty"`
	// If true, create a system collection. In this case collection-name should start with an underscore.
	// End users should normally create non-system collections only. API implementors may be required to create system
	// collections in very special occasions, but normally a regular collection will do. (The default is false)
	IsSystem *bool `json:"isSystem,omitempty"`
	// If true then the collection data is kept in-memory only and not made persistent.
	// Unloading the collection will cause the collection data to be discarded. Stopping or re-starting the server will also
	// cause full loss of data in the collection. Setting this option will make the resulting collection be slightly faster
	// than regular collections because ArangoDB does not enforce any synchronization to disk and does not calculate any
	// CRC checksums for datafiles (as there are no datafiles). This option should therefore be used for cache-type collections only,
	// and not for data that cannot be re-created otherwise. (The default is false)
	IsVolatile *bool `json:"isVolatile,omitempty"`
	// The maximal size of a journal or datafile in bytes. The value must be at least 1048576 (1 MiB). (The default is a configuration parameter)
	JournalSize *int64 `json:"journalSize,omitempty"`
	// Specifies how keys in the collection are created.
	KeyOptions *CollectionKeyOptions `json:"keyOptions,omitempty"`
	// In a cluster, this value determines the number of shards to create for the collection. In a single server setup, this option is meaningless. (default is 1)
	NumberOfShards *int `json:"numberOfShards,omitempty"`
	// ReplicationFactor in a cluster (default is 1), this attribute determines how many copies of each shard are kept on different DBServers.
	// The value 1 means that only one copy (no synchronous replication) is kept.
	// A value of k means that k-1 replicas are kept. Any two copies reside on different DBServers.
	// Replication between them is synchronous, that is, every write operation to the "leader" copy will be replicated to all "follower" replicas,
	// before the write operation is reported successful. If a server fails, this is detected automatically
	// and one of the servers holding copies take over, usually without an error being reported.
	ReplicationFactor *ReplicationFactor `json:"replicationFactor,omitempty"`
	// Schema for collection validation
	Schema *CollectionSchemaOptions `json:"schema,omitempty"`
	// This attribute specifies the name of the sharding strategy to use for the collection.
	// Must be one of ShardingStrategy* values.
	ShardingStrategy *ShardingStrategy `json:"shardingStrategy,omitempty"`
	// In a cluster, this attribute determines which document attributes are used to
	// determine the target shard for documents. Documents are sent to shards based on the values of their shard key attributes.
	// The values of all shard key attributes in a document are hashed, and the hash value is used to determine the target shard.
	// Note: Values of shard key attributes cannot be changed once set. This option is meaningless in a single server setup.
	// The default is []string{"_key"}.
	ShardKeys *[]string `json:"shardKeys,omitempty"`
	// This field must be set to the attribute that will be used for sharding or SmartGraphs.
	// All vertices are required to have this attribute set. Edges derive the attribute from their connected vertices.
	// This requires ArangoDB Enterprise Edition.
	SmartGraphAttribute *string `json:"smartGraphAttribute,omitempty"`
	// SmartJoinAttribute
	// In the specific case that the two collections have the same number of shards, the data of the two collections can
	// be co-located on the same server for the same shard key values. In this case the extra hop via the coordinator will not be necessary.
	// See documentation for SmartJoins.
	// This requires ArangoDB Enterprise Edition.
	SmartJoinAttribute *string `json:"smartJoinAttribute,omitempty"`
	// Available from 3.7 ArangoDB version
	SyncByRevision *bool `json:"syncByRevision,omitempty"`
	// The type of the collection to create. (default is CollectionTypeDocument)
	Type *CollectionType `json:"type,omitempty"`
	// If true then the data is synchronized to disk before returning from a document create, update, replace or removal operation. (default: false)
	WaitForSync *bool `json:"waitForSync,omitempty"`
	// WriteConcern contains how many copies must be available before a collection can be written.
	// It is required that 1 <= WriteConcern <= ReplicationFactor.
	// Default is 1. Not available for SatelliteCollections.
	// Available from 3.6 ArangoDB version.
	WriteConcern *int `json:"writeConcern,omitempty"`
	// ComputedValues let configure collections to generate document attributes when documents are created or modified, using an AQL expression
	ComputedValues *[]ComputedValue `json:"computedValues,omitempty"`
}

type CreateDatabaseDefaultOptions struct {
	// Default replication factor for collections in database
	ReplicationFactor ReplicationFactor `json:"replicationFactor,omitempty"`
	// Default write concern for collections in database
	WriteConcern int `json:"writeConcern,omitempty"`
	// Default sharding for collections in database
	Sharding DatabaseSharding `json:"sharding,omitempty"`
	// Replication version to use for this database
	// Available since ArangoDB version 3.11
	ReplicationVersion DatabaseReplicationVersion `json:"replicationVersion,omitempty"`
}

type CreateDatabaseOptions struct {
	// List of users to initially create for the new database. User information will not be changed for users that already exist.
	// If users is not specified or does not contain any users, a default user root will be created with an empty string password.
	// This ensures that the new database will be accessible after it is created.
	Users []CreateDatabaseUserOptions `json:"users,omitempty"`

	// Options database defaults
	Options CreateDatabaseDefaultOptions `json:"options,omitempty"`
}

type CreateDatabaseUserOptions struct {
	// Loginname of the user to be created
	UserName string `json:"user,omitempty"`
	// The user password as a string. If not specified, it will default to an empty string.
	Password string `json:"passwd,omitempty"`
	// A flag indicating whether the user account should be activated or not. The default value is true. If set to false, the user won't be able to log into the database.
	Active *bool `json:"active,omitempty"`
	// A JSON object with extra user information. The data contained in extra will be stored for the user but not be interpreted further by ArangoDB.
	Extra interface{} `json:"extra,omitempty"`
}

type CreateEdgeDefinitionOptions struct {
	// An array of collection names that is used to create SatelliteCollections for a (Disjoint) SmartGraph
	// using SatelliteCollections (Enterprise Edition only).
	// Each array element must be a string and a valid collection name. The collection type cannot be modified later.
	Satellites []string `json:"satellites,omitempty"`
}

type CreateEdgeDefinitionResponse struct {
	shared.ResponseStruct `json:",inline"`

	// GraphDefinition contains the updated graph definition
	GraphDefinition *GraphDefinition `json:"graph,omitempty"`

	Edge
}

type CreateEdgeOptions struct {
	// Define if the request should wait until synced to disk.
	WaitForSync *bool `json:"waitForSync,omitempty"`

	// Define if the response should contain the complete new version of the document.
	NewObject interface{}

	// To make this operation a part of a Stream Transaction, set this header to the transaction ID returned by the
	// DatabaseTransaction.BeginTransaction() method.
	TransactionID string
}

type CreateGeoIndexOptions struct {
	// Name optional user defined name used for hints in AQL queries
	Name string `json:"name,omitempty"`

	// If a geo-spatial index on a location is constructed and GeoJSON is true, then the order within the array
	// is longitude followed by latitude. This corresponds to the format described in http://geojson.org/geojson-spec.html#positions
	GeoJSON *bool `json:"geoJson,omitempty"`

	// LegacyPolygons determines if the to-be-created index should use legacy polygons or not.
	// It is relevant for those that have geoJson set to true only.
	// Old geo indexes from versions from below 3.10 will always implicitly have the legacyPolygons option set to true.
	// Newly generated geo indexes from 3.10 on will have the legacyPolygons option by default set to false,
	// however, it can still be explicitly overwritten with true to create a legacy index but is not recommended.
	LegacyPolygons *bool `json:"legacyPolygons,omitempty"`

	// InBackground You can set this option to true to create the index in the background,
	// which will not write-lock the underlying collection for as long as if the index is built in the foreground.
	// The default value is false.
	InBackground *bool `json:"inBackground,omitempty"`
}

type CreateGraphOptions struct {
	// Satellites An array of collection names that is used to create SatelliteCollections for a (Disjoint) SmartGraph
	// using SatelliteCollections (Enterprise Edition only). Each array element must be a string and a valid
	// collection name. The collection type cannot be modified later.
	Satellites []string `json:"satellites,omitempty"`
}

type CreateMDIIndexOptions struct {
	// Name optional user defined name used for hints in AQL queries
	Name string `json:"name,omitempty"`

	// FieldValueTypes is required and the only allowed value is "double".
	//Future extensions of the index will allow other types.
	FieldValueTypes MDIFieldType `json:"fieldValueTypes,required"`

	// Unique if true, then create a unique index.
	Unique *bool `json:"unique,omitempty"`

	// Sparse If `true`, then create a sparse index to exclude documents from the index that do not have the defined
	// attributes or are explicitly set to `null` values. If a non-value is set, it still needs to be numeric.
	Sparse *bool `json:"sparse,omitempty"`

	// InBackground You can set this option to true to create the index in the background,
	// which will not write-lock the underlying collection for as long as if the index is built in the foreground.
	// The default value is false.
	InBackground *bool `json:"inBackground,omitempty"`

	// StoredValues The optional `storedValues` attribute can contain an array of paths to additional attributes to
	// store in the index. These additional attributes cannot be used for index lookups or for sorting, but they can
	// be used for projections. This allows an index to fully cover more queries and avoid extra document lookups.
	// The maximum number of attributes in `storedValues` is 32.
	//
	// Attributes in `storedValues` cannot overlap with attributes specified in `prefixFields` but you can have
	// the attributes in both `storedValues` and `fields`.
	StoredValues []string `json:"storedValues,omitempty"`
}

type CreateMDIPrefixedIndexOptions struct {
	CreateMDIIndexOptions `json:",inline"`

	// PrefixFields is required and contains nn array of attribute names used as search prefix.
	// Array expansions are not allowed.
	PrefixFields []string `json:"prefixFields,required"`
}

type CreatePersistentIndexOptions struct {
	// Name optional user defined name used for hints in AQL queries
	Name string `json:"name,omitempty"`

	// CacheEnabled if true, then the index will be cached in memory. Caching is turned off by default.
	CacheEnabled *bool `json:"cacheEnabled,omitempty"`

	// StoreValues if true, then the additional attributes will be included.
	// These additional attributes cannot be used for index lookups or sorts, but they can be used for projections.
	// There must be no overlap of attribute paths between `fields` and `storedValues`. The maximum number of values is 32.
	StoredValues []string `json:"storedValues,omitempty"`

	// Sparse You can control the sparsity for persistent indexes.
	// The inverted, fulltext, and geo index types are sparse by definition.
	Sparse *bool `json:"sparse,omitempty"`

	// Unique is supported by persistent indexes. By default, all user-defined indexes are non-unique.
	// Only the attributes in fields are checked for uniqueness.
	// Any attributes in from storedValues are not checked for their uniqueness.
	Unique *bool `json:"unique,omitempty"`

	// Deduplicate is supported by array indexes of type persistent. It controls whether inserting duplicate index
	// values from the same document into a unique array index will lead to a unique constraint error or not.
	// The default value is true, so only a single instance of each non-unique index value will be inserted into
	// the index per document.
	// Trying to insert a value into the index that already exists in the index will always fail,
	// regardless of the value of this attribute.
	Deduplicate *bool `json:"deduplicate,omitempty"`

	// Estimates determines if the to-be-created index should maintain selectivity estimates or not.
	// Is supported by indexes of type persistent
	// This attribute controls whether index selectivity estimates are maintained for the index.
	// Not maintaining index selectivity estimates can have a slightly positive impact on write performance.
	// The downside of turning off index selectivity estimates will be that the query optimizer will not be able
	// to determine the usefulness of different competing indexes in AQL queries when there are multiple candidate
	// indexes to choose from. The estimates attribute is optional and defaults to true if not set.
	// It will have no effect on indexes other than persistent (with hash and skiplist being mere aliases for the persistent index type nowadays).
	Estimates *bool `json:"estimates,omitempty"`

	// InBackground You can set this option to true to create the index in the background,
	// which will not write-lock the underlying collection for as long as if the index is built in the foreground.
	// The default value is false.
	InBackground *bool `json:"inBackground,omitempty"`
}

type CreateTTLIndexOptions struct {
	// Name optional user defined name used for hints in AQL queries
	Name string `json:"name,omitempty"`

	// InBackground You can set this option to true to create the index in the background,
	// which will not write-lock the underlying collection for as long as if the index is built in the foreground.
	// The default value is false.
	InBackground *bool `json:"inBackground,omitempty"`
}

type CreateVertexCollectionOptions struct {
	// Satellites contain an array of collection names that will be used to create SatelliteCollections for
	// a (Disjoint) SmartGraph using SatelliteCollections (Enterprise Edition only)
	Satellites []string `json:"satellites,omitempty"`
}

type CreateVertexCollectionResponse struct {
	shared.ResponseStruct `json:",inline"`

	// GraphDefinition contains the updated graph definition
	GraphDefinition *GraphDefinition `json:"graph,omitempty"`

	VertexCollection
}

type CreateVertexOptions struct {
	// Define if the request should wait until synced to disk.
	WaitForSync *bool `json:"waitForSync,omitempty"`

	// Define if the response should contain the complete new version of the document.
	NewObject interface{}

	// To make this operation a part of a Stream Transaction, set this header to the transaction ID returned by the
	// DatabaseTransaction.BeginTransaction() method.
	TransactionID string
}

type Cursor interface {
	io.Closer

	// CloseWithContext run Close with specified Context
	CloseWithContext(ctx context.Context) error

	// HasMore returns true if the next call to ReadDocument does not return a NoMoreDocuments error.
	HasMore() bool

	// ReadDocument reads the next document from the cursor.
	// The document data is stored into result, the document meta data is returned.
	// If the cursor has no more documents, a NoMoreDocuments error is returned.
	// Note: If the query (resulting in this cursor) does not return documents,
	//       then the returned DocumentMeta will be empty.
	ReadDocument(ctx context.Context, result interface{}) (DocumentMeta, error)

	// Count returns the total number of result documents available.
	// A valid return value is only available when the cursor has been created with `Count` and not with `Stream`.
	Count() int64

	// Statistics returns the query execution statistics for this cursor.
	// This might not be valid if the cursor has been created with `Stream`
	Statistics() CursorStats

	// Plan returns the query execution plan for this cursor.
	Plan() CursorPlan
}

type CursorBatch interface {
	io.Closer

	// CloseWithContext run Close with specified Context
	CloseWithContext(ctx context.Context) error

	// HasMoreBatches returns true if the next call to ReadNextBatch does not return a NoMoreDocuments error.
	HasMoreBatches() bool

	// ReadNextBatch reads the next batch of documents from the cursor.
	// The result must be a pointer to a slice of documents.
	// E.g. `var result []MyStruct{}`.
	ReadNextBatch(ctx context.Context, result interface{}) error

	// RetryReadBatch retries the last batch read made by ReadNextBatch.
	// The result must be a pointer to a slice of documents.
	// E.g. `var result []MyStruct{}`.
	RetryReadBatch(ctx context.Context, result interface{}) error

	// ReadNextRawBatch reads the next batch of documents from the cursor.
	// The result must be a pointer to a byte array *[]bytes.
	ReadNextRawBatch(ctx context.Context, result *connection.RawObject) error

	// RetryReadRawBatch retries the last batch read made by ReadNextRawBatch.
	// The result must be a pointer to a byte array *[]bytes.
	RetryReadRawBatch(ctx context.Context, result *connection.RawObject) error

	// Count returns the total number of result documents available.
	// A valid return value is only available when the cursor has been created with `Count` and not with `Stream`.
	Count() int64

	// Statistics returns the query execution statistics for this cursor.
	// This might not be valid if the cursor has been created with `Stream`
	Statistics() CursorStats

	// Plan returns the query execution plan for this cursor.
	Plan() CursorPlan
}

type CursorPlan struct {
	// Nodes describes a nested list of the execution plan nodes.
	Nodes []CursorPlanNodes `json:"nodes,omitempty"`
	// Rules describes a list with the names of the applied optimizer rules.
	Rules []string `json:"rules,omitempty"`
	// Collections describes list of the collections involved in the query.
	Collections []CursorPlanCollection `json:"collections,omitempty"`
	// Variables describes list of variables involved in the query.
	Variables []CursorPlanVariable `json:"variables,omitempty"`
	// EstimatedCost is an estimated cost of the query.
	EstimatedCost float64 `json:"estimatedCost,omitempty"`
	// EstimatedNrItems is an estimated number of results.
	EstimatedNrItems int `json:"estimatedNrItems,omitempty"`
	// IsModificationQuery describes whether the query contains write operations.
	IsModificationQuery bool `json:"isModificationQuery,omitempty"`
}

type CursorPlanCollection struct {
	// Name is a name of collection.
	Name string `json:"name"`
	// Type describes how the collection is used: read, write or exclusive.
	Type string `json:"type"`
}

type CursorPlanNodes map[string]interface{}

type CursorPlanVariable struct {
	// ID is a variable's id.
	ID int `json:"id"`
	// Name is a variable's name.
	Name string `json:"name"`
	// IsDataFromCollection is set to true when data comes from a collection.
	IsDataFromCollection bool `json:"isDataFromCollection"`
	// IsFullDocumentFromCollection is set to true when all data comes from a collection.
	IsFullDocumentFromCollection bool `json:"isFullDocumentFromCollection"`
}

type CursorStats struct {
	// The total number of data-modification operations successfully executed.
	WritesExecutedInt uint64 `json:"writesExecuted,omitempty"`
	// The total number of data-modification operations that were unsuccessful
	WritesIgnoredInt uint64 `json:"writesIgnored,omitempty"`
	// The total number of documents iterated over when scanning a collection without an index.
	ScannedFullInt uint64 `json:"scannedFull,omitempty"`
	// The total number of documents iterated over when scanning a collection using an index.
	ScannedIndexInt uint64 `json:"scannedIndex,omitempty"`
	// The total number of documents that were removed after executing a filter condition in a FilterNode
	FilteredInt uint64 `json:"filtered,omitempty"`
	// The total number of documents that matched the search condition if the query's final LIMIT statement were not present.
	FullCountInt uint64 `json:"fullCount,omitempty"`
	// Query execution time (wall-clock time). value will be set from the outside
	ExecutionTimeInt float64 `json:"executionTime,omitempty"`

	HTTPRequests    uint64 `json:"httpRequests,omitempty"`
	PeakMemoryUsage uint64 `json:"peakMemoryUsage,omitempty"`

	// CursorsCreated the total number of cursor objects created during query execution. Cursor objects are created for index lookups.
	CursorsCreated uint64 `json:"cursorsCreated,omitempty"`
	// CursorsRearmed the total number of times an existing cursor object was repurposed.
	// Repurposing an existing cursor object is normally more efficient compared to destroying an existing cursor object
	// and creating a new one from scratch.
	CursorsRearmed uint64 `json:"cursorsRearmed,omitempty"`
	// CacheHits the total number of index entries read from in-memory caches for indexes of type edge or persistent.
	// This value will only be non-zero when reading from indexes that have an in-memory cache enabled,
	// and when the query allows using the in-memory cache (i.e. using equality lookups on all index attributes).
	CacheHits uint64 `json:"cacheHits,omitempty"`
	// CacheMisses the total number of cache read attempts for index entries that could not be served from in-memory caches for indexes of type edge or persistent.
	// This value will only be non-zero when reading from indexes that have an in-memory cache enabled,
	// the query allows using the in-memory cache (i.e. using equality lookups on all index attributes) and the looked up values are not present in the cache.
	CacheMisses uint64 `json:"cacheMisses,omitempty"`
}

type Database interface {
	// Name returns the name of the database.
	Name() string

	// Info fetches information about the database.
	Info(ctx context.Context) (DatabaseInfo, error)

	// Remove removes the entire database.
	// If the database does not exist, a NotFoundError is returned.
	Remove(ctx context.Context) error

	// TransactionJS performs a javascript transaction. The result of the transaction function is returned.
	TransactionJS(ctx context.Context, options TransactionJSOptions) (interface{}, error)

	// Returns the available key generators for collections.
	KeyGenerators(ctx context.Context) (KeyGeneratorsResponse, error)

	DatabaseCollection
	DatabaseTransaction
	DatabaseQuery
	DatabaseView
	DatabaseAnalyzer
	DatabaseGraph
}

type DatabaseAnalyzer interface {
	// EnsureCreatedAnalyzer creates an Analyzer for the database, if it does not already exist.
	// It returns the Analyser object together with a boolean indicating if the Analyzer was newly created (true) or pre-existing (false).
	EnsureCreatedAnalyzer(ctx context.Context, analyzer *AnalyzerDefinition) (Analyzer, bool, error)

	// Analyzer returns the analyzer definition for the given analyzer
	Analyzer(ctx context.Context, name string) (Analyzer, error)

	// Analyzers return an iterator to read all analyzers
	Analyzers(ctx context.Context) (AnalyzersResponseReader, error)
}

type DatabaseCollection interface {
	// GetCollection opens a connection to an existing collection within the database.
	// If no collection with given name exists, an NotFoundError is returned.
	GetCollection(ctx context.Context, name string, options *GetCollectionOptions) (Collection, error)

	// CollectionExists returns true if a collection with given name exists within the database.
	CollectionExists(ctx context.Context, name string) (bool, error)

	// Collections returns a list of all collections in the database.
	Collections(ctx context.Context) ([]Collection, error)

	// CreateCollection creates a new collection with given name and options, and opens a connection to it.
	// If a collection with given name already exists within the database, a DuplicateError is returned.
	CreateCollectionV2(ctx context.Context, name string, props *CreateCollectionPropertiesV2) (Collection, error)

	// CreateCollectionWithOptions creates a new collection with given name and options, and opens a connection to it.
	// If a collection with given name already exists within the database, a DuplicateError is returned.
	CreateCollectionWithOptionsV2(ctx context.Context, name string, props *CreateCollectionPropertiesV2, options *CreateCollectionOptions) (Collection, error)
}

type DatabaseGraph interface {
	// GetEdges returns inbound and outbound edge documents of a given vertex.
	// Requires Edge collection name and vertex ID
	GetEdges(ctx context.Context, name, vertex string, options *GetEdgesOptions) ([]EdgeDetails, error)

	// Graph opens a connection to an existing graph within the database.
	// If no graph with given name exists, an NotFoundError is returned.
	Graph(ctx context.Context, name string, options *GetGraphOptions) (Graph, error)

	// GraphExists returns true if a graph with given name exists within the database.
	GraphExists(ctx context.Context, name string) (bool, error)

	// Graphs return a list of all graphs in the database.
	Graphs(ctx context.Context) (GraphsResponseReader, error)

	// CreateGraph creates a new graph with given name and options, and opens a connection to it.
	// If a graph with given name already exists within the database, a DuplicateError is returned.
	CreateGraph(ctx context.Context, name string, graph *GraphDefinition, options *CreateGraphOptions) (Graph, error)
}

type DatabaseInfo struct {
	// The identifier of the database.
	ID string `json:"id,omitempty"`

	// The name of the database.
	Name string `json:"name,omitempty"`

	// The filesystem path of the database.
	Path string `json:"path,omitempty"`

	// If true then the database is the _system database.
	IsSystem bool `json:"isSystem,omitempty"`

	// Default replication factor for collections in database
	ReplicationFactor ReplicationFactor `json:"replicationFactor,omitempty"`

	// Default write concern for collections in database
	WriteConcern int `json:"writeConcern,omitempty"`

	// Default sharding for collections in database
	Sharding DatabaseSharding `json:"sharding,omitempty"`

	// Replication version used for this database
	ReplicationVersion DatabaseReplicationVersion `json:"replicationVersion,omitempty"`
}

type DatabaseInventory struct {
	Info        DatabaseInfo          `json:"properties,omitempty"`
	Collections []InventoryCollection `json:"collections,omitempty"`
	Views       []InventoryView       `json:"views,omitempty"`
	State       ServerStatus          `json:"state,omitempty"`
	Tick        string                `json:"tick,omitempty"`
}

type DatabasePermissions struct {
	// Permission access type for the database.
	Permission Grant `json:"permission"`

	// Collections contain a map with collection names as object keys and the associated privileges for them.
	Collections map[string]Grant `json:"collections"`
}

type DatabaseQuery interface {
	// Query performs an AQL query, returning a cursor used to iterate over the returned documents.
	// Note that the returned Cursor must always be closed to avoid holding on to resources in the server while they are no longer needed.
	Query(ctx context.Context, query string, opts *QueryOptions) (Cursor, error)

	// QueryBatch performs an AQL query, returning a cursor used to iterate over the returned documents in batches.
	// In contrast to Query, QueryBatch does not load all documents into memory, but returns them in batches and allows for retries in case of errors.
	// Note that the returned Cursor must always be closed to avoid holding on to resources in the server while they are no longer needed
	QueryBatch(ctx context.Context, query string, opts *QueryOptions, result interface{}) (CursorBatch, error)

	// ValidateQuery validates an AQL query.
	// When the query is valid, nil returned, otherwise an error is returned.
	// The query is not executed.
	ValidateQuery(ctx context.Context, query string) error

	// ExplainQuery explains an AQL query and return information about it.
	ExplainQuery(ctx context.Context, query string, bindVars map[string]interface{}, opts *ExplainQueryOptions) (ExplainQueryResult, error)

	// GetQueryProperties returns the properties of the query system.
	GetQueryProperties(ctx context.Context) (QueryProperties, error)

	// UpdateQueryProperties updates the properties of the query system.
	// The properties are updated with the provided options.
	// The updated properties are returned.
	UpdateQueryProperties(ctx context.Context, options QueryProperties) (QueryProperties, error)

	// ListOfRunningAQLQueries returns a list of currently running AQL queries.
	// If the all parameter is set to true, it returns all queries, otherwise only the queries that are currently running.
	// The result is a list of RunningAQLQuery objects.
	ListOfRunningAQLQueries(ctx context.Context, all *bool) ([]RunningAQLQuery, error)

	// ListOfSlowAQLQueries returns a list of slow AQL queries.
	// If the all parameter is set to true, it returns all slow queries, otherwise only the queries that are currently running.
	// The result is a list of RunningAQLQuery objects.
	// Slow queries are defined as queries that have been running longer than the configured slow query threshold.
	// The slow query threshold can be configured in the query properties.
	// The result is a list of RunningAQLQuery objects.
	ListOfSlowAQLQueries(ctx context.Context, all *bool) ([]RunningAQLQuery, error)

	// ClearSlowAQLQueries clears the list of slow AQL queries.
	// If the all parameter is set to true, it clears all slow queries, otherwise only
	// the queries that are currently running.
	ClearSlowAQLQueries(ctx context.Context, all *bool) error

	// KillAQLQuery kills a running AQL query.
	// The queryId is the unique identifier of the query
	KillAQLQuery(ctx context.Context, queryId string, all *bool) error

	// GetAllOptimizerRules returns all optimizer rules available in the database.
	// The result is a list of OptimizerRule objects.
	GetAllOptimizerRules(ctx context.Context) ([]OptimizerRules, error)

	// GetQueryPlanCache returns a list of cached query plans.
	// The result is a list of QueryPlanCacheRespObject objects.
	GetQueryPlanCache(ctx context.Context) ([]QueryPlanCacheRespObject, error)

	// ClearQueryPlanCache clears the query plan cache.
	ClearQueryPlanCache(ctx context.Context) error

	// GetQueryEntriesCache returns a list of cached query entries.
	// The result is a list of QueryCacheEntriesRespObject objects.
	GetQueryEntriesCache(ctx context.Context) ([]QueryCacheEntriesRespObject, error)

	// ClearQueryCache clears the query cache.
	// This will remove all cached query entries.
	ClearQueryCache(ctx context.Context) error

	// GetQueryCacheProperties returns the properties of the query cache.
	// The result is a QueryCacheProperties object.
	GetQueryCacheProperties(ctx context.Context) (QueryCacheProperties, error)

	// SetQueryCacheProperties sets the properties of the query cache.
	// The properties are updated with the provided options.
	SetQueryCacheProperties(ctx context.Context, options QueryCacheProperties) (QueryCacheProperties, error)

	// CreateUserDefinedFunction creates a user-defined function in the database.
	// The function is created with the provided options.
	// The function is created in the system collection `_aqlfunctions`.
	// The function is created with the provided code and name.
	// If the function already exists, it will be updated with the new code.
	CreateUserDefinedFunction(ctx context.Context, options UserDefinedFunctionObject) (bool, error)

	// DeleteUserDefinedFunction removes a user-defined AQL function from the current database.
	// If group is true, all functions with the given name as a namespace prefix will be deleted.
	// If group is false, only the function with the fully qualified name will be removed.
	// It returns the number of functions deleted.
	DeleteUserDefinedFunction(ctx context.Context, name *string, group *bool) (*int, error)

	// GetUserDefinedFunctions retrieves all user-defined AQL functions registered in the current database.
	// It returns a list of UserDefinedFunctionObject, each containing the function's name, code, and isDeterministic.
	// The returned list may be empty array if no user-defined functions are registered.
	GetUserDefinedFunctions(ctx context.Context) ([]UserDefinedFunctionObject, error)
}

type DatabaseReplicationVersion string

type DatabaseSharding string

type DatabaseTransaction interface {
	ListTransactions(ctx context.Context) ([]Transaction, error)
	ListTransactionsWithStatuses(ctx context.Context, statuses ...TransactionStatus) ([]Transaction, error)

	BeginTransaction(ctx context.Context, cols TransactionCollections, opts *BeginTransactionOptions) (Transaction, error)

	Transaction(ctx context.Context, id TransactionID) (Transaction, error)

	WithTransaction(ctx context.Context, cols TransactionCollections, opts *BeginTransactionOptions, commitOptions *CommitTransactionOptions, abortOptions *AbortTransactionOptions, w TransactionWrap) error
}

type DatabaseView interface {
	// View opens a connection to an existing view within the database.
	// If no view with given name exists, an NotFoundError is returned.
	View(ctx context.Context, name string) (View, error)

	// ViewExists returns true if a view with given name exists within the database.
	ViewExists(ctx context.Context, name string) (bool, error)

	// Views returns a reader to iterate over all views in the database
	Views(ctx context.Context) (ViewsResponseReader, error)

	// ViewsAll returns all views in the database
	ViewsAll(ctx context.Context) ([]View, error)

	// CreateArangoSearchView creates a new view of type ArangoSearch,
	// with given name and options, and opens a connection to it.
	// If a view with given name already exists within the database, a ConflictError is returned.
	CreateArangoSearchView(ctx context.Context, name string, options *ArangoSearchViewProperties) (ArangoSearchView, error)

	// CreateArangoSearchAliasView creates ArangoSearch alias view with given name and options, and opens a connection to it.
	// If a view with given name already exists within the database, a ConflictError is returned.
	CreateArangoSearchAliasView(ctx context.Context, name string, options *ArangoSearchAliasViewProperties) (ArangoSearchViewAlias, error)
}

type DeleteEdgeDefinitionOptions struct {
	// Drop the collection as well. The collection is only dropped if it is not used in other graphs.
	DropCollection *bool

	// Define if the request should wait until synced to disk.
	WaitForSync *bool
}

type DeleteEdgeDefinitionResponse struct {
	shared.ResponseStruct `json:",inline"`

	// GraphDefinition contains the updated graph definition
	GraphDefinition *GraphDefinition `json:"graph,omitempty"`
}

type DeleteEdgeOptions struct {
	// Define if the request should wait until synced to disk.
	WaitForSync *bool `json:"waitForSync,omitempty"`

	// Define if a presentation of the deleted document should be returned within the response object.
	OldObject interface{}

	// Conditionally delete a Edge based on a target revision id
	// If the “If-Match” header is given, then it must contain exactly one ETag (_rev).
	IfMatch string

	// To make this operation a part of a Stream Transaction, set this header to the transaction ID returned by the
	// DatabaseTransaction.BeginTransaction() method.
	TransactionID string
}

type DeleteVertexCollectionOptions struct {
	// Drop the collection as well. The collection is only dropped if it is not used in other graphs.
	DropCollection *bool
}

type DeleteVertexCollectionResponse struct {
	shared.ResponseStruct `json:",inline"`

	// GraphDefinition contains the updated graph definition
	GraphDefinition *GraphDefinition `json:"graph,omitempty"`
}

type DeleteVertexOptions struct {
	// Define if the request should wait until synced to disk.
	WaitForSync *bool `json:"waitForSync,omitempty"`

	// Define if a presentation of the deleted document should be returned within the response object.
	OldObject interface{}

	// Conditionally delete a vertex based on a target revision id
	// If the “If-Match” header is given, then it must contain exactly one ETag (_rev).
	IfMatch string

	// To make this operation a part of a Stream Transaction, set this header to the transaction ID returned by the
	// DatabaseTransaction.BeginTransaction() method.
	TransactionID string
}

type DeployFoxxServiceRequest struct {
	FoxxDeploymentOptions `json:",inline"`
}

type DocumentID string

type DocumentMeta struct {
	Key string     `json:"_key,omitempty"`
	ID  DocumentID `json:"_id,omitempty"`
	Rev string     `json:"_rev,omitempty"`
}

type DocumentMetaSlice []DocumentMeta

type DocumentMetaWithOldRev struct {
	DocumentMeta
	OldRev string `json:"_oldRev,omitempty"`
}

type Edge interface {
	GraphCollection

	// Name returns the name of the Edge collection
	Name() string

	// GetEdge Gets an Edge from the given collection.
	// To get _key and _rev values, embed the DocumentMeta struct in your result struct.
	GetEdge(ctx context.Context, key string, result interface{}, opts *GetEdgeOptions) error

	// CreateEdge Creates a new edge in the specified collection.
	// Within the body the edge has to contain a '_from' and '_to' value referencing to valid vertices in the graph.
	// Furthermore, the edge has to be valid according to the edge definitions.
	// To get _key and _rev values, embed the DocumentMeta struct in your result struct and pass to EdgeCreateResponse.New.
	CreateEdge(ctx context.Context, Edge interface{}, opts *CreateEdgeOptions) (EdgeCreateResponse, error)

	// UpdateEdge Partially modify the data of the specific edge in the collection.
	UpdateEdge(ctx context.Context, key string, newValue interface{}, opts *EdgeUpdateOptions) (EdgeUpdateResponse, error)

	// ReplaceEdge Replaces the data of an Edge in the collection.
	ReplaceEdge(ctx context.Context, key string, newValue interface{}, opts *EdgeReplaceOptions) (EdgeReplaceResponse, error)

	// DeleteEdge Removes an Edge from the collection.
	DeleteEdge(ctx context.Context, key string, opts *DeleteEdgeOptions) (EdgeDeleteResponse, error)
}

type EdgeCreateResponse struct {
	DocumentMeta
	shared.ResponseStruct `json:",inline"`
	New                   interface{}
}

type EdgeDefinition struct {
	// Name of the edge collection, where the edges are stored in.
	Collection string `json:"collection"`

	// List of vertex collection names.
	// Edges in a collection can only be inserted if their _to is in any of the collections here.
	To []string `json:"to"`

	// List of vertex collection names.
	// Edges in a collection can only be inserted if their _from is in any of the collections here.
	From []string `json:"from"`
}

type EdgeDeleteResponse struct {
	shared.ResponseStruct `json:",inline"`
	Old                   interface{}
}

type EdgeDetails struct {
	DocumentMeta
	From  string `json:"_from"`
	To    string `json:"_to"`
	Label string `json:"$label"`
}

type EdgeDirection string

type EdgeReplaceOptions struct {
	// Define if the request should wait until synced to disk.
	WaitForSync *bool

	// Define if a presentation of the new document should be returned within the response object.
	NewObject interface{}

	// Define if a presentation of the deleted document should be returned within the response object.
	OldObject interface{}

	// Define if values set to null should be stored. By default (true), the given documents attribute(s)
	// are set to null. If this parameter is set to false, top-level attribute and sub-attributes with a null value
	// in the request are removed from the document (but not attributes of objects that are nested inside of arrays).
	KeepNull *bool

	// Conditionally replace a Edge based on a target revision id
	// If the “If-Match” header is given, then it must contain exactly one ETag (_rev).
	IfMatch string

	// To make this operation a part of a Stream Transaction, set this header to the transaction ID returned by the
	// DatabaseTransaction.BeginTransaction() method.
	TransactionID string
}

type EdgeReplaceResponse struct {
	DocumentMeta
	shared.ResponseStruct `json:",inline"`
	Old, New              interface{}
}

type EdgeUpdateOptions struct {
	// Define if the request should wait until synced to disk.
	WaitForSync *bool

	// Define if a presentation of the new document should be returned within the response object.
	NewObject interface{}

	// Define if a presentation of the deleted document should be returned within the response object.
	OldObject interface{}

	// Define if values set to null should be stored. By default (true), the given documents attribute(s)
	// are set to null. If this parameter is set to false, top-level attribute and sub-attributes with a null value
	// in the request are removed from the document (but not attributes of objects that are nested inside of arrays).
	KeepNull *bool

	// Conditionally update a Edge based on a target revision id
	// If the “If-Match” header is given, then it must contain exactly one ETag (_rev).
	IfMatch string

	// To make this operation a part of a Stream Transaction, set this header to the transaction ID returned by the
	// DatabaseTransaction.BeginTransaction() method.
	TransactionID string
}

type EdgeUpdateResponse struct {
	DocumentMeta
	shared.ResponseStruct `json:",inline"`
	Old, New              interface{}
}

type EngineInfo struct {
	Type EngineType `json:"name"`
}

type EngineType string

type Engines struct {
	// Arangodb specifies the required ArangoDB version range (semver format).
	Arangodb *string `json:"arangodb,omitempty"`
}

type ExplainQueryOptimizerOptions struct {
	// A list of to-be-included or to-be-excluded optimizer rules can be put into this attribute,
	// telling the optimizer to include or exclude specific rules.
	//  To disable a rule, prefix its name with a "-", to enable a rule, prefix it with a "+".
	// There is also a pseudo-rule "all", which matches all optimizer rules. "-all" disables all rules.
	Rules []string `json:"rules,omitempty"`
}

type ExplainQueryOptions struct {
	// If set to true, all possible execution plans will be returned.
	// The default is false, meaning only the optimal plan will be returned.
	AllPlans bool `json:"allPlans,omitempty"`

	// An optional maximum number of plans that the optimizer is allowed to generate.
	// Setting this attribute to a low value allows to put a cap on the amount of work the optimizer does.
	MaxNumberOfPlans *int `json:"maxNumberOfPlans,omitempty"`

	// Options related to the query optimizer.
	Optimizer ExplainQueryOptimizerOptions `json:"optimizer,omitempty"`
}

type ExplainQueryResult struct {
	Plan  ExplainQueryResultPlan   `json:"plan,omitempty"`
	Plans []ExplainQueryResultPlan `json:"plans,omitempty"`

	// List of warnings that occurred during optimization or execution plan creation
	Warnings []string `json:"warnings,omitempty"`

	// Info about optimizer statistics
	Stats ExplainQueryResultExecutionStats `json:"stats,omitempty"`

	// Cacheable states whether the query results can be cached on the server if the query result cache were used.
	// This attribute is not present when allPlans is set to true.
	Cacheable *bool `json:"cacheable,omitempty"`
}

type ExplainQueryResultExecutionCollection struct {
	Name string `json:"name"`
	Type string `json:"type"`
}

type ExplainQueryResultExecutionNodeRaw map[string]interface{}

type ExplainQueryResultExecutionStats struct {
	RulesExecuted   int     `json:"rulesExecuted,omitempty"`
	RulesSkipped    int     `json:"rulesSkipped,omitempty"`
	PlansCreated    int     `json:"plansCreated,omitempty"`
	PeakMemoryUsage uint64  `json:"peakMemoryUsage,omitempty"`
	ExecutionTime   float64 `json:"executionTime,omitempty"`
}

type ExplainQueryResultExecutionVariable struct {
	ID                           int    `json:"id"`
	Name                         string `json:"name"`
	IsDataFromCollection         bool   `json:"isDataFromCollection"`
	IsFullDocumentFromCollection bool   `json:"isFullDocumentFromCollection"`
}

type ExplainQueryResultPlan struct {
	// Execution nodes of the plan.
	NodesRaw []ExplainQueryResultExecutionNodeRaw `json:"nodes,omitempty"`

	// List of rules the optimizer applied
	Rules []string `json:"rules,omitempty"`

	// List of collections used in the query
	Collections []ExplainQueryResultExecutionCollection `json:"collections,omitempty"`

	// List of variables used in the query (note: this may contain internal variables created by the optimizer)
	Variables []ExplainQueryResultExecutionVariable `json:"variables,omitempty"`

	// The total estimated cost for the plan. If there are multiple plans, the optimizer will choose the plan with the lowest total cost
	EstimatedCost float64 `json:"estimatedCost,omitempty"`

	// The estimated number of results.
	EstimatedNrItems int `json:"estimatedNrItems,omitempty"`
}

type Flags struct {
	// CanBeDisabled indicates whether the query can be disabled.
	CanBeDisabled *bool `json:"canBeDisabled,omitempty"`
	// CanBeExecuted indicates whether the query can be executed.
	CanCreateAdditionalPlans *bool `json:"canCreateAdditionalPlans,omitempty"`
	//ClusterOnly indicates whether the query is only available in a cluster environment.
	ClusterOnly *bool `json:"clusterOnly,omitempty"`
	// DisabledByDefault indicates whether the query is disabled by default.
	// This means that the query is not executed unless explicitly enabled.
	DisabledByDefault *bool `json:"disabledByDefault,omitempty"`
	// EnterpriseOnly indicates whether the query is only available in the Enterprise Edition.
	EnterpriseOnly *bool `json:"enterpriseOnly,omitempty"`
	// Hidden indicates whether the query is hidden from the user.
	Hidden *bool `json:"hidden,omitempty"`
}

type FoxxDeleteOptions struct {
	Mount    *string
	Teardown *bool
}

type FoxxDeploymentOptions struct {
	Mount *string
}

type FoxxServiceListItem struct {
	CommonFoxxServiceFields
	// Provides lists the capabilities or interfaces the service provides.
	// This is a flexible map that may contain metadata like API contracts or service roles.
	Provides map[string]interface{} `json:"provides"`
}

type FoxxServiceObject struct {
	// Common fields for all Foxx services.
	CommonFoxxServiceFields

	// Path is the local filesystem path where the service is installed.
	Path *string `json:"path,omitempty"`

	// Manifest contains the normalized manifest.json of the service.
	Manifest *Manifest `json:"manifest,omitempty"`

	// Options contains optional runtime options defined for the service.
	Options map[string]interface{} `json:"options,omitempty"`
}

type FoxxTestOptions struct {
	FoxxDeploymentOptions
	Reporter  *string `json:"reporter,omitempty"`
	Idiomatic *bool   `json:"idiomatic,omitempty"`
	Filter    *string `json:"filter,omitempty"`
}

type GetCollectionOptions struct {
	// SkipExistCheck skips checking if collection exists
	SkipExistCheck bool `json:"skipExistCheck,omitempty"`
}

type GetDatabaseOptions struct {
	// SkipExistCheck skips checking if database exists
	SkipExistCheck bool `json:"skipExistCheck,omitempty"`
}

type GetEdgeOptions struct {
	// Must contain a revision. If this is set, a document is only returned if it has exactly this revision.
	// Also see if-match header as an alternative to this.
	Rev string `json:"rev,omitempty"`

	// If the “If-Match” header is given, then it must contain exactly one ETag (_rev).
	// The document is returned, if it has the same revision as the given ETag
	IfMatch string

	// If the “If-None-Match” header is given, then it must contain exactly one ETag (_rev).
	// The document is returned, if it has a different revision than the given ETag
	IfNoneMatch string

	// To make this operation a part of a Stream Transaction, set this header to the transaction ID returned by the
	// DatabaseTransaction.BeginTransaction() method.
	TransactionID string
}

type GetEdgesOptions struct {
	// The direction of the edges. Allowed values are "in" and "out". If not set, edges in both directions are returned.
	Direction EdgeDirection `json:"direction,omitempty"`

	// Set this to true to allow the Coordinator to ask any shard replica for the data, not only the shard leader.
	// This may result in “dirty reads”.
	AllowDirtyReads *bool `json:"-"`
}

type GetGraphOptions struct {
	// SkipExistCheck skips checking if graph exists
	SkipExistCheck bool `json:"skipExistCheck,omitempty"`
}

type GetVersionOptions struct {
	// If true, additional details will be returned in response
	// Default false
	Details *bool
}

type GetVertexOptions struct {
	// Must contain a revision. If this is set, a document is only returned if it has exactly this revision.
	// Also see if-match header as an alternative to this.
	Rev string `json:"rev,omitempty"`

	// If the “If-Match” header is given, then it must contain exactly one ETag (_rev).
	// The document is returned, if it has the same revision as the given ETag
	IfMatch string

	// If the “If-None-Match” header is given, then it must contain exactly one ETag (_rev).
	// The document is returned, if it has a different revision than the given ETag
	IfNoneMatch string

	// To make this operation a part of a Stream Transaction, set this header to the transaction ID returned by the
	// DatabaseTransaction.BeginTransaction() method.
	TransactionID string
}

type Grant string

type Graph interface {
	// Name returns the name of the graph.
	Name() string

	// IsSmart Whether the graph is a SmartGraph (Enterprise Edition only).
	IsSmart() bool

	// IsSatellite Flag if the graph is a SatelliteGraph (Enterprise Edition only) or not.
	IsSatellite() bool

	// IsDisjoint Whether the graph is a Disjoint SmartGraph (Enterprise Edition only).
	IsDisjoint() bool

	// EdgeDefinitions returns the edge definitions of the graph.
	EdgeDefinitions() []EdgeDefinition

	// SmartGraphAttribute of the sharding attribute in the SmartGraph case (Enterprise Edition only).
	SmartGraphAttribute() string

	// NumberOfShards Number of shards created for every new collection in the graph.
	NumberOfShards() *int

	// OrphanCollections An array of additional vertex collections.
	// Documents in these collections do not have edges within this graph.
	OrphanCollections() []string

	// ReplicationFactor The replication factor used for every new collection in the graph.
	// For SatelliteGraphs, it is the string "satellite" (Enterprise Edition only).
	ReplicationFactor() int

	// WriteConcern The default write concern for new collections in the graph. It determines how many copies of each shard
	// are required to be in sync on the different DB-Servers. If there are less than these many copies in the cluster,
	// a shard refuses to write. Writes to shards with enough up-to-date copies succeed at the same time, however.
	// The value of writeConcern cannot be greater than replicationFactor. For SatelliteGraphs, the writeConcern is
	// automatically controlled to equal the number of DB-Servers and the attribute is not available. (cluster only)
	WriteConcern() *int

	// Remove the entire graph with options.
	Remove(ctx context.Context, opts *RemoveGraphOptions) error

	// GraphVertexCollections - Vertex collection functions
	GraphVertexCollections

	// GraphEdgesDefinition - Edge collection functions
	GraphEdgesDefinition
}

type GraphCollection interface {
	Name() string
	Database() Database

	// Count fetches the number of document in the collection.
	Count(ctx context.Context) (int64, error)

	CollectionDocuments
	CollectionIndexes
}

type GraphDefinition struct {
	Name string `json:"name"`

	// IsSmart Whether the graph is a SmartGraph (Enterprise Edition only).
	IsSmart bool `json:"isSmart"`

	// IsSatellite Flag if the graph is a SatelliteGraph (Enterprise Edition only) or not.
	IsSatellite bool `json:"isSatellite"`

	// IsDisjoint Whether the graph is a Disjoint SmartGraph (Enterprise Edition only).
	IsDisjoint bool `json:"isDisjoint,omitempty"`

	// EdgeDefinitions An array of definitions for the relations of the graph
	EdgeDefinitions []EdgeDefinition `json:"edgeDefinitions,omitempty"`

	// NumberOfShards Number of shards created for every new collection in the graph.
	// For Satellite Graphs, it has to be set to 1
	NumberOfShards *int `json:"numberOfShards,omitempty"`

	// OrphanCollections An array of additional vertex collections.
	// Documents in these collections do not have edges within this graph.
	OrphanCollections []string `json:"orphanCollections,omitempty"`

	// WriteConcern The default write concern for new collections in the graph. It determines how many copies of each shard
	// are required to be in sync on the different DB-Servers. If there are less than these many copies in the cluster,
	// a shard refuses to write. Writes to shards with enough up-to-date copies succeed at the same time, however.
	// The value of writeConcern cannot be greater than replicationFactor. For SatelliteGraphs, the writeConcern is
	// automatically controlled to equal the number of DB-Servers and the attribute is not available. (cluster only)
	WriteConcern *int `json:"writeConcern,omitempty"`

	// ReplicationFactor The replication factor used for every new collection in the graph.
	// For SatelliteGraphs, it is the string "satellite" (Enterprise Edition only).
	ReplicationFactor graphReplicationFactor `json:"replicationFactor,omitempty"`

	// SmartGraphAttribute of the sharding attribute in the SmartGraph case (Enterprise Edition only).
	SmartGraphAttribute string `json:"smartGraphAttribute,omitempty"`
}

type GraphEdgesDefinition interface {
	// EdgeDefinition opens a connection to an existing Edge collection within the graph.
	// If no Edge collection with given name exists, an NotFoundError is returned.
	// Note: When calling Remove on the returned Collection, the collection is removed from the graph. Not from the database.
	EdgeDefinition(ctx context.Context, collection string) (Edge, error)

	// EdgeDefinitionExists returns true if an Edge collection with given name exists within the graph.
	EdgeDefinitionExists(ctx context.Context, collection string) (bool, error)

	// GetEdgeDefinitions returns all Edge collections of this graph
	// Note: When calling Remove on any of the returned Collection's, the collection is removed from the graph. Not from the database.
	GetEdgeDefinitions(ctx context.Context) ([]Edge, error)

	// CreateEdgeDefinition creates an Edge collection in the graph
	// This edge definition has to contain a 'collection' and an array of each 'from' and 'to' vertex collections.
	// An edge definition can only be added if this definition is either not used in any other graph, or it is used
	// with exactly the same definition.
	// For example, it is not possible to store a definition “e” from “v1” to “v2” in one graph,
	// and “e” from “v2” to “v1” in another graph, but both can have “e” from “v1” to “v2”.
	CreateEdgeDefinition(ctx context.Context, collection string, from, to []string, opts *CreateEdgeDefinitionOptions) (CreateEdgeDefinitionResponse, error)

	// ReplaceEdgeDefinition Change one specific edge definition.
	// This modifies all occurrences of this definition in all graphs known to your database.
	ReplaceEdgeDefinition(ctx context.Context, collection string, from, to []string, opts *ReplaceEdgeOptions) (ReplaceEdgeDefinitionResponse, error)

	// DeleteEdgeDefinition Remove one edge definition from the graph.
	// This only removes the edge collection from the graph definition.
	// The vertex collections of the edge definition become orphan collections,
	// but otherwise remain untouched and can still be used in your queries.
	DeleteEdgeDefinition(ctx context.Context, collection string, opts *DeleteEdgeDefinitionOptions) (DeleteEdgeDefinitionResponse, error)
}

type GraphVertexCollections interface {
	// VertexCollection opens a connection to an existing vertex-collection within the graph.
	// If no vertex-collection with given name exists, an NotFoundError is returned.
	// Note: When calling Remove on the returned Collection, the collection is removed from the graph. Not from the database.
	VertexCollection(ctx context.Context, name string) (VertexCollection, error)

	// VertexCollectionExists returns true if a vertex-collection with given name exists within the graph.
	VertexCollectionExists(ctx context.Context, name string) (bool, error)

	// VertexCollections returns all vertex collections of this graph
	// Note: When calling Remove on any of the returned Collection's, the collection is removed from the graph. Not from the database.
	VertexCollections(ctx context.Context) ([]VertexCollection, error)

	// CreateVertexCollection creates a vertex collection in the graph
	CreateVertexCollection(ctx context.Context, name string, opts *CreateVertexCollectionOptions) (CreateVertexCollectionResponse, error)

	// DeleteVertexCollection Removes a vertex collection from the list of the graph’s orphan collections.
	// It can optionally delete the collection if it is not used in any other graph.
	// You cannot remove vertex collections that are used in one of the edge definitions of the graph.
	// You need to modify or remove the edge definition first to fully remove a vertex collection from the graph.
	DeleteVertexCollection(ctx context.Context, name string, opts *DeleteVertexCollectionOptions) (DeleteVertexCollectionResponse, error)
}

type GraphsResponseReader interface {
	// Read returns next Graph. If no Graph left, shared.NoMoreDocumentsError returned
	Read() (Graph, error)
}

type IndexOptions struct {
	// Fields returns a list of attributes of this index.
	Fields []string `json:"fields,omitempty"`

	// Estimates determines if the to-be-created index should maintain selectivity estimates or not - PersistentIndex only
	Estimates *bool `json:"estimates,omitempty"`

	// SelectivityEstimate determines the selectivity estimate value of the index - PersistentIndex only
	SelectivityEstimate float64 `json:"selectivityEstimate,omitempty"`

	// MinLength returns min length for this index if set.
	MinLength *int `json:"minLength,omitempty"`

	// Deduplicate returns deduplicate setting of this index.
	Deduplicate *bool `json:"deduplicate,omitempty"`

	// ExpireAfter returns an expiry after for this index if set.
	ExpireAfter *int `json:"expireAfter,omitempty"`

	// CacheEnabled if true, then the index will be cached in memory. Caching is turned off by default.
	CacheEnabled *bool `json:"cacheEnabled,omitempty"`

	// StoredValues returns a list of stored values for this index - PersistentIndex only
	StoredValues []string `json:"storedValues,omitempty"`

	// GeoJSON returns if geo json was set for this index or not.
	GeoJSON *bool `json:"geoJson,omitempty"`

	// LegacyPolygons returns if legacy polygons was set for this index or not before 3.10 - GeoIndex only
	LegacyPolygons *bool `json:"legacyPolygons,omitempty"`
}

type IndexResponse struct {
	// Name optional user defined name used for hints in AQL queries
	Name string `json:"name,omitempty"`

	// Type returns the type of the index
	Type IndexType `json:"type"`

	IndexSharedOptions `json:",inline"`

	// RegularIndex is the regular index object. It is empty for the InvertedIndex type.
	RegularIndex *IndexOptions `json:"indexes"`

	// InvertedIndex is the inverted index object. It is not empty only for InvertedIndex type.
	InvertedIndex *InvertedIndexOptions `json:"invertedIndexes"`
}

type IndexSharedOptions struct {
	// ID returns the ID of the index. Effectively this is `<collection-name>/<index.Name()>`.
	ID string `json:"id,omitempty"`

	// Unique is supported by persistent indexes. By default, all user-defined indexes are non-unique.
	// Only the attributes in fields are checked for uniqueness.
	// Any attributes in from storedValues are not checked for their uniqueness.
	Unique *bool `json:"unique,omitempty"`

	// Sparse You can control the sparsity for persistent indexes.
	// The inverted, fulltext, and geo index types are sparse by definition.
	Sparse *bool `json:"sparse,omitempty"`

	// IsNewlyCreated returns if this index was newly created or pre-existing.
	IsNewlyCreated *bool `json:"isNewlyCreated,omitempty"`
}

type IndexType string

type InventoryCollection struct {
	Parameters  InventoryCollectionParameters `json:"parameters"`
	Indexes     []InventoryIndex              `json:"indexes,omitempty"`
	PlanVersion int64                         `json:"planVersion,omitempty"`
	IsReady     bool                          `json:"isReady,omitempty"`
	AllInSync   bool                          `json:"allInSync,omitempty"`
}

type InventoryCollectionParameters struct {
	Deleted bool                   `json:"deleted,omitempty"`
	Shards  map[ShardID][]ServerID `json:"shards,omitempty"`
	PlanID  string                 `json:"planId,omitempty"`

	CollectionProperties
}

type InventoryIndex struct {
	ID              string   `json:"id,omitempty"`
	Type            string   `json:"type,omitempty"`
	Fields          []string `json:"fields,omitempty"`
	Unique          bool     `json:"unique"`
	Sparse          bool     `json:"sparse"`
	Deduplicate     bool     `json:"deduplicate"`
	MinLength       int      `json:"minLength,omitempty"`
	GeoJSON         bool     `json:"geoJson,omitempty"`
	Name            string   `json:"name,omitempty"`
	ExpireAfter     int      `json:"expireAfter,omitempty"`
	Estimates       bool     `json:"estimates,omitempty"`
	FieldValueTypes string   `json:"fieldValueTypes,omitempty"`
	CacheEnabled    *bool    `json:"cacheEnabled,omitempty"`
}

type InventoryView struct {
	Name     string   `json:"name,omitempty"`
	Deleted  bool     `json:"deleted,omitempty"`
	ID       string   `json:"id,omitempty"`
	IsSystem bool     `json:"isSystem,omitempty"`
	PlanID   string   `json:"planId,omitempty"`
	Type     ViewType `json:"type,omitempty"`

	ArangoSearchViewProperties
}

type InvertedIndexField struct {
	// Name (Required) An attribute path. The '.' character denotes sub-attributes.
	Name string `json:"name"`

	// Analyzer indicating the name of an analyzer instance
	// Default: the value defined by the top-level analyzer option, or if not set, the default identity Analyzer.
	Analyzer string `json:"analyzer,omitempty"`

	// Features is a list of Analyzer features to use for this field. They define what features are enabled for the analyzer
	Features []ArangoSearchFeature `json:"features,omitempty"`

	// IncludeAllFields This option only applies if you use the inverted index in a search-alias Views.
	// If set to true, then all sub-attributes of this field are indexed, excluding any sub-attributes that are configured separately by other elements in the fields array (and their sub-attributes). The analyzer and features properties apply to the sub-attributes.
	// If set to false, then sub-attributes are ignored. The default value is defined by the top-level includeAllFields option, or false if not set.
	IncludeAllFields *bool `json:"includeAllFields,omitempty"`

	// SearchField This option only applies if you use the inverted index in a search-alias Views.
	// You can set the option to true to get the same behavior as with arangosearch Views regarding the indexing of array values for this field. If enabled, both, array and primitive values (strings, numbers, etc.) are accepted. Every element of an array is indexed according to the trackListPositions option.
	// If set to false, it depends on the attribute path. If it explicitly expand an array ([*]), then the elements are indexed separately. Otherwise, the array is indexed as a whole, but only geopoint and aql Analyzers accept array inputs. You cannot use an array expansion if searchField is enabled.
	// Default: the value defined by the top-level searchField option, or false if not set.
	SearchField *bool `json:"searchField,omitempty"`

	// TrackListPositions This option only applies if you use the inverted index in a search-alias Views.
	// If set to true, then track the value position in arrays for array values. For example, when querying a document like { attr: [ "valueX", "valueY", "valueZ" ] }, you need to specify the array element, e.g. doc.attr[1] == "valueY".
	// If set to false, all values in an array are treated as equal alternatives. You don’t specify an array element in queries, e.g. doc.attr == "valueY", and all elements are searched for a match.
	// Default: the value defined by the top-level trackListPositions option, or false if not set.
	TrackListPositions bool `json:"trackListPositions,omitempty"`

	// Cache - Enable this option to always cache the field normalization values in memory for this specific field
	// Default: the value defined by the top-level 'cache' option.
	Cache *bool `json:"cache,omitempty"`

	// Nested Index the specified sub-objects that are stored in an array.
	// Other than with the fields property, the values get indexed in a way that lets you query for co-occurring values.
	// For example, you can search the sub-objects and all the conditions need to be met by a single sub-object instead of across all of them.
	// Enterprise-only feature
	Nested []InvertedIndexNestedField `json:"nested,omitempty"`
}

type InvertedIndexNestedField struct {
	// Name An attribute path. The . character denotes sub-attributes.
	Name string `json:"name"`

	// Analyzer indicating the name of an analyzer instance
	// Default: the value defined by the top-level analyzer option, or if not set, the default identity Analyzer.
	Analyzer string `json:"analyzer,omitempty"`

	// Features is a list of Analyzer features to use for this field. They define what features are enabled for the analyzer
	Features []ArangoSearchFeature `json:"features,omitempty"`

	// SearchField This option only applies if you use the inverted index in a search-alias Views.
	// You can set the option to true to get the same behavior as with arangosearch Views regarding the indexing of array values for this field. If enabled, both, array and primitive values (strings, numbers, etc.) are accepted. Every element of an array is indexed according to the trackListPositions option.
	// If set to false, it depends on the attribute path. If it explicitly expand an array ([*]), then the elements are indexed separately. Otherwise, the array is indexed as a whole, but only geopoint and aql Analyzers accept array inputs. You cannot use an array expansion if searchField is enabled.
	// Default: the value defined by the top-level searchField option, or false if not set.
	SearchField *bool `json:"searchField,omitempty"`

	// Cache - Enable this option to always cache the field normalization values in memory for this specific field
	// Default: the value defined by the top-level 'cache' option.
	Cache *bool `json:"cache,omitempty"`

	// Nested - Index the specified sub-objects that are stored in an array.
	// Other than with the fields property, the values get indexed in a way that lets you query for co-occurring values.
	// For example, you can search the sub-objects and all the conditions need to be met by a single sub-object instead of across all of them.
	// Enterprise-only feature
	Nested []InvertedIndexNestedField `json:"nested,omitempty"`
}

type InvertedIndexOptions struct {
	// Name optional user defined name used for hints in AQL queries
	Name string `json:"name,omitempty"`

	// Fields contains the properties for individual fields of the element.
	// The key of the map are field names.
	// Required: true
	Fields []InvertedIndexField `json:"fields,omitempty"`

	// SearchField This option only applies if you use the inverted index in a search-alias Views.
	// You can set the option to true to get the same behavior as with arangosearch Views regarding the indexing of array values as the default.
	// If enabled, both, array and primitive values (strings, numbers, etc.) are accepted. Every element of an array is indexed according to the trackListPositions option.
	// If set to false, it depends on the attribute path. If it explicitly expand an array ([*]), then the elements are indexed separately.
	// Otherwise, the array is indexed as a whole, but only geopoint and aql Analyzers accept array inputs.
	// You cannot use an array expansion if searchField is enabled.
	SearchField *bool `json:"searchField,omitempty"`

	// Cache - Enable this option to always cache the field normalization values in memory for all fields by default.
	Cache *bool `json:"cache,omitempty"`

	// StoredValues The optional storedValues attribute can contain an array of paths to additional attributes to store in the index.
	// These additional attributes cannot be used for index lookups or for sorting, but they can be used for projections.
	// This allows an index to fully cover more queries and avoid extra document lookups.
	StoredValues []StoredValue `json:"storedValues,omitempty"`

	// PrimarySort You can define a primary sort order to enable an AQL optimization.
	// If a query iterates over all documents of a collection, wants to sort them by attribute values, and the (left-most) fields to sort by,
	// as well as their sorting direction, match with the primarySort definition, then the SORT operation is optimized away.
	PrimarySort *PrimarySort `json:"primarySort,omitempty"`

	// PrimaryKeyCache Enable this option to always cache the primary key column in memory.
	// This can improve the performance of queries that return many documents.
	PrimaryKeyCache *bool `json:"primaryKeyCache,omitempty"`

	// Analyzer  The name of an Analyzer to use by default. This Analyzer is applied to the values of the indexed
	// fields for which you don’t define Analyzers explicitly.
	Analyzer string `json:"analyzer,omitempty"`

	// Features list of analyzer features. You can set this option to overwrite what features are enabled for the default analyzer
	Features []ArangoSearchFeature `json:"features,omitempty"`

	// IncludeAllFields If set to true, all fields of this element will be indexed. Defaults to false.
	// Warning: Using includeAllFields for a lot of attributes in combination with complex Analyzers
	// may significantly slow down the indexing process.
	IncludeAllFields *bool `json:"includeAllFields,omitempty"`

	// TrackListPositions track the value position in arrays for array values.
	TrackListPositions bool `json:"trackListPositions,omitempty"`

	// Parallelism - The number of threads to use for indexing the fields. Default: 2
	Parallelism *int `json:"parallelism,omitempty"`

	// CleanupIntervalStep Wait at least this many commits between removing unused files in the ArangoSearch data directory
	// (default: 2, to disable use: 0).
	CleanupIntervalStep *int64 `json:"cleanupIntervalStep,omitempty"`

	// CommitIntervalMsec Wait at least this many milliseconds between committing View data store changes and making
	// documents visible to queries (default: 1000, to disable use: 0).
	CommitIntervalMsec *int64 `json:"commitIntervalMsec,omitempty"`

	// ConsolidationIntervalMsec Wait at least this many milliseconds between applying ‘consolidationPolicy’ to consolidate View data store
	// and possibly release space on the filesystem (default: 1000, to disable use: 0).
	ConsolidationIntervalMsec *int64 `json:"consolidationIntervalMsec,omitempty"`

	// ConsolidationPolicy The consolidation policy to apply for selecting which segments should be merged (default: {}).
	ConsolidationPolicy *ConsolidationPolicy `json:"consolidationPolicy,omitempty"`

	// WriteBufferIdle Maximum number of writers (segments) cached in the pool (default: 64, use 0 to disable)
	WriteBufferIdle *int64 `json:"writebufferIdle,omitempty"`

	// WriteBufferActive Maximum number of concurrent active writers (segments) that perform a transaction.
	// Other writers (segments) wait till current active writers (segments) finish (default: 0, use 0 to disable)
	WriteBufferActive *int64 `json:"writebufferActive,omitempty"`

	// WriteBufferSizeMax Maximum memory byte size per writer (segment) before a writer (segment) flush is triggered.
	// 0 value turns off this limit for any writer (buffer) and data will be flushed periodically based on the value defined for the flush thread (ArangoDB server startup option).
	// 0 value should be used carefully due to high potential memory consumption (default: 33554432, use 0 to disable)
	WriteBufferSizeMax *int64 `json:"writebufferSizeMax,omitempty"`

	// OptimizeTopK is an array of strings defining optimized sort expressions.
	// Introduced in v3.11.0, Enterprise Edition only.
	OptimizeTopK []string `json:"optimizeTopK,omitempty"`

	// InBackground You can set this option to true to create the index in the background,
	// which will not write-lock the underlying collection for as long as if the index is built in the foreground.
	// The default value is false.
	InBackground *bool `json:"inBackground,omitempty"`
}

type KeyGeneratorType string

type KeyGeneratorsResponse struct {
	KeyGenerators []string `json:"keyGenerators"`
}

type License struct {
	// Features describe properties of the license.
	Features LicenseFeatures `json:"features"`

	// License is an encrypted license key in Base64 encoding.
	License string `json:"license,omitempty"`

	// Status is a status of a license.
	Status LicenseStatus `json:"status,omitempty"`

	// Version is a version of a license.
	Version int `json:"version"`

	// Hash The hash value of the license.
	Hash string `json:"hash,omitempty"`
}

type LicenseFeatures struct {
	// Expires is expiry date as Unix timestamp (seconds since January 1st, 1970 UTC).
	Expires int `json:"expires"`
}

type LicenseStatus string

type ListBackupsResponse struct {
	Server  string                `json:"server,omitempty"`
	Backups map[string]BackupMeta `json:"list,omitempty"`
}

type LogLevels map[string]string

type LogLevelsGetOptions struct {
	// serverID describes log levels for a specific server ID.
	ServerID ServerID
}

type LogLevelsSetOptions struct {
	// serverID describes log levels for a specific server ID.
	ServerID ServerID
}

type MDIFieldType string

type Manifest struct {
	// Schema is the JSON schema URL for the manifest structure.
	Schema *string `json:"$schema,omitempty"`

	// Name is the name of the Foxx service.
	Name *string `json:"name,omitempty"`

	// Version is the service's semantic version.
	Version *string `json:"version,omitempty"`

	// License is the license identifier (e.g., "Apache-2.0").
	License *string `json:"license,omitempty"`

	// Repository contains details about the service's source repository.
	Repository *Repository `json:"repository,omitempty"`

	// Author is the main author of the service.
	Author *string `json:"author,omitempty"`

	// Contributors is a list of people who contributed to the service.
	Contributors []*Contributor `json:"contributors,omitempty"`

	// Description provides a human-readable explanation of the service.
	Description *string `json:"description,omitempty"`

	// Engines specifies the engine requirements for running the service.
	Engines *Engines `json:"engines,omitempty"`

	// DefaultDocument specifies the default document to serve (e.g., "index.html").
	DefaultDocument *string `json:"defaultDocument,omitempty"`

	// Main specifies the main entry point JavaScript file of the service.
	Main *string `json:"main,omitempty"`

	// Configuration contains service-specific configuration options.
	Configuration map[string]interface{} `json:"configuration,omitempty"`

	// Dependencies defines other services or packages this service depends on.
	Dependencies map[string]interface{} `json:"dependencies,omitempty"`

	// Files maps URL paths to static files or directories included in the service.
	Files map[string]interface{} `json:"files,omitempty"`

	// Scripts contains script definitions for service lifecycle hooks or tasks.
	Scripts map[string]interface{} `json:"scripts,omitempty"`
}

type NumberOfServersResponse struct {
	NoCoordinators   int        `json:"numberOfCoordinators,omitempty"`
	NoDBServers      int        `json:"numberOfDBServers,omitempty"`
	CleanedServerIDs []ServerID `json:"cleanedServers,omitempty"`
}

type OptimizerRules struct {
	// Name of the optimizer rule.
	Name  string `json:"name,omitempty"`
	Flags `json:"flags,omitempty"`
}

type PrimarySort struct {
	// Fields (Required) - An array of the fields to sort the index by and the direction to sort each field in.
	Fields []PrimarySortEntry `json:"fields,omitempty"`

	// Compression Defines how to compress the primary sort data
	Compression PrimarySortCompression `json:"compression,omitempty"`

	// Cache - Enable this option to always cache the primary sort columns in memory.
	// This can improve the performance of queries that utilize the primary sort order.
	Cache *bool `json:"cache,omitempty"`
}

type PrimarySortCompression string

type PrimarySortEntry struct {
	// Field An attribute path. The . character denotes sub-attributes.
	Field string `json:"field,required"`

	// Ascending The sorting direction
	Ascending bool `json:"asc,required"`
}

type QueryCacheEntriesRespObject struct {
	CacheRespObject `json:",inline"`
	// Result is the number of documents in the query result.
	Results *uint32 `json:"results,omitempty"`
	// RunTime is the time it took to execute the query in seconds.
	RunTime string `json:"runTime,omitempty"`
	// Size is the size of the query result in bytes.
	Size *uint64 `json:"size,omitempty"`
	// Started is the time when the query has been started.
	// Date and time at which the query result has been added to the cache.
	Started *string `json:"started,omitempty"`
}

type QueryCacheProperties struct {
	// IncludeSystem indicates whether the query cache includes system collections.
	IncludeSystem *bool `json:"includeSystem,omitempty"`
	// MaxEntrySize is the maximum size of a single query cache entry in bytes.
	MaxEntrySize *uint64 `json:"maxEntrySize,omitempty"`
	// MaxResults is the maximum number of results that can be stored in the query cache.
	MaxResults *uint16 `json:"maxResults,omitempty"`
	// MaxResultsSize is the maximum size of the query cache in bytes.
	MaxResultsSize *uint64 `json:"maxResultsSize,omitempty"`
	// Mode is the query cache mode.
	// The mode can be one of the following values:
	// "on" - the query cache is enabled and will be used for all queries.
	// "off" - the query cache is disabled and will not be used for any queries.
	// "demand" - the query cache is enabled, but will only be used for queries that explicitly request it.
	Mode *string `json:"mode,omitempty"`
}

type QueryOptions struct {
	// Set this to true to allow the Coordinator to ask any shard replica for the data, not only the shard leader.
	// This may result in “dirty reads”.
	// This option is ignored if this operation is part of a DatabaseTransaction (TransactionID option).
	// The header set when creating the transaction decides about dirty reads for the entire transaction,
	// not the individual read operations.
	AllowDirtyReads *bool `json:"-"`

	// To make this operation a part of a Stream Transaction, set this header to the transaction ID returned by the
	// DatabaseTransaction.BeginTransaction() method.
	TransactionID string `json:"-"`

	// Indicates whether the number of documents in the result set should be returned in the "count" attribute of the result.
	// Calculating the "count" attribute might have a performance impact for some queries in the future so this option is
	// turned off by default, and "count" is only returned when requested.
	Count bool `json:"count,omitempty"`

	// maximum number of result documents to be transferred from the server to the client in one roundtrip.
	// If this attribute is not set, a server-controlled default value will be used. A batchSize value of 0 is disallowed.
	BatchSize int `json:"batchSize,omitempty"`

	// flag to determine whether the AQL query cache shall be used. If set to false, then any query cache lookup
	// will be skipped for the query. If set to true, it will lead to the query cache being checked for the query
	// if the query cache mode is either on or demand.
	Cache bool `json:"cache,omitempty"`

	// the maximum number of memory (measured in bytes) that the query is allowed to use. If set, then the query will fail
	// with error "resource limit exceeded" in case it allocates too much memory. A value of 0 indicates that there is no memory limit.
	MemoryLimit int64 `json:"memoryLimit,omitempty"`

	// The time-to-live for the cursor (in seconds). The cursor will be removed on the server automatically after the specified
	// amount of time. This is useful to ensure garbage collection of cursors that are not fully fetched by clients.
	// If not set, a server-defined value will be used.
	TTL float64 `json:"ttl,omitempty"`

	// key/value pairs representing the bind parameters.
	BindVars map[string]interface{} `json:"bindVars,omitempty"`
	Options  QuerySubOptions        `json:"options,omitempty"`
}

type QueryPlanCacheRespObject struct {
	CacheRespObject `json:",inline"`
	// QueryHash is the hash of the AQL query string.
	QueryHash *uint32 `json:"queryHash,omitempty"`
	// FullCount indicates whether the query result contains the full count of documents.
	FullCount *bool `json:"fullCount,omitempty"`
	// Created is the time when the query plan has been added to the cache.
	Created *string `json:"created,omitempty"`
	// MemoryUsage is the memory usage of the cached plan in bytes.
	// This is the amount of memory used by the cached plan on the server.
	MemoryUsage *uint64 `json:"memoryUsage,omitempty"`
}

type QueryProperties struct {
	Enabled              *bool    `json:"enabled"`
	TrackSlowQueries     *bool    `json:"trackSlowQueries"`
	TrackBindVars        *bool    `json:"trackBindVars"`
	MaxSlowQueries       *int     `json:"maxSlowQueries"`
	SlowQueryThreshold   *float64 `json:"slowQueryThreshold"`
	MaxQueryStringLength *int     `json:"maxQueryStringLength"`
}

type QueryRequest struct {
	Query string `json:"query"`
}

type QuerySubOptions struct {
	// If you set this option to true and execute the query against a cluster deployment, then the Coordinator is
	// allowed to read from any shard replica and not only from the leader.
	// You may observe data inconsistencies (dirty reads) when reading from followers, namely obsolete revisions of
	// documents because changes have not yet been replicated to the follower, as well as changes to documents before
	// they are officially committed on the leader.
	//
	//This feature is only available in the Enterprise Edition.
	AllowDirtyReads bool `json:"allowDirtyReads,omitempty"`

	// AllowRetry If set to `true`, ArangoDB will store cursor results in such a way
	// that batch reads can be retried in the case of a communication error.
	AllowRetry bool `json:"allowRetry,omitempty"`

	// When set to true, the query will throw an exception and abort instead of producing a warning.
	// This option should be used during development to catch potential issues early.
	// When the attribute is set to false, warnings will not be propagated to exceptions and will be returned
	// with the query result. There is also a server configuration option --query.fail-on-warning for setting
	// the default value for failOnWarning so it does not need to be set on a per-query level.
	FailOnWarning *bool `json:"failOnWarning,omitempty"`

	// If set to true or not specified, this will make the query store the data it reads via the RocksDB storage engine
	// in the RocksDB block cache. This is usually the desired behavior. The option can be set to false for queries that
	// are known to either read a lot of data which would thrash the block cache, or for queries that read data which
	// are known to be outside of the hot set. By setting the option to false, data read by the query will not make it
	// into the RocksDB block cache if not already in there, thus leaving more room for the actual hot set.
	FillBlockCache bool `json:"fillBlockCache,omitempty"`

	// if set to true and the query contains a LIMIT clause, then the result will have an extra attribute with the sub-attributes
	// stats and fullCount, { ... , "extra": { "stats": { "fullCount": 123 } } }. The fullCount attribute will contain the number
	// of documents in the result before the last LIMIT in the query was applied. It can be used to count the number of documents
	// that match certain filter criteria, but only return a subset of them, in one go. It is thus similar to MySQL's SQL_CALC_FOUND_ROWS hint.
	// Note that setting the option will disable a few LIMIT optimizations and may lead to more documents being processed, and
	// thus make queries run longer. Note that the fullCount attribute will only be present in the result if the query has a LIMIT clause
	// and the LIMIT clause is actually used in the query.
	FullCount bool `json:"fullCount,omitempty"`

	// The maximum number of operations after which an intermediate commit is performed automatically.
	IntermediateCommitCount *int `json:"intermediateCommitCount,omitempty"`

	// The maximum total size of operations after which an intermediate commit is performed automatically.
	IntermediateCommitSize *int `json:"intermediateCommitSize,omitempty"`

	// A threshold for the maximum number of OR sub-nodes in the internal representation of an AQL FILTER condition.
	// Yon can use this option to limit the computation time and memory usage when converting complex AQL FILTER
	// conditions into the internal DNF (disjunctive normal form) format. FILTER conditions with a lot of logical
	// branches (AND, OR, NOT) can take a large amount of processing time and memory. This query option limits
	// the computation time and memory usage for such conditions.
	//
	// Once the threshold value is reached during the DNF conversion of a FILTER condition, the conversion is aborted,
	// and the query continues with a simplified internal representation of the condition,
	// which cannot be used for index lookups.
	//
	// You can set the threshold globally instead of per query with the --query.max-dnf-condition-members startup option.
	MaxDNFConditionMembers *int `json:"maxDNFConditionMembers,omitempty"`

	// The number of execution nodes in the query plan after that stack splitting is performed to avoid a potential
	// stack overflow. Defaults to the configured value of the startup option `--query.max-nodes-per-callstack`.
	// This option is only useful for testing and debugging and normally does not need any adjustment.
	MaxNodesPerCallstack *int `json:"maxNodesPerCallstack,omitempty"`

	// Limits the maximum number of plans that are created by the AQL query optimizer.
	MaxNumberOfPlans *int `json:"maxNumberOfPlans,omitempty"`

	// MaxRuntime specify the timeout which can be used to kill a query on the server after the specified
	// amount in time. The timeout value is specified in seconds. A value of 0 means no timeout will be enforced.
	MaxRuntime float64 `json:"maxRuntime,omitempty"`

	// The transaction size limit in bytes.
	MaxTransactionSize *int `json:"maxTransactionSize,omitempty"`

	// Limits the maximum number of warnings a query will return. The number of warnings a query will return is limited
	// to 10 by default, but that number can be increased or decreased by setting this attribute.
	MaxWarningCount *int `json:"maxWarningCount,omitempty"`

	// Optimizer contains options related to the query optimizer.
	Optimizer QuerySubOptionsOptimizer `json:"optimizer,omitempty"`

	// Profile If set to 1, then the additional query profiling information is returned in the profile sub-attribute
	// of the extra return attribute, unless the query result is served from the query cache.
	// If set to 2, the query includes execution stats per query plan node in stats.nodes
	// sub-attribute of the extra return attribute.
	// Additionally, the query plan is returned in the extra.plan sub-attribute.
	Profile uint `json:"profile,omitempty"`

	// This Enterprise Edition parameter allows to configure how long a DBServer will have time to bring the SatelliteCollections
	// involved in the query into sync. The default value is 60.0 (seconds). When the max time has been reached the query will be stopped.
	SatelliteSyncWait float64 `json:"satelliteSyncWait,omitempty"`

	// Let AQL queries (especially graph traversals) treat collection to which a user has no access rights for as if
	// these collections are empty. Instead of returning a forbidden access error, your queries execute normally.
	// This is intended to help with certain use-cases: A graph contains several collections and different users
	// execute AQL queries on that graph. You can naturally limit the accessible results by changing the access rights
	// of users on collections.
	//
	// This feature is only available in the Enterprise Edition.
	SkipInaccessibleCollections *bool `json:"skipInaccessibleCollections,omitempty"`

	// This option allows queries to store intermediate and final results temporarily on disk if the amount of memory
	// used (in bytes) exceeds the specified value. This is used for decreasing the memory usage during the query execution.
	//
	// This option only has an effect on queries that use the SORT operation but without a LIMIT, and if you enable
	//the spillover feature by setting a path for the directory to store the temporary data in with
	// the --temp.intermediate-results-path startup option.
	//
	// Default value: 128MB.
	SpillOverThresholdMemoryUsage *int `json:"spillOverThresholdMemoryUsage,omitempty"`

	// This option allows queries to store intermediate and final results temporarily on disk if the number of rows
	// produced by the query exceeds the specified value. This is used for decreasing the memory usage during the query
	// execution. In a query that iterates over a collection that contains documents, each row is a document, and in
	// a query that iterates over temporary values (i.e. FOR i IN 1..100), each row is one of such temporary values.
	//
	// This option only has an effect on queries that use the SORT operation but without a LIMIT, and if you enable
	// the spillover feature by setting a path for the directory to store the temporary data in with
	// the --temp.intermediate-results-path startup option.
	//
	// Default value: 5000000 rows.
	SpillOverThresholdNumRows *int `json:"spillOverThresholdNumRows,omitempty"`

	// Specify true and the query will be executed in a streaming fashion. The query result is not stored on
	// the server, but calculated on the fly. Beware: long-running queries will need to hold the collection
	// locks for as long as the query cursor exists. When set to false a query will be executed right away in
	// its entirety.
	Stream bool `json:"stream,omitempty"`

	// [unofficial] Limits the maximum number of plans that are created by the AQL query optimizer.
	MaxPlans int `json:"maxPlans,omitempty"`

	// [unofficial] ShardId query option
	ShardIds []string `json:"shardIds,omitempty"`

	// [unofficial] This query option can be used in complex queries in case the query optimizer cannot
	// automatically detect that the query can be limited to only a single server (e.g. in a Disjoint SmartGraph case).
	ForceOneShardAttributeValue *string `json:"forceOneShardAttributeValue,omitempty"`
}