gocbcore

type AddOptions struct {
	Key                    []byte
	CollectionName         string
	ScopeName              string
	RetryStrategy          RetryStrategy
	Value                  []byte
	Flags                  uint32
	Datatype               uint8
	Expiry                 uint32
	DurabilityLevel        DurabilityLevel
	DurabilityLevelTimeout uint16
	CollectionID           uint32

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type AdjoinExCallback func(*AdjoinResult, error)

type AdjoinOptions struct {
	Key                    []byte
	Value                  []byte
	CollectionName         string
	ScopeName              string
	RetryStrategy          RetryStrategy
	Cas                    Cas
	DurabilityLevel        DurabilityLevel
	DurabilityLevelTimeout uint16
	CollectionID           uint32

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type AdjoinResult struct {
	Cas           Cas
	MutationToken MutationToken
}

type Agent struct {
	// contains filtered or unexported fields
}

type AgentConfig struct {
	UserAgent   string
	MemdAddrs   []string
	HTTPAddrs   []string
	UseTLS      bool
	BucketName  string
	NetworkType string
	Auth        AuthProvider

	TLSRootCAs    *x509.CertPool
	TLSSkipVerify bool

	UseMutationTokens    bool
	UseCompression       bool
	UseDurations         bool
	DisableDecompression bool

	UseCollections bool

	CompressionMinSize  int
	CompressionMinRatio float64

	HTTPRedialPeriod time.Duration
	HTTPRetryDelay   time.Duration
	CccpMaxWait      time.Duration
	CccpPollPeriod   time.Duration

	ConnectTimeout   time.Duration
	KVConnectTimeout time.Duration

	KvPoolSize   int
	MaxQueueSize int

	HTTPMaxIdleConns          int
	HTTPMaxIdleConnsPerHost   int
	HTTPIdleConnectionTimeout time.Duration

	// Volatile: Tracer API is subject to change.
	Tracer           RequestTracer
	NoRootTraceSpans bool

	DefaultRetryStrategy RetryStrategy
	CircuitBreakerConfig CircuitBreakerConfig

	UseZombieLogger        bool
	ZombieLoggerInterval   time.Duration
	ZombieLoggerSampleSize int

	DcpAgentPriority DcpAgentPriority
	UseDCPExpiry     bool
	UseDCPStreamID   bool
}

type AnalyticsError struct {
	InnerError      error                `json:"-"`
	Statement       string               `json:"statement,omitempty"`
	ClientContextID string               `json:"client_context_id,omitempty"`
	Errors          []AnalyticsErrorDesc `json:"errors,omitempty"`
	Endpoint        string               `json:"endpoint,omitempty"`
	RetryReasons    []RetryReason        `json:"retry_reasons,omitempty"`
	RetryAttempts   uint32               `json:"retry_attempts,omitempty"`
}

type AnalyticsErrorDesc struct {
	Code    uint32
	Message string
}

type AnalyticsQueryOptions struct {
	Payload       []byte
	Priority      int
	RetryStrategy RetryStrategy
	Deadline      time.Time

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type AnalyticsRowReader struct {
	// contains filtered or unexported fields
}

type AuthCertRequest struct {
	Service  ServiceType
	Endpoint string
}

type AuthClient interface {
	Address() string
	SupportsFeature(feature HelloFeature) bool

	SaslListMechs(deadline time.Time, cb func(mechs []AuthMechanism, err error)) error
	SaslAuth(k, v []byte, deadline time.Time, cb func(b []byte, err error)) error
	SaslStep(k, v []byte, deadline time.Time, cb func(err error)) error
}

type AuthCredsRequest struct {
	Service  ServiceType
	Endpoint string
}

type AuthFunc func(client AuthClient, deadline time.Time, continueCb func(), completedCb func(error)) error

type AuthMechanism string

type AuthProvider interface {
	SupportsTLS() bool
	SupportsNonTLS() bool
	Certificate(req AuthCertRequest) (*tls.Certificate, error)
	Credentials(req AuthCredsRequest) ([]UserPassPair, error)
}

type BackoffCalculator func(retryAttempts uint32) time.Duration

type BestEffortRetryStrategy struct {
	// contains filtered or unexported fields
}

type BytesAndError struct {
	Err   error
	Bytes []byte
}

type Cas uint64

type CircuitBreakerCallback func(error) bool

type CircuitBreakerConfig struct {
	Enabled                  bool
	VolumeThreshold          int64
	ErrorThresholdPercentage float64
	SleepWindow              time.Duration
	RollingWindow            time.Duration
	CompletionCallback       CircuitBreakerCallback
	CanaryTimeout            time.Duration
}

type CloseStreamCallback func(error)

type ClusterCapability uint32

type CollectionIDCallback func(manifestID uint64, collectionID uint32, err error)

type CompressionType uint32

type CounterExCallback func(*CounterResult, error)

type CounterInExCallback func(*CounterInResult, error)

type CounterInOptions StoreInOptions

type CounterInResult struct {
	Value         []byte
	Cas           Cas
	MutationToken MutationToken
}

type CounterOptions struct {
	Key                    []byte
	Delta                  uint64
	Initial                uint64
	Expiry                 uint32
	CollectionName         string
	ScopeName              string
	RetryStrategy          RetryStrategy
	Cas                    Cas
	DurabilityLevel        DurabilityLevel
	DurabilityLevelTimeout uint16
	CollectionID           uint32

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type CounterResult struct {
	Value         uint64
	Cas           Cas
	MutationToken MutationToken
}

type DataType uint32

type DatatypeFlag uint8

type DcpAgentPriority uint8

type DcpOpenFlag uint32

type DcpStreamAddFlag uint32

type DeleteExCallback func(*DeleteResult, error)

type DeleteInExCallback func(*DeleteInResult, error)

type DeleteInOptions struct {
	Key                    []byte
	Path                   string
	Cas                    Cas
	Expiry                 uint32
	Flags                  SubdocFlag
	CollectionName         string
	ScopeName              string
	RetryStrategy          RetryStrategy
	DurabilityLevel        DurabilityLevel
	DurabilityLevelTimeout uint16
	CollectionID           uint32

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type DeleteInResult struct {
	Cas           Cas
	MutationToken MutationToken
}

type DeleteMetaExCallback func(*DeleteMetaResult, error)

type DeleteMetaOptions struct {
	Key            []byte
	Value          []byte
	Extra          []byte
	Datatype       uint8
	Options        uint32
	Flags          uint32
	Expiry         uint32
	Cas            Cas
	RevNo          uint64
	CollectionName string
	ScopeName      string
	CollectionID   uint32
	RetryStrategy  RetryStrategy

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type DeleteMetaResult struct {
	Cas           Cas
	MutationToken MutationToken
}

type DeleteOptions struct {
	Key                    []byte
	CollectionName         string
	ScopeName              string
	RetryStrategy          RetryStrategy
	Cas                    Cas
	DurabilityLevel        DurabilityLevel
	DurabilityLevelTimeout uint16
	CollectionID           uint32

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type DeleteResult struct {
	Cas           Cas
	MutationToken MutationToken
}

type DiagnosticInfo struct {
	ConfigRev int64
	MemdConns []MemdConnInfo
}

type DurabilityLevel uint8

type ExecHelloResponse struct {
	SrvFeatures []HelloFeature
	Err         error
}

type ExistsInExCallback func(*ExistsInResult, error)

type ExistsInOptions struct {
	Key            []byte
	Path           string
	Flags          SubdocFlag
	CollectionName string
	ScopeName      string
	CollectionID   uint32
	RetryStrategy  RetryStrategy

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type ExistsInResult struct {
	Cas Cas
}

type FailoverEntry struct {
	VbUUID VbUUID
	SeqNo  SeqNo
}

type GetAndLockExCallback func(*GetAndLockResult, error)

type GetAndLockOptions struct {
	Key            []byte
	LockTime       uint32
	CollectionName string
	ScopeName      string
	CollectionID   uint32
	RetryStrategy  RetryStrategy

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type GetAndLockResult struct {
	Value    []byte
	Flags    uint32
	Datatype uint8
	Cas      Cas
}

type GetAndTouchExCallback func(*GetAndTouchResult, error)

type GetAndTouchOptions struct {
	Key            []byte
	Expiry         uint32
	CollectionName string
	ScopeName      string
	CollectionID   uint32
	RetryStrategy  RetryStrategy

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type GetAndTouchResult struct {
	Value    []byte
	Flags    uint32
	Datatype uint8
	Cas      Cas
}

type GetAnyReplicaOptions struct {
	Key            []byte
	CollectionName string
	ScopeName      string
	CollectionID   uint32
	RetryStrategy  RetryStrategy

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type GetCollectionIDOptions struct {
	RetryStrategy RetryStrategy
	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type GetCollectionManifestOptions struct {
	// Volatile: Tracer API is subject to change.
	TraceContext  RequestSpanContext
	RetryStrategy RetryStrategy
}

type GetExCallback func(*GetResult, error)

type GetFailoverLogCallback func([]FailoverEntry, error)

type GetInExCallback func(*GetInResult, error)

type GetInOptions struct {
	Key            []byte
	Path           string
	Flags          SubdocFlag
	CollectionName string
	ScopeName      string
	CollectionID   uint32
	RetryStrategy  RetryStrategy

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type GetInResult struct {
	Value []byte
	Cas   Cas
}

type GetMetaExCallback func(*GetMetaResult, error)

type GetMetaOptions struct {
	Key            []byte
	CollectionName string
	ScopeName      string
	CollectionID   uint32
	RetryStrategy  RetryStrategy

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type GetMetaResult struct {
	Value    []byte
	Flags    uint32
	Cas      Cas
	Expiry   uint32
	SeqNo    SeqNo
	Datatype uint8
	Deleted  uint32
}

type GetOneReplicaOptions struct {
	Key            []byte
	CollectionName string
	ScopeName      string
	CollectionID   uint32
	RetryStrategy  RetryStrategy
	ReplicaIdx     int

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type GetOptions struct {
	Key            []byte
	CollectionName string
	ScopeName      string
	CollectionID   uint32
	RetryStrategy  RetryStrategy

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type GetRandomExCallback func(*GetRandomResult, error)

type GetRandomOptions struct {
	RetryStrategy RetryStrategy

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type GetRandomResult struct {
	Key      []byte
	Value    []byte
	Flags    uint32
	Datatype uint8
	Cas      Cas
}

type GetReplicaExCallback func(*GetReplicaResult, error)

type GetReplicaResult struct {
	Value    []byte
	Flags    uint32
	Datatype uint8
	Cas      Cas
}

type GetResult struct {
	Value    []byte
	Flags    uint32
	Datatype uint8
	Cas      Cas
}

type GetVBucketSeqnosCallback func([]VbSeqNoEntry, error)

type HTTPError struct {
	InnerError    error         `json:"-"`
	UniqueID      string        `json:"unique_id,omitempty"`
	Endpoint      string        `json:"endpoint,omitempty"`
	RetryReasons  []RetryReason `json:"retry_reasons,omitempty"`
	RetryAttempts uint32        `json:"retry_attempts,omitempty"`
}

type HTTPRequest struct {
	Service       ServiceType
	Method        string
	Endpoint      string
	Path          string
	Username      string
	Password      string
	Body          []byte
	Headers       map[string]string
	ContentType   string
	IsIdempotent  bool
	UniqueID      string
	Timeout       time.Duration
	RetryStrategy RetryStrategy

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type HTTPResponse struct {
	Endpoint   string
	StatusCode int
	Body       io.ReadCloser
}

type HelloFeature uint16

type KeyState uint8

type KeyValueError struct {
	InnerError         error         `json:"-"`
	StatusCode         StatusCode    `json:"status_code,omitempty"`
	BucketName         string        `json:"bucket,omitempty"`
	ScopeName          string        `json:"scope,omitempty"`
	CollectionName     string        `json:"collection,omitempty"`
	CollectionID       uint32        `json:"collection_id,omitempty"`
	ErrorName          string        `json:"error_name,omitempty"`
	ErrorDescription   string        `json:"error_description,omitempty"`
	Opaque             uint32        `json:"opaque,omitempty"`
	Context            string        `json:"context,omitempty"`
	Ref                string        `json:"ref,omitempty"`
	RetryReasons       []RetryReason `json:"retry_reasons,omitempty"`
	RetryAttempts      uint32        `json:"retry_attempts,omitempty"`
	LastDispatchedTo   string        `json:"last_dispatched_to,omitempty"`
	LastDispatchedFrom string        `json:"last_dispatched_from,omitempty"`
	LastConnectionID   string        `json:"last_connection_id,omitempty"`
}

type LogLevel int

type LogRedactLevel int

type Logger interface {
	// Outputs logging information:
	// level is the verbosity level
	// offset is the position within the calling stack from which the message
	// originated. This is useful for contextual loggers which retrieve file/line
	// information.
	Log(level LogLevel, offset int, format string, v ...interface{}) error
}

type LookupInExCallback func(*LookupInResult, error)

type LookupInOptions struct {
	Key            []byte
	Flags          SubdocDocFlag
	Ops            []SubDocOp
	CollectionName string
	ScopeName      string
	CollectionID   uint32
	RetryStrategy  RetryStrategy

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type LookupInResult struct {
	Cas Cas
	Ops []SubDocResult
}

type Manifest struct {
	UID    uint64
	Scopes []ManifestScope
}

type ManifestCallback func(manifest []byte, err error)

type ManifestCollection struct {
	UID  uint32
	Name string
}

type ManifestScope struct {
	UID         uint32
	Name        string
	Collections []ManifestCollection
}

type MemdConnInfo struct {
	LocalAddr    string
	RemoteAddr   string
	LastActivity time.Time
	Scope        string
	ID           string
}

type MutateInExCallback func(*MutateInResult, error)

type MutateInOptions struct {
	Key                    []byte
	Flags                  SubdocDocFlag
	Cas                    Cas
	Expiry                 uint32
	Ops                    []SubDocOp
	CollectionName         string
	ScopeName              string
	RetryStrategy          RetryStrategy
	DurabilityLevel        DurabilityLevel
	DurabilityLevelTimeout uint16
	CollectionID           uint32

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type MutateInResult struct {
	Cas           Cas
	MutationToken MutationToken
	Ops           []SubDocResult
}

type MutationToken struct {
	VbID   uint16
	VbUUID VbUUID
	SeqNo  SeqNo
}

type N1QLError struct {
	InnerError      error           `json:"-"`
	Statement       string          `json:"statement,omitempty"`
	ClientContextID string          `json:"client_context_id,omitempty"`
	Errors          []N1QLErrorDesc `json:"errors,omitempty"`
	Endpoint        string          `json:"endpoint,omitempty"`
	RetryReasons    []RetryReason   `json:"retry_reasons,omitempty"`
	RetryAttempts   uint32          `json:"retry_attempts,omitempty"`
}

type N1QLErrorDesc struct {
	Code    uint32
	Message string
}

type N1QLQueryOptions struct {
	Payload       []byte
	RetryStrategy RetryStrategy
	Deadline      time.Time

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type N1QLRowReader struct {
	// contains filtered or unexported fields
}

type NoRetryRetryAction struct {
}

type ObserveExCallback func(*ObserveResult, error)

type ObserveOptions struct {
	Key            []byte
	ReplicaIdx     int
	CollectionName string
	ScopeName      string
	CollectionID   uint32
	RetryStrategy  RetryStrategy

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type ObserveResult struct {
	KeyState KeyState
	Cas      Cas
}

type ObserveVbExCallback func(*ObserveVbResult, error)

type ObserveVbOptions struct {
	VbID          uint16
	VbUUID        VbUUID
	ReplicaIdx    int
	RetryStrategy RetryStrategy

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type ObserveVbResult struct {
	DidFailover  bool
	VbID         uint16
	VbUUID       VbUUID
	PersistSeqNo SeqNo
	CurrentSeqNo SeqNo
	OldVbUUID    VbUUID
	LastSeqNo    SeqNo
}

type OpenStreamCallback func([]FailoverEntry, error)

type PasswordAuthProvider struct {
	Username string
	Password string
}

type PendingOp interface {
	Cancel(err error)
}

type PingKvExCallback func(*PingKvResult, error)

type PingKvOptions struct {
	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type PingKvResult struct {
	ConfigRev int64
	Services  []PingResult
}

type PingResult struct {
	Endpoint string
	Error    error
	Latency  time.Duration
	ID       string
	Scope    string
}

type ReplaceOptions struct {
	Key                    []byte
	CollectionName         string
	ScopeName              string
	RetryStrategy          RetryStrategy
	Value                  []byte
	Flags                  uint32
	Datatype               uint8
	Cas                    Cas
	Expiry                 uint32
	DurabilityLevel        DurabilityLevel
	DurabilityLevelTimeout uint16
	CollectionID           uint32

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type RequestSpan interface {
	Finish()
	Context() RequestSpanContext
	SetTag(key string, value interface{}) RequestSpan
}

type RequestSpanContext interface {
}

type RequestTracer interface {
	StartSpan(operationName string, parentContext RequestSpanContext) RequestSpan
}

type RetryAction interface {
	Duration() time.Duration
}

type RetryReason interface {
	AllowsNonIdempotentRetry() bool
	AlwaysRetry() bool
	Description() string
}

type RetryRequest interface {
	RetryAttempts() uint32
	Identifier() string
	Idempotent() bool
	RetryReasons() []RetryReason
	// contains filtered or unexported methods
}

type RetryStrategy interface {
	RetryAfter(req RetryRequest, reason RetryReason) RetryAction
}

type SaslListMechsCompleted struct {
	Err   error
	Mechs []AuthMechanism
}

type SearchError struct {
	InnerError       error         `json:"-"`
	IndexName        string        `json:"index_name,omitempty"`
	Query            interface{}   `json:"query,omitempty"`
	ErrorText        string        `json:"error_text"`
	HTTPResponseCode int           `json:"status_code,omitempty"`
	Endpoint         string        `json:"endpoint,omitempty"`
	RetryReasons     []RetryReason `json:"retry_reasons,omitempty"`
	RetryAttempts    uint32        `json:"retry_attempts,omitempty"`
}

type SearchQueryOptions struct {
	IndexName     string
	Payload       []byte
	RetryStrategy RetryStrategy
	Deadline      time.Time

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type SearchRowReader struct {
	// contains filtered or unexported fields
}

type SeqNo uint64

type ServiceType int

type SetMetaExCallback func(*SetMetaResult, error)

type SetMetaOption uint32

type SetMetaOptions struct {
	Key            []byte
	Value          []byte
	Extra          []byte
	Datatype       uint8
	Options        uint32
	Flags          uint32
	Expiry         uint32
	Cas            Cas
	RevNo          uint64
	CollectionName string
	ScopeName      string
	CollectionID   uint32
	RetryStrategy  RetryStrategy

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type SetMetaResult struct {
	Cas           Cas
	MutationToken MutationToken
}

type SetOptions struct {
	Key                    []byte
	CollectionName         string
	ScopeName              string
	RetryStrategy          RetryStrategy
	Value                  []byte
	Flags                  uint32
	Datatype               uint8
	Expiry                 uint32
	DurabilityLevel        DurabilityLevel
	DurabilityLevelTimeout uint16
	CollectionID           uint32

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type SingleServerStats struct {
	Stats map[string]string
	Error error
}

type SnapshotState uint32

type StatsExCallback func(*StatsResult, error)

type StatsOptions struct {
	Key string
	// Target indicates that something specific should be targeted by the operation. If left nil
	// then the stats command will be sent to all servers.
	Target        StatsTarget
	RetryStrategy RetryStrategy

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type StatsResult struct {
	Servers map[string]SingleServerStats
}

type StatsTarget interface {
}

type StatusCode uint16

type StoreExCallback func(*StoreResult, error)

type StoreInExCallback func(*StoreInResult, error)

type StoreInOptions struct {
	Key                    []byte
	Path                   string
	Value                  []byte
	Flags                  SubdocFlag
	Cas                    Cas
	Expiry                 uint32
	CollectionName         string
	ScopeName              string
	RetryStrategy          RetryStrategy
	DurabilityLevel        DurabilityLevel
	DurabilityLevelTimeout uint16
	CollectionID           uint32

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type StoreInResult struct {
	Cas           Cas
	MutationToken MutationToken
}

type StoreResult struct {
	Cas           Cas
	MutationToken MutationToken
}

type StreamEndStatus uint32

type StreamEventCode uint32

type StreamFilter struct {
	ManifestUID uint64
	Collections []uint32
	Scope       uint32
	StreamID    uint16
}

type StreamObserver interface {
	SnapshotMarker(startSeqNo, endSeqNo uint64, vbID uint16, streamID uint16, snapshotType SnapshotState)
	Mutation(seqNo, revNo uint64, flags, expiry, lockTime uint32, cas uint64, datatype uint8, vbID uint16, collectionID uint32, streamID uint16, key, value []byte)
	Deletion(seqNo, revNo, cas uint64, datatype uint8, vbID uint16, collectionID uint32, streamID uint16, key, value []byte)
	Expiration(seqNo, revNo, cas uint64, vbID uint16, collectionID uint32, streamID uint16, key []byte)
	End(vbID uint16, streamID uint16, err error)
	CreateCollection(seqNo uint64, version uint8, vbID uint16, manifestUID uint64, scopeID uint32, collectionID uint32, ttl uint32, streamID uint16, key []byte)
	DeleteCollection(seqNo uint64, version uint8, vbID uint16, manifestUID uint64, scopeID uint32, collectionID uint32, streamID uint16)
	FlushCollection(seqNo uint64, version uint8, vbID uint16, manifestUID uint64, collectionID uint32)
	CreateScope(seqNo uint64, version uint8, vbID uint16, manifestUID uint64, scopeID uint32, streamID uint16, key []byte)
	DeleteScope(seqNo uint64, version uint8, vbID uint16, manifestUID uint64, scopeID uint32, streamID uint16)
	ModifyCollection(seqNo uint64, version uint8, vbID uint16, manifestUID uint64, collectionID uint32, ttl uint32, streamID uint16)
}

type SubDocOp struct {
	Op    SubDocOpType
	Flags SubdocFlag
	Path  string
	Value []byte
}

type SubDocOpType uint8

type SubDocResult struct {
	Err   error
	Value []byte
}

type SubDocumentError struct {
	InnerError error
	Index      int
}

type SubdocDocFlag uint8

type SubdocFlag uint8

type TouchExCallback func(*TouchResult, error)

type TouchOptions struct {
	Key            []byte
	Expiry         uint32
	CollectionName string
	ScopeName      string
	CollectionID   uint32
	RetryStrategy  RetryStrategy

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type TouchResult struct {
	Cas           Cas
	MutationToken MutationToken
}

type UnlockExCallback func(*UnlockResult, error)

type UnlockOptions struct {
	Key            []byte
	Cas            Cas
	CollectionName string
	ScopeName      string
	CollectionID   uint32
	RetryStrategy  RetryStrategy

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type UnlockResult struct {
	Cas           Cas
	MutationToken MutationToken
}

type UserPassPair struct {
	Username string
	Password string
}

type VBucketIDStatsTarget struct {
	VbID uint16
}

type VbSeqNoEntry struct {
	VbID  uint16
	SeqNo SeqNo
}

type VbUUID uint64

type VbucketState uint32

type ViewError struct {
	InnerError         error                `json:"-"`
	DesignDocumentName string               `json:"design_document_name,omitempty"`
	ViewName           string               `json:"view_name,omitempty"`
	Errors             []ViewQueryErrorDesc `json:"errors,omitempty"`
	Endpoint           string               `json:"endpoint,omitempty"`
	RetryReasons       []RetryReason        `json:"retry_reasons,omitempty"`
	RetryAttempts      uint32               `json:"retry_attempts,omitempty"`
}

type ViewQueryErrorDesc struct {
	SourceNode string
	Message    string
}

type ViewQueryOptions struct {
	DesignDocumentName string
	ViewType           string
	ViewName           string
	Options            url.Values
	RetryStrategy      RetryStrategy
	Deadline           time.Time

	// Volatile: Tracer API is subject to change.
	TraceContext RequestSpanContext
}

type ViewQueryRowReader struct {
	// contains filtered or unexported fields
}

type WithDurationRetryAction struct {
	WithDuration time.Duration
}