arangodb

type AbortTransactionOptions struct{}

type AccessTokenInfo struct {
	// Id is the unique identifier for the access token.
	Id *int `json:"id,omitempty"`

	// Embed the AccessTokenRequest fields (Name and ValidUntil) for reference.
	AccessTokenRequest

	// CreatedAt is the Unix timestamp when the token was created.
	CreatedAt *int64 `json:"created_at,omitempty"`

	// Fingerprint is a unique string associated with the token,
	// useful for tracking or verifying the token without revealing it.
	Fingerprint *string `json:"fingerprint,omitempty"`

	// Active indicates whether the token is currently active or has been revoked/expired.
	Active *bool `json:"active,omitempty"`
}

type AccessTokenRequest struct {
	// Name is a descriptive name for the access token (e.g., "Token for Service A").
	// This helps identify the token later. Required field.
	Name *string `json:"name,omitempty"`

	// ValidUntil is the Unix timestamp (seconds since epoch) until which the token remains valid.
	// Required field. After this time, the token will automatically expire.
	ValidUntil *int64 `json:"valid_until,omitempty"`
}

type AccessTokenResponse struct {
	// Tokens is a list of all access tokens associated with a user.
	Tokens []AccessTokenInfo `json:"tokens,omitempty"`
}

type AdminLogEntriesOptions struct {
	// Upto log level
	Upto string `json:"upto"` // (default: "info")

	// Returns all log entries of log level level.
	//  Note that the query parameters upto and level are mutually exclusive.
	Level *string `json:"level,omitempty"`

	// Start position
	Start int `json:"start"` // (default: 0)

	// Restricts the result to at most size log entries.
	Size *int `json:"size,omitempty"`

	// Offset position
	Offset int `json:"offset"` // (default: 0)

	// Only return the log entries containing the text specified in search.
	Search *string `json:"search,omitempty"`

	// Sort the log entries either ascending (if sort is asc) or
	// descending (if sort is desc) according to their id values.
	Sort string `json:"sort,omitempty"` // (default: "asc")

	// Returns all log entries of the specified server.
	//  If no serverId is given, the asked server will reply.
	// This parameter is only meaningful on Coordinators.
	ServerId *string `json:"serverId,omitempty"`
}

type AdminLogEntriesResponse struct {
	// Total number of log entries
	Total int `json:"total"`

	// List of log messages
	Messages []MessageObject `json:"messages"`
}

type AgencyCommInfo struct {
	// List of agency endpoints
	Endpoints *[]string `json:"endpoints,omitempty"`
}

type AgencyInfo struct {
	// Agency communication details
	AgencyComm *AgencyCommInfo `json:"agencyComm,omitempty"`
}

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 ApiCallsObject struct {
	// TimeStamp is the UTC timestamp when the API call was executed.
	TimeStamp string `json:"timeStamp"`

	// RequestType is the HTTP method used for the call (e.g., GET, POST).
	RequestType string `json:"requestType"`

	// Path is the HTTP request path that was accessed.
	Path string `json:"path"`

	// Database is the name of the database the API call was executed against.
	Database string `json:"database"`
}

type ApiCallsResponse struct {
	Calls []ApiCallsObject `json:"calls"`
}

type ApplierConfigResponse struct {
	// Logger server endpoint (e.g., tcp://127.0.0.1:8529)
	Endpoint *string `json:"endpoint,omitempty"`
	// Database name (e.g., "_system")
	Database *string `json:"database,omitempty"`
	// Username for authentication
	Username *string `json:"username,omitempty"`
	// Password for authentication
	Password *string `json:"password,omitempty"`
	// Maximum connection attempts before stopping
	MaxConnectRetries int `json:"maxConnectRetries"`
	// Timeout (seconds) for connecting to endpoint
	ConnectTimeout int `json:"connectTimeout"`
	// Timeout (seconds) for individual requests
	RequestTimeout int `json:"requestTimeout"`
	// Max size of log transfer packets
	ChunkSize int `json:"chunkSize"`
	// Whether applier auto-starts on server startup
	AutoStart bool `json:"autoStart"`
	// Whether adaptive polling is used
	AdaptivePolling bool `json:"adaptivePolling"`
	// Whether system collections are included
	IncludeSystem bool `json:"includeSystem"`
	// Whether full automatic resync is performed if needed
	AutoResync bool `json:"autoResync"`
	// Number of auto-resync retries before giving up
	AutoResyncRetries int `json:"autoResyncRetries"`
	// Max wait time (seconds) for initial sync
	InitialSyncMaxWaitTime int `json:"initialSyncMaxWaitTime"`
	// Idle time (seconds) before retrying failed connection
	ConnectionRetryWaitTime int `json:"connectionRetryWaitTime"`
	// Minimum idle wait time (seconds) when no new data
	IdleMinWaitTime int `json:"idleMinWaitTime"`
	// Maximum idle wait time (seconds) when no new data (may be fractional, hence float64)
	IdleMaxWaitTime float64 `json:"idleMaxWaitTime"`
	// If true, aborts if start tick not available on leader
	RequireFromPresent bool `json:"requireFromPresent"`
	// If true, logs each applier operation (debugging only)
	Verbose bool `json:"verbose"`
	// Type of collection restriction ("include" or "exclude")
	RestrictType string `json:"restrictType"`
	// Collections included/excluded depending on RestrictType
	RestrictCollections []string `json:"restrictCollections"`
	// Max number of errors to ignore
	IgnoreErrors *int `json:"ignoreErrors,omitempty"`
	// SSL protocol version
	SslProtocol *int `json:"sslProtocol,omitempty"`
	// Whether to skip create/drop collection operations
	SkipCreateDrop *bool `json:"skipCreateDrop,omitempty"`
	// Max packet size (bytes)
	MaxPacketSize *int64 `json:"maxPacketSize,omitempty"`
	// Whether to include Foxx queues. Deprecated: Foxx relies on server-side JavaScript and is planned to be removed in ArangoDB v4.0.
	IncludeFoxxQueues *bool `json:"includeFoxxQueues,omitempty"`
	// Whether incremental sync is used
	Incremental *bool `json:"incremental,omitempty"`
}

type ApplierOptions struct {
	// AdaptivePolling controls whether the replication applier uses adaptive polling.
	AdaptivePolling *bool `json:"adaptivePolling,omitempty"`

	// AutoResync, if set to true, allows the applier to automatically
	// trigger a full resynchronization if it falls too far behind.
	AutoResync *bool `json:"autoResync,omitempty"`

	// AutoResyncRetries defines how many times the applier should retry
	// automatic resynchronization after failure.
	AutoResyncRetries *int `json:"autoResyncRetries,omitempty"`

	// AutoStart indicates if the applier should start automatically
	// once configured.
	AutoStart *bool `json:"autoStart,omitempty"`

	// ChunkSize is the maximum size (in bytes) of the data batches
	// fetched by the applier.
	ChunkSize *int `json:"chunkSize,omitempty"`

	// ConnectTimeout is the timeout (in seconds) for the initial
	// connection attempt to the master endpoint.
	ConnectTimeout *int `json:"connectTimeout,omitempty"`

	// ConnectionRetryWaitTime is the wait time (in seconds) before retrying
	// a failed connection attempt.
	ConnectionRetryWaitTime *int `json:"connectionRetryWaitTime,omitempty"`

	// Database is the name of the database on the master that the applier
	// should replicate from.
	Database *string `json:"database,omitempty"`

	// Endpoint specifies the master server endpoint (e.g., "tcp://127.0.0.1:8529")
	// from which replication data is pulled. This is required.
	Endpoint *string `json:"endpoint,omitempty"`

	// IdleMaxWaitTime is the maximum wait time (in seconds) between
	// polling requests when the applier is idle.
	IdleMaxWaitTime *int `json:"idleMaxWaitTime,omitempty"`

	// IdleMinWaitTime is the minimum wait time (in seconds) between
	// polling requests when the applier is idle.
	IdleMinWaitTime *int `json:"idleMinWaitTime,omitempty"`

	// IncludeSystem specifies whether system collections should be
	// replicated as well.
	IncludeSystem *bool `json:"includeSystem,omitempty"`

	// InitialSyncMaxWaitTime defines the maximum wait time (in seconds)
	// for the initial synchronization step.
	InitialSyncMaxWaitTime *int `json:"initialSyncMaxWaitTime,omitempty"`

	// MaxConnectRetries is the maximum number of retries for
	// initial connection attempts.
	MaxConnectRetries *int `json:"maxConnectRetries,omitempty"`

	// Password is the password used when connecting to the master.
	Password *string `json:"password,omitempty"`

	// RequestTimeout specifies the timeout (in seconds) for individual
	// HTTP requests made by the applier.
	RequestTimeout *int `json:"requestTimeout,omitempty"`

	// RequireFromPresent, if true, requires the replication to start from
	// the present and not accept missing history.
	RequireFromPresent *bool `json:"requireFromPresent,omitempty"`

	// RestrictCollections is an optional list of collections to include
	// or exclude in replication, depending on RestrictType.
	RestrictCollections *[]string `json:"restrictCollections,omitempty"`

	// RestrictType determines how RestrictCollections is interpreted:
	// "include" or "exclude".
	RestrictType *string `json:"restrictType,omitempty"`

	// Username is the username used when connecting to the master.
	Username *string `json:"username,omitempty"`

	// Verbose controls the verbosity of the applier's logging.
	Verbose *bool `json:"verbose,omitempty"`
}

type ApplierProgress struct {
	// Time is when the progress message was recorded.
	Time *string `json:"time,omitempty"`

	// Message provides a short description of the progress (e.g., "applied batch").
	Message *string `json:"message,omitempty"`

	// FailedConnects counts failed connection attempts at this progress point.
	FailedConnects *int `json:"failedConnects,omitempty"`
}

type ApplierServer struct {
	// Version is the ArangoDB version.
	Version *string `json:"version"`

	// ServerId is the unique ID of the server.
	ServerId *string `json:"serverId"`
}

type ApplierState struct {
	// Started indicates when the applier was started.
	Started *string `json:"started"`

	// Running is true if the applier is currently running.
	Running *bool `json:"running"`

	// Phase describes the current applier phase (e.g., "running", "inactive").
	Phase *string `json:"phase"`

	// LastAppliedContinuousTick is the tick of the last operation applied by the applier.
	LastAppliedContinuousTick *string `json:"lastAppliedContinuousTick"`

	// LastProcessedContinuousTick is the tick of the last operation processed.
	LastProcessedContinuousTick *string `json:"lastProcessedContinuousTick"`

	// LastAvailableContinuousTick is the last tick available on the replication logger.
	LastAvailableContinuousTick *string `json:"lastAvailableContinuousTick"`

	// SafeResumeTick is the tick from which the applier can safely resume.
	SafeResumeTick *string `json:"safeResumeTick"`

	// TicksBehind indicates how many ticks the applier is behind the latest log.
	TicksBehind *int64 `json:"ticksBehind,omitempty"`

	// Progress provides detailed information about the last progress event.
	Progress *ApplierProgress `json:"progress,omitempty"`

	// TotalRequests is the total number of requests made by the applier.
	TotalRequests *int `json:"totalRequests,omitempty"`

	// TotalFailedConnects counts the number of failed connection attempts.
	TotalFailedConnects *int `json:"totalFailedConnects,omitempty"`

	// TotalEvents is the total number of replication events processed.
	TotalEvents *int `json:"totalEvents,omitempty"`

	// TotalDocuments is the number of document operations applied.
	TotalDocuments *int `json:"totalDocuments,omitempty"`

	// TotalRemovals is the number of document removal operations applied.
	TotalRemovals *int `json:"totalRemovals,omitempty"`

	// TotalResyncs counts how many times a resync was triggered.
	TotalResyncs *int `json:"totalResyncs,omitempty"`

	// TotalOperationsExcluded is the number of operations ignored (due to filters, etc.).
	TotalOperationsExcluded *int `json:"totalOperationsExcluded,omitempty"`

	// TotalApplyTime is the cumulative time (in ms) spent applying operations.
	TotalApplyTime *int `json:"totalApplyTime,omitempty"`

	// AverageApplyTime is the average time (in ms) spent applying operations.
	AverageApplyTime *int `json:"averageApplyTime,omitempty"`

	// TotalFetchTime is the cumulative time (in ms) spent fetching operations.
	TotalFetchTime *int `json:"totalFetchTime,omitempty"`

	// AverageFetchTime is the average time (in ms) spent fetching operations.
	AverageFetchTime *int `json:"averageFetchTime,omitempty"`

	// LastError contains information about the last error, if any.
	LastError *struct {
		// ErrorNum is the numeric error code of the last error.
		ErrorNum *int `json:"errorNum,omitempty"`
		// ErrorMessage is the descriptive message of the last error.
		ErrorMessage *string `json:"errorMessage,omitempty"`
		// Time is the timestamp of the last error.
		Time time.Time `json:"time,omitempty"`
	} `json:"lastError,omitempty"`

	// Time is the timestamp of this applier state snapshot.
	Time time.Time `json:"time,omitempty"`
}

type ApplierStateResp struct {
	// State holds detailed information about the applier's current state.
	State ApplierState `json:"state"`

	// Server contains information about the server providing this state.
	Server ApplierServer `json:"server"`

	// Endpoint is the endpoint this applier is connected to.
	Endpoint *string `json:"endpoint"`
}

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 {
	// Deprecated: Only available up to v3.12.6.
	MinScore *int64 `json:"minScore,omitempty"`

	// Deprecated: Only available up to v3.12.6.
	// Deprecated since v3.12.7. Use segment byte size skew–based consolidation.
	MinSegments *int64 `json:"segmentsMin,omitempty"`

	// MaxSegments specifies the maximum number of segments that will be evaluated as candidates for consolidation.
	// Deprecated: Only available up to v3.12.6.
	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.
	// Deprecated: Only available up to v3.12.6.
	SegmentsBytesFloor *int64 `json:"segmentsBytesFloor,omitempty"`

	// MaxSkewThreshold defines the maximum allowed size skew between segment files
	// (value between 0.0 and 1.0) before they are considered for consolidation.
	// Default: 0.4. Available from ArangoDB v3.12.7 onward.
	MaxSkewThreshold *float64 `json:"maxSkewThreshold,omitempty"`

	// MinDeletionRatio defines the minimum ratio of deleted documents (0.0–1.0)
	// required to trigger segment cleanup.
	// Default: 0.5. Available from ArangoDB v3.12.7 onward.
	MinDeletionRatio *float64 `json:"minDeletionRatio,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; from v3.12.5 onward also in Community Edition.
	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; from v3.12.5 onward also in Community Edition.
	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; from v3.12.5 onward also in Community Edition.
	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; from v3.12.5 onward also in Community Edition.
	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; from v3.12.5 onward also in Community Edition.
	// 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"`

	// (Cluster only; Enterprise Edition; from v3.12.5 onward also in Community Edition.) 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 BasicProperties struct {
	// Unique identifier (collection ID, view ID, etc.)
	ID *string `json:"id,omitempty"`
	// Human-readable name
	Name *string `json:"name,omitempty"`
}

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
	ClientReplication
	ClientAccessTokens
}

type ClientAccessTokens interface {
	// CreateAccessToken creates a new access token for the specified user.
	// Permissions:
	//   - You can always create an access token for yourself.
	//   - To create a token for another user, you need admin access
	//     to the _system database.
	CreateAccessToken(ctx context.Context, user *string, req AccessTokenRequest) (CreateAccessTokenResponse, error)

	// DeleteAccessToken deletes a specific access token for a given user.
	DeleteAccessToken(ctx context.Context, user *string, tokenId *int) error

	// GetAllAccessToken retrieves all access tokens for a given user.
	GetAllAccessToken(ctx context.Context, user *string) (AccessTokenResponse, error)
}

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

	// GetSystemTime returns the current system time as a Unix timestamp with microsecond precision.
	GetSystemTime(ctx context.Context, dbName string) (float64, error)

	// GetServerStatus returns status information about the server.
	GetServerStatus(ctx context.Context, dbName string) (ServerStatusResponse, error)

	// GetDeploymentSupportInfo retrieves deployment information for support purposes.
	GetDeploymentSupportInfo(ctx context.Context) (SupportInfoResponse, error)

	// GetStartupConfiguration return the effective configuration of the queried arangod instance.
	GetStartupConfiguration(ctx context.Context) (map[string]interface{}, error)

	// GetStartupConfigurationDescription fetches the available startup configuration
	// options of the queried arangod instance.
	GetStartupConfigurationDescription(ctx context.Context) (map[string]interface{}, error)

	// ReloadRoutingTable reloads the routing information from the _routing system
	// collection, causing Foxx services to rebuild their routing table.
	ReloadRoutingTable(ctx context.Context, dbName string) error

	// ExecuteAdminScript executes JavaScript code on the server.
	// Note: Requires ArangoDB to be started with --javascript.allow-admin-execute enabled.
	// Deprecated: Server-side JavaScript is planned to be removed in ArangoDB v4.0.
	ExecuteAdminScript(ctx context.Context, dbName string, script *string) (interface{}, error)

	// CompactDatabases can be used to reclaim disk space after substantial data deletions have taken place,
	// by compacting the entire database system data.
	// The endpoint requires superuser access.
	CompactDatabases(ctx context.Context, opts *CompactOpts) (map[string]interface{}, error)

	// GetTLSData returns information about the server's TLS configuration.
	// This call requires authentication.
	GetTLSData(ctx context.Context, dbName string) (TLSDataResponse, error)

	// ReloadTLSData triggers a reload of all TLS data (server key, client-auth CA)
	// and returns the updated TLS configuration summary.
	// Requires superuser rights.
	ReloadTLSData(ctx context.Context) (TLSDataResponse, error)

	// RotateEncryptionAtRestKey reloads the user-supplied encryption key from
	// the --rocksdb.encryption-keyfolder and re-encrypts the internal encryption key.
	// Requires superuser rights and is not available on Coordinators.
	RotateEncryptionAtRestKey(ctx context.Context) ([]EncryptionKey, error)
	// GetJWTSecrets retrieves information about the currently loaded JWT secrets
	// for a given database.
	// Requires a superuser JWT for authorization.
	GetJWTSecrets(ctx context.Context, dbName string) (JWTSecretsResult, error)

	// ReloadJWTSecrets forces the server to reload the JWT secrets from disk.
	// Requires a superuser JWT for authorization.
	ReloadJWTSecrets(ctx context.Context) (JWTSecretsResult, error)

	// GetDeploymentId retrieves the unique deployment ID for the ArangoDB deployment.
	GetDeploymentId(ctx context.Context) (DeploymentIdResponse, error)

	// Shutdown initiates a shutdown sequence on a coordinator or single server.
	// Behavior:
	//   - Requires administrative privileges.
	//   - The database name itself is not important as long as the authenticated
	//     user has read access to the database and admin access to `_system`.
	//   - When `graceful` is true, a soft (graceful) shutdown is triggered.
	//     In this case, ShutdownInfo can be used to track shutdown progress.
	// Available since:
	// ArangoDB v3.7.12, v3.8.1, v3.9.0
	Shutdown(ctx context.Context, dbName string, graceful *bool) error

	// ShutdownInfo returns information about the progress of a soft shutdown
	// of a Coordinator.
	// The response reports the number of ongoing operations (transactions,
	// cursors, async jobs, low priority requests, etc.). Once all values
	// reach zero, the allClear flag is set and the Coordinator shuts down
	// automatically.
	// This API is only available on Coordinators.
	// Available since:
	// ArangoDB v3.7.12, v3.8.1, v3.9.0
	ShutdownInfo(ctx context.Context, dbName string) (ShutdownInfo, 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

	// ClusterStatistics retrieves statistical information from a specific DBServer
	// in an ArangoDB cluster. The statistics include system, client, HTTP, and server
	// metrics such as CPU usage, memory, connections, requests, and transaction details.
	//
	// Deprecated: ArangoDB 4.0 removes the Statistics REST API, including GET /_admin/cluster/statistics.
	// Use ClientAdmin.Metrics on ArangoDB 4.0+ (GET /_admin/metrics), or deprecated ClientAdmin.GetMetrics
	// on 3.x (GET .../_admin/metrics/v2); pass a non-nil serverId to scope metrics to a DB-Server where supported.
	ClusterStatistics(ctx context.Context, dbServer string) (ClusterStatisticsResponse, error)

	// ClusterEndpoints returns the endpoints of a cluster.
	ClusterEndpoints(ctx context.Context) (ClusterEndpointsResponse, error)

	// GetDBServerMaintenance retrieves the maintenance status of a given DB-Server.
	// It checks whether the specified DB-Server is in maintenance mode and,
	// if so, until what date and time (in ISO 8601 format) the maintenance will last.
	GetDBServerMaintenance(ctx context.Context, dbServer string) (ClusterMaintenanceResponse, error)

	// SetDBServerMaintenance sets the maintenance mode for a specific DB-Server.
	// This endpoint affects only the given DB-Server. When in maintenance mode,
	// the server is excluded from supervision actions such as shard distribution
	// or failover. This is typically used during planned restarts or upgrades.
	SetDBServerMaintenance(ctx context.Context, dbServer string, opts *ClusterMaintenanceOpts) error

	// SetClusterMaintenance sets the cluster-wide supervision maintenance mode.
	// This endpoint affects the supervision (Agency) component of the cluster.
	// While enabled, automatic failovers, shard movements, and repair jobs
	// are suspended. The mode can be:
	//
	//   - "on":   Enable maintenance mode for the default 60 minutes.
	//   - "off":  Disable maintenance mode immediately.
	//   - "<number>":  Enable maintenance mode for <number> seconds.
	//
	// Be aware that no automatic failovers of any kind will take place while
	// the maintenance mode is enabled. The supervision will reactivate itself
	// automatically after the duration expires.
	SetClusterMaintenance(ctx context.Context, mode *string) error

	// GetClusterRebalance retrieves the current cluster imbalance status.
	// It computes the imbalance across leaders and shards, and includes the number of
	// ongoing and pending move shard operations.
	GetClusterRebalance(ctx context.Context) (RebalanceResponse, error)

	// ComputeClusterRebalance computes a set of move shard operations to improve cluster balance.
	ComputeClusterRebalance(ctx context.Context, opts *RebalanceRequestBody) (RebalancePlan, error)

	// ExecuteClusterRebalance executes a set of shard move operations on the cluster.
	ExecuteClusterRebalance(ctx context.Context, opts *ExecuteRebalanceRequestBody) error

	// ComputeAndExecuteClusterRebalance computes moves internally then executes them.
	ComputeAndExecuteClusterRebalance(ctx context.Context, opts *RebalanceRequestBody) (RebalancePlan, 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

	// Logs retrieve logs from server in ArangoDB 3.8.0+ format
	Logs(ctx context.Context, queryParams *AdminLogEntriesOptions) (AdminLogEntriesResponse, error)

	// DeleteLogLevels removes log levels for a specific server.
	DeleteLogLevels(ctx context.Context, serverId *string) (LogLevelResponse, error)

	// GetStructuredLogSettings returns the server's current structured log settings.
	GetStructuredLogSettings(ctx context.Context) (LogSettingsOptions, error)

	// UpdateStructuredLogSettings modifies and returns the server's current structured log settings.
	UpdateStructuredLogSettings(ctx context.Context, opts *LogSettingsOptions) (LogSettingsOptions, error)

	// GetRecentAPICalls gets a list of the most recent requests with a timestamp and the endpoint
	GetRecentAPICalls(ctx context.Context, dbName string) (ApiCallsResponse, error)

	// GetMetrics returns Prometheus-format metrics from GET .../_admin/metrics/v2.
	//
	// Deprecated: This uses the Metrics API v2 path. ArangoDB 4.0 removes /_admin/metrics/v2;
	// the metric names and attributes also differ from GET .../_admin/metrics (see Metrics).
	// Use Metrics for ArangoDB 4.0 and later.
	GetMetrics(ctx context.Context, dbName string, serverId *string) ([]byte, error)

	// Metrics returns Prometheus-format metrics from GET .../_admin/metrics (without the v2 suffix).
	// The response schema differs from deprecated GetMetrics (…/metrics/v2); see release notes.
	// Intended for ArangoDB 4.0+ where the v2 metrics endpoint is removed.
	Metrics(ctx context.Context, dbName string, serverId *string) ([]byte, 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 ClientError struct {
	Code    int
	Message string
}

type ClientReplication interface {
	// CreateNewBatch creates a new replication batch.
	CreateNewBatch(ctx context.Context, dbName string, DBserver *string, state *bool, opt CreateNewBatchOptions) (CreateNewBatchResponse, error)
	// GetInventory retrieves the inventory of a replication batch.
	GetInventory(ctx context.Context, dbName string, params InventoryQueryParams) (InventoryResponse, error)
	// DeleteBatch deletes a replication batch.
	DeleteBatch(ctx context.Context, dbName string, DBserver *string, batchId string) error
	// ExtendBatch extends the TTL of a replication batch.
	ExtendBatch(ctx context.Context, dbName string, DBserver *string, batchId string, opt CreateNewBatchOptions) error
	// Dump retrieves a chunk of data from a collection in a replication batch.
	Dump(ctx context.Context, dbName string, params ReplicationDumpParams) ([]byte, error)
	// LoggerState retrieves the state of the replication logger.
	LoggerState(ctx context.Context, dbName string, DBserver *string) (LoggerStateResponse, error)
	// LoggerFirstTick calls GET /_api/replication/logger-first-tick for the first tick of the replication logger.
	//
	// Deprecated: Do not use on ArangoDB 4.0 or newer. That release removes
	// GET /_api/replication/logger-first-tick.
	// For incremental write-ahead log updates, the 4.0 HTTP API documents
	// GET /_db/{database-name}/_api/wal/tail instead.
	// On older versions this method still works.
	LoggerFirstTick(ctx context.Context, dbName string) (LoggerFirstTickResponse, error)
	// LoggerTickRange calls GET /_api/replication/logger-tick-ranges for tick ranges in WAL logfiles.
	// On older servers the response may be a JSON array or a standard envelope whose "result" is that array.
	//
	// Deprecated: Do not use on ArangoDB 4.0 or newer. That release removes
	// GET /_api/replication/logger-tick-ranges.
	// For incremental WAL tailing, the 4.0 HTTP API documents
	// GET /_db/{database-name}/_api/wal/tail instead.
	// On older versions this method still works.
	LoggerTickRange(ctx context.Context, dbName string) ([]LoggerTickRangeResponseObj, error)
	// GetApplierConfig retrieves the configuration of the replication applier.
	GetApplierConfig(ctx context.Context, dbName string, global *bool) (ApplierConfigResponse, error)
	// UpdateApplierConfig updates the configuration of the replication applier.
	UpdateApplierConfig(ctx context.Context, dbName string, global *bool, opts ApplierOptions) (ApplierConfigResponse, error)
	// ApplierStart starts the replication applier.
	ApplierStart(ctx context.Context, dbName string, global *bool, from *string) (ApplierStateResp, error)
	// ApplierStop stops the replication applier.
	ApplierStop(ctx context.Context, dbName string, global *bool) (ApplierStateResp, error)
	// GetApplierState retrieves the state of the replication applier.
	GetApplierState(ctx context.Context, dbName string, global *bool) (ApplierStateResp, error)
	// GetReplicationServerId retrieves the server ID used for replication.
	GetReplicationServerId(ctx context.Context, dbName string) (string, error)
	// MakeFollower makes the current server a follower of the specified leader.
	MakeFollower(ctx context.Context, dbName string, opts ApplierOptions) (ApplierStateResp, error)
	// GetWALRange retrieves the WAL range information.
	GetWALRange(ctx context.Context, dbName string) (WALRangeResponse, error)
	// GetWALLastTick retrieves the last available tick information.
	GetWALLastTick(ctx context.Context, dbName string) (WALLastTickResponse, error)
	// GetWALTail retrieves the tail of the WAL.
	GetWALTail(ctx context.Context, dbName string, params *WALTailOptions) ([]byte, error)
	// RebuildShardRevisionTree rebuilds the Merkle tree for a shard.
	RebuildShardRevisionTree(ctx context.Context, dbName string, shardID ShardID) error
	// GetShardRevisionTree retrieves the Merkle tree for a shard.
	GetShardRevisionTree(ctx context.Context, dbName string, shardID ShardID, batchId string) (json.RawMessage, error)
	// ListDocumentRevisionsInRange retrieves documents by their revision IDs.
	ListDocumentRevisionsInRange(ctx context.Context, dbName string, queryParams RevisionQueryParams, opts [][2]string) ([][2]string, error)
	// FetchRevisionDocuments retrieves documents by their revision IDs.
	FetchRevisionDocuments(ctx context.Context, dbName string, queryParams RevisionQueryParams, opts []string) ([]map[string]interface{}, error)
	// StartReplicationSync starts the replication synchronization process.
	StartReplicationSync(ctx context.Context, dbName string, opts ReplicationSyncOptions) (ReplicationSyncResult, 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)

	// HandleAdminVersion retrieves the ArangoDB server version information (GET /_admin/version).
	//
	// Deprecated: Use Version or VersionWithOptions instead. HandleAdminVersion exists only for
	// backward compatibility with code that used the old name. On ArangoDB 3.x the decoded
	// VersionInfo matches VersionWithOptions for the same GetVersionOptions.
	// The legacy HTTP route GET /_admin/version is removed in ArangoDB 4.0.
	HandleAdminVersion(ctx context.Context, opts *GetVersionOptions) (VersionInfo, error)
}

type ClientStats struct {
	HttpConnections *int       `json:"httpConnections,omitempty"`
	ConnectionTime  *TimeStats `json:"connectionTime,omitempty"`
	TotalTime       *TimeStats `json:"totalTime,omitempty"`
	RequestTime     *TimeStats `json:"requestTime,omitempty"`
	QueueTime       *TimeStats `json:"queueTime,omitempty"`
	IoTime          *TimeStats `json:"ioTime,omitempty"`
	BytesSent       *TimeStats `json:"bytesSent,omitempty"`
	BytesReceived   *TimeStats `json:"bytesReceived,omitempty"`
}

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 ClusterEndpoint struct {
	// Endpoint is the connection string (protocol + host + port)
	// of a coordinator in the cluster, e.g. "tcp://127.0.0.1:8529".
	Endpoint *string `json:"endpoint,omitempty"`
}

type ClusterEndpointsResponse struct {
	// Endpoints is the list of cluster endpoints (usually coordinators)
	// that the client can use to connect to the cluster.
	Endpoints []ClusterEndpoint `json:"endpoints,omitempty"`
}

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 ClusterMaintenanceOpts struct {
	// Mode specifies the maintenance mode to apply to the DB-Server.
	// Possible values:
	//   - "maintenance": enable maintenance mode
	//   - "normal": disable maintenance mode
	// This field is required.
	Mode *string `json:"mode"`

	// Timeout specifies how long the maintenance mode should last, in seconds.
	// This field is optional; if nil, the server will use the default timeout (usually 3600 seconds).
	Timeout *int `json:"timeout"`
}

type ClusterMaintenanceResponse struct {
	// The mode of the DB-Server. The value is "maintenance".
	Mode *string `json:"mode,omitempty"`

	// Until what date and time the maintenance mode currently lasts,
	// in the ISO 8601 date/time format.
	Until *string `json:"until,omitempty"`
}

type ClusterStatisticsResponse struct {
	Time       *float64     `json:"time,omitempty"`
	Enabled    *bool        `json:"enabled,omitempty"`
	System     *SystemStats `json:"system,omitempty"`
	Client     *ClientStats `json:"client,omitempty"`
	ClientUser *ClientStats `json:"clientUser,omitempty"`
	HTTP       *HTTPStats   `json:"http,omitempty"`
	Server     *ServerStats `json:"server,omitempty"`
}

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.
	// Deprecated: use OverwriteMode instead. Will be removed in v4.0.
	Overwrite *bool

	// OverwriteMode supersedes the deprecated 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 {
	shared.ReadAllReadable[CollectionDocumentCreateResponse]
	Read() (CollectionDocumentCreateResponse, error)
	// Len returns the total number of documents in the input (not the remaining
	// documents to read), and it can be called at any time without affecting iteration.
	Len() int
}

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
	// Should be a pointer to an object
	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 {
	shared.ReadAllIntoReadable[CollectionDocumentDeleteResponse]
	Read(i interface{}) (CollectionDocumentDeleteResponse, error)
	// Len returns the total number of documents in the input (not the remaining documents to read).
	// It can be called at any time without affecting iteration.
	Len() int
}

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 {
	// IgnoreMissing controls whether rows with missing values are imported when using tabular import format.
	// Missing values are omitted and excess values are ignored.
	IgnoreMissing *bool `json:"ignoreMissing,omitempty"`
	// 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"`
	// OverwriteCollectionPrefix forces `fromPrefix` and `toPrefix` to be applied even if values already contain a collection prefix.
	OverwriteCollectionPrefix *bool `json:"overwriteCollectionPrefix,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"`
	// Details includes per-document error details in the import response for failed documents.
	Details *bool `json:"details,omitempty"`

	// Wait until the import 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 `json:"details,omitempty"`
}

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)
	shared.ReadAllIntoReadable[CollectionDocumentReadResponse]
	// Len returns the total number of documents in the input (not the remaining documents to read).
	// It can be called at any time and does not affect iteration.
	Len() int
}

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 {
	shared.ReadAllReadable[CollectionDocumentReplaceResponse]
	Read() (CollectionDocumentReplaceResponse, error)
	// Len returns the total number of documents in the input, not the number of documents remaining to read.
	// It can be called at any time and does not affect iteration over the results.
	Len() int
}

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 {
	shared.ReadAllReadable[CollectionDocumentUpdateResponse]
	Read() (CollectionDocumentUpdateResponse, error)
	// Len returns the total number of documents in the input, not the number of
	// documents remaining to be read, and can be called at any time without
	// affecting iteration.
	Len() int
}

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, autoincrement, uuid, and padded.
		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.
	// Enterprise Edition; from v3.12.5 onward also available in Community 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

	// EnsureVectorIndex creates a vector 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.12.4 and later.
	// VectorParams is an obligatory parameter and must contain at least Dimension, Metric and NLists fields.
	// CreateVectorIndexOptions.InBackground is sent when set; see CreateVectorIndexOptions.InBackground.
	EnsureVectorIndex(ctx context.Context, fields []string, params *VectorParams, options *CreateVectorIndexOptions) (IndexResponse, bool, 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.
	// Deprecated: collection status is a legacy server concept; server API remains backward-compatible. Only values 3 (loaded) and 5 (deleted) are still in use. Status and statusString may be removed in v4.0.
	Status CollectionStatus `json:"status,omitempty"`

	// StatusString represents status as a string.
	// Deprecated: collection status is a legacy server concept; server API remains backward-compatible. Only values 3 (loaded) and 5 (deleted) are still in use. Status and statusString may be removed in v4.0.
	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, autoincrement, uuid, and padded.
	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

	// 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.
	//
	// Deprecated: since 3.7 version. It is related only to MMFiles.
	IndexBuckets int `json:"indexBuckets,omitempty"`

	// DoCompact specifies whether or not the collection will be compacted.
	//
	// Deprecated: since 3.7 version. It is related only to MMFiles.
	DoCompact bool `json:"doCompact,omitempty"`

	// JournalSize is the maximal size setting for journals / datafiles in bytes.
	JournalSize int64 `json:"journalSize,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)
	//
	// Deprecated: since 3.7 version. It is related only to MMFiles.
	IsVolatile bool `json:"isVolatile,omitempty"`

	// SmartJoinAttribute
	// See documentation for SmartJoins.
	// Enterprise Edition; from v3.12.5 onward also available in Community 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.
	// Enterprise Edition; from v3.12.5 onward also available in Community 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 CollectionType int

type CollectionsInventoryResponse struct {
	// Indexes defined on the collection.
	// Note: Primary indexes and edge indexes are not included in this array.
	Indexes []IndexesInventoryResponse `json:"indexes,omitempty"`
	// Collection properties and metadata.
	Parameters ParametersInventoryResponse `json:"parameters,omitempty"`
}

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 CompactOpts struct {
	//whether or not compacted data should be moved to the minimum possible level.
	ChangeLevel *bool `json:"changeLevel,omitempty"`
	// Whether or not to compact the bottommost level of data.
	CompactBottomMostLevel *bool `json:"compactBottomMostLevel,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
	// Deprecated: Only available up to v3.12.6.
	MinScore *int64 `json:"minScore,omitempty"`

	// Deprecated: Only available up to v3.12.6.
	// Deprecated since v3.12.7. Use segment byte size skew–based consolidation.
	SegmentsMin *int64 `json:"segmentsMin,omitempty"`

	// SegmentsMax The maximum number of segments that are evaluated as candidates for consolidation. Default: 10
	// Deprecated: Only available up to v3.12.6.
	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
	// Deprecated: Only available up to v3.12.6.
	SegmentsBytesFloor *int64 `json:"segmentsBytesFloor,omitempty"`

	// MaxSkewThreshold defines the maximum allowed size skew between segment files
	// (value between 0.0 and 1.0) before they are considered for consolidation.
	// Default: 0.4. Available from ArangoDB v3.12.7 onward.
	MaxSkewThreshold *float64 `json:"maxSkewThreshold,omitempty"`

	// MinDeletionRatio defines the minimum ratio of deleted documents (0.0–1.0)
	// required to trigger segment cleanup.
	// Default: 0.5. Available from ArangoDB v3.12.7 onward.
	MinDeletionRatio *float64 `json:"minDeletionRatio,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 CoordinatorInfo struct {
	// ID of the Foxxmaster coordinator. Deprecated: Foxx is planned to be removed in ArangoDB v4.0.
	Foxxmaster *string `json:"foxxmaster,omitempty"`
	// Whether this server is the Foxxmaster. Deprecated: Foxx is planned to be removed in ArangoDB v4.0.
	IsFoxxmaster *bool `json:"isFoxxmaster,omitempty"`
}

type CpuStatsInfo struct {
	// Percentage of CPU time spent in user mode
	UserPercent *float64 `json:"userPercent,omitempty"`

	// Percentage of CPU time spent in system/kernel mode
	SystemPercent *float64 `json:"systemPercent,omitempty"`

	// Percentage of CPU time spent idle
	IdlePercent *float64 `json:"idlePercent,omitempty"`

	// Percentage of CPU time spent waiting for I/O
	IowaitPercent *float64 `json:"iowaitPercent,omitempty"`
}

type CreateAccessTokenResponse struct {
	// Embed the AccessTokenInfo metadata.
	AccessTokenInfo

	// Token is the actual access token string.
	// It is only returned once at creation and should be stored securely.
	Token *string `json:"token,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)
	// Deprecated: since 3.7 version. It is related only to MMFiles.
	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.
	//
	// Deprecated: since 3.7 version. It is related only to MMFiles.
	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.
	// Enterprise Edition; from v3.12.5 onward also available in Community 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)
	//
	// Deprecated: since 3.7 version. It is related only to MMFiles.
	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)
	//
	// Deprecated: related to legacy MMFiles settings and not part of the 4.0 public create-collection request.
	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.
	// Enterprise Edition; from v3.12.5 onward also available in Community 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.
	// Enterprise Edition; from v3.12.5 onward also available in Community 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.
	//
	// Note: server responses may still report this value as empty string,
	// including when DatabaseShardingFlexible was requested.
	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; from v3.12.5 onward also in Community Edition).
	// 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; from v3.12.5 onward also in Community Edition). 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 CreateNewBatchOptions struct {
	Ttl int `json:"ttl"`
}

type CreateNewBatchResponse struct {
	// The ID of the created batch
	ID string `json:"id"`
	// The last tick of the created batch
	LastTick string `json:"lastTick"`
	// Only present if the state URL parameter was set to true
	State map[string]interface{} `json:"state,omitempty"`
}

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 controls whether the index excludes documents with the indexed attribute missing or null.
	// Used by persistent indexes. (Vector indexes have their own Sparse in CreateVectorIndexOptions.)
	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 CreateVectorIndexOptions struct {
	// InBackground, when true, is sent to the server: index building is deferred until enough data is available,
	// avoiding an immediate error on empty or nearly empty collections. When false or unset, synchronous creation
	// may return an error while still creating an index in unusable state if training data is insufficient.
	// Alternatively, insert embeddings first then create the index without relying on inBackground.
	InBackground *bool `json:"inBackground,omitempty"`
	// Optional index name.
	Name *string `json:"name,omitempty"`
	// Number of threads to use for index creation.
	Parallelism *int `json:"parallelism,omitempty"`
	// Exclude docs missing the field.
	Sparse *bool `json:"sparse,omitempty"`
	// Introduced in v3.12.7
	// Up to 32 additional attributes can be stored in the index.
	StoredValues []string `json:"storedValues,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; from v3.12.5 onward also in Community Edition).
	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

	// Deprecated: JavaScript transactions rely on server-side JavaScript and are planned to be removed in ArangoDB v4.0.
	// 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.
	//
	// Note: server responses may report this as empty string even if the
	// database was created with sharding set to flexible.
	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)

	// Deprecated: User-defined AQL functions rely on server-side JavaScript and are planned to be removed in ArangoDB v4.0.
	// 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)

	// Deprecated: User-defined AQL functions rely on server-side JavaScript and are planned to be removed in ArangoDB v4.0.
	// 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)

	// Deprecated: User-defined AQL functions rely on server-side JavaScript and are planned to be removed in ArangoDB v4.0.
	// 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 DeploymentIdResponse struct {
	// Id represents the unique deployment identifier
	Id *string `json:"id"`
}

type DeploymentInfo struct {
	// Type of deployment ("single" or "cluster")
	Type *string `json:"type,omitempty"`

	// Map of servers in the cluster, keyed by server ID (only present in cluster mode)
	Servers *map[ServerID]ServerInfo `json:"servers,omitempty"`

	// Number of agents in the cluster (cluster only)
	Agents *int `json:"agents,omitempty"`

	// Number of coordinators in the cluster (cluster only)
	Coordinators *int `json:"coordinators,omitempty"`

	// Number of DB servers in the cluster (cluster only)
	DbServers *int `json:"dbServers,omitempty"`

	// Shard distribution details (cluster only)
	Shards *ShardsInfo `json:"shards,omitempty"`
}

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 is the edge definition name (e.g. edge collection name in the graph).
	// It is not a system attribute; the server uses the "$label" key in responses for this value.
	Label string `json:"$label"`
}

type EdgeDirection string