// Code generated by depstubber. DO NOT EDIT.
// This is a simple stub for github.com/couchbase/gocb/v2, strictly for use in testing.

// See the LICENSE file for information about the licensing of the original library.
// Source: github.com/couchbase/gocb/v2 (exports: Cluster,Scope; functions: )

// Package gocb is a stub of github.com/couchbase/gocb/v2, generated by depstubber.
package gocb

import (
	time "time"
)

type AllowQueryingSearchIndexOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type AnalyticsDataset struct {
	Name          string
	DataverseName string
	LinkName      string
	BucketName    string
}

type AnalyticsIndex struct {
	Name          string
	DatasetName   string
	DataverseName string
	IsPrimary     bool
}

type AnalyticsIndexManager struct{}

func (_ *AnalyticsIndexManager) ConnectLink(_ *ConnectAnalyticsLinkOptions) error {
	return nil
}

func (_ *AnalyticsIndexManager) CreateDataset(_ string, _ string, _ *CreateAnalyticsDatasetOptions) error {
	return nil
}

func (_ *AnalyticsIndexManager) CreateDataverse(_ string, _ *CreateAnalyticsDataverseOptions) error {
	return nil
}

func (_ *AnalyticsIndexManager) CreateIndex(_ string, _ string, _ map[string]string, _ *CreateAnalyticsIndexOptions) error {
	return nil
}

func (_ *AnalyticsIndexManager) DisconnectLink(_ *DisconnectAnalyticsLinkOptions) error {
	return nil
}

func (_ *AnalyticsIndexManager) DropDataset(_ string, _ *DropAnalyticsDatasetOptions) error {
	return nil
}

func (_ *AnalyticsIndexManager) DropDataverse(_ string, _ *DropAnalyticsDataverseOptions) error {
	return nil
}

func (_ *AnalyticsIndexManager) DropIndex(_ string, _ string, _ *DropAnalyticsIndexOptions) error {
	return nil
}

func (_ *AnalyticsIndexManager) GetAllDatasets(_ *GetAllAnalyticsDatasetsOptions) ([]AnalyticsDataset, error) {
	return nil, nil
}

func (_ *AnalyticsIndexManager) GetAllIndexes(_ *GetAllAnalyticsIndexesOptions) ([]AnalyticsIndex, error) {
	return nil, nil
}

func (_ *AnalyticsIndexManager) GetPendingMutations(_ *GetPendingMutationsAnalyticsOptions) (map[string]map[string]int, error) {
	return nil, nil
}

type AnalyticsMetaData struct {
	RequestID       string
	ClientContextID string
	Metrics         AnalyticsMetrics
	Signature       interface{}
	Warnings        []AnalyticsWarning
}

type AnalyticsMetrics struct {
	ElapsedTime      time.Duration
	ExecutionTime    time.Duration
	ResultCount      uint64
	ResultSize       uint64
	MutationCount    uint64
	SortCount        uint64
	ErrorCount       uint64
	WarningCount     uint64
	ProcessedObjects uint64
}

type AnalyticsOptions struct {
	ClientContextID      string
	Priority             bool
	PositionalParameters []interface{}
	NamedParameters      map[string]interface{}
	Readonly             bool
	ScanConsistency      AnalyticsScanConsistency
	Raw                  map[string]interface{}
	Timeout              time.Duration
	RetryStrategy        RetryStrategy
}

type AnalyticsResult struct{}

func (_ *AnalyticsResult) Close() error {
	return nil
}

func (_ *AnalyticsResult) Err() error {
	return nil
}

func (_ *AnalyticsResult) MetaData() (*AnalyticsMetaData, error) {
	return nil, nil
}

func (_ *AnalyticsResult) Next() bool {
	return false
}

func (_ *AnalyticsResult) One(_ interface{}) error {
	return nil
}

func (_ *AnalyticsResult) Raw() *AnalyticsResultRaw {
	return nil
}

func (_ *AnalyticsResult) Row(_ interface{}) error {
	return nil
}

type AnalyticsResultRaw struct{}

func (_ *AnalyticsResultRaw) Close() error {
	return nil
}

func (_ *AnalyticsResultRaw) Err() error {
	return nil
}

func (_ *AnalyticsResultRaw) MetaData() ([]byte, error) {
	return nil, nil
}

func (_ *AnalyticsResultRaw) NextBytes() []byte {
	return nil
}

type AnalyticsScanConsistency uint

type AnalyticsWarning struct {
	Code    uint32
	Message string
}

type AnalyzeDocumentOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type AppendOptions struct {
	Timeout         time.Duration
	DurabilityLevel DurabilityLevel
	PersistTo       uint
	ReplicateTo     uint
	Cas             Cas
	RetryStrategy   RetryStrategy
	Internal        struct {
		User []byte
	}
}

type AuthDomain string

type BinaryCollection struct{}

func (_ *BinaryCollection) Append(_ string, _ []byte, _ *AppendOptions) (*MutationResult, error) {
	return nil, nil
}

func (_ *BinaryCollection) Decrement(_ string, _ *DecrementOptions) (*CounterResult, error) {
	return nil, nil
}

func (_ *BinaryCollection) Increment(_ string, _ *IncrementOptions) (*CounterResult, error) {
	return nil, nil
}

func (_ *BinaryCollection) Prepend(_ string, _ []byte, _ *PrependOptions) (*MutationResult, error) {
	return nil, nil
}

type Bucket struct{}

func (_ *Bucket) Collection(_ string) *Collection {
	return nil
}

func (_ *Bucket) Collections() *CollectionManager {
	return nil
}

func (_ *Bucket) DefaultCollection() *Collection {
	return nil
}

func (_ *Bucket) DefaultScope() *Scope {
	return nil
}

func (_ *Bucket) Internal() *InternalBucket {
	return nil
}

func (_ *Bucket) Name() string {
	return ""
}

func (_ *Bucket) Ping(_ *PingOptions) (*PingResult, error) {
	return nil, nil
}

func (_ *Bucket) Scope(_ string) *Scope {
	return nil
}

func (_ *Bucket) ViewIndexes() *ViewIndexManager {
	return nil
}

func (_ *Bucket) ViewQuery(_ string, _ string, _ *ViewOptions) (*ViewResult, error) {
	return nil, nil
}

func (_ *Bucket) WaitUntilReady(_ time.Duration, _ *WaitUntilReadyOptions) error {
	return nil
}

type BucketManager struct{}

func (_ *BucketManager) CreateBucket(_ CreateBucketSettings, _ *CreateBucketOptions) error {
	return nil
}

func (_ *BucketManager) DropBucket(_ string, _ *DropBucketOptions) error {
	return nil
}

func (_ *BucketManager) FlushBucket(_ string, _ *FlushBucketOptions) error {
	return nil
}

func (_ *BucketManager) GetAllBuckets(_ *GetAllBucketsOptions) (map[string]BucketSettings, error) {
	return nil, nil
}

func (_ *BucketManager) GetBucket(_ string, _ *GetBucketOptions) (*BucketSettings, error) {
	return nil, nil
}

func (_ *BucketManager) UpdateBucket(_ BucketSettings, _ *UpdateBucketOptions) error {
	return nil
}

type BucketSettings struct {
	Name                   string
	FlushEnabled           bool
	ReplicaIndexDisabled   bool
	RAMQuotaMB             uint64
	NumReplicas            uint32
	BucketType             BucketType
	EvictionPolicy         EvictionPolicyType
	MaxTTL                 time.Duration
	MaxExpiry              time.Duration
	CompressionMode        CompressionMode
	MinimumDurabilityLevel DurabilityLevel
}

type BucketType string

type BuildDeferredQueryIndexOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type BulkOp interface{}

type BulkOpOptions struct {
	Timeout       time.Duration
	Transcoder    Transcoder
	RetryStrategy RetryStrategy
}

type Cas uint64

type Cluster struct{}

func (_ *Cluster) AnalyticsIndexes() *AnalyticsIndexManager {
	return nil
}

func (_ *Cluster) AnalyticsQuery(_ string, _ *AnalyticsOptions) (*AnalyticsResult, error) {
	return nil, nil
}

func (_ *Cluster) Bucket(_ string) *Bucket {
	return nil
}

func (_ *Cluster) Buckets() *BucketManager {
	return nil
}

func (_ *Cluster) Close(_ *ClusterCloseOptions) error {
	return nil
}

func (_ *Cluster) Diagnostics(_ *DiagnosticsOptions) (*DiagnosticsResult, error) {
	return nil, nil
}

func (_ *Cluster) Ping(_ *PingOptions) (*PingResult, error) {
	return nil, nil
}

func (_ *Cluster) Query(_ string, _ *QueryOptions) (*QueryResult, error) {
	return nil, nil
}

func (_ *Cluster) QueryIndexes() *QueryIndexManager {
	return nil
}

func (_ *Cluster) SearchIndexes() *SearchIndexManager {
	return nil
}

func (_ *Cluster) SearchQuery(_ string, _ interface{}, _ *SearchOptions) (*SearchResult, error) {
	return nil, nil
}

func (_ *Cluster) Users() *UserManager {
	return nil
}

func (_ *Cluster) WaitUntilReady(_ time.Duration, _ *WaitUntilReadyOptions) error {
	return nil
}

type ClusterCloseOptions struct{}

type ClusterState uint

type Collection struct{}

func (_ *Collection) Binary() *BinaryCollection {
	return nil
}

func (_ *Collection) Bucket() *Bucket {
	return nil
}

func (_ *Collection) Do(_ []BulkOp, _ *BulkOpOptions) error {
	return nil
}

func (_ *Collection) Exists(_ string, _ *ExistsOptions) (*ExistsResult, error) {
	return nil, nil
}

func (_ *Collection) Get(_ string, _ *GetOptions) (*GetResult, error) {
	return nil, nil
}

func (_ *Collection) GetAllReplicas(_ string, _ *GetAllReplicaOptions) (*GetAllReplicasResult, error) {
	return nil, nil
}

func (_ *Collection) GetAndLock(_ string, _ time.Duration, _ *GetAndLockOptions) (*GetResult, error) {
	return nil, nil
}

func (_ *Collection) GetAndTouch(_ string, _ time.Duration, _ *GetAndTouchOptions) (*GetResult, error) {
	return nil, nil
}

func (_ *Collection) GetAnyReplica(_ string, _ *GetAnyReplicaOptions) (*GetReplicaResult, error) {
	return nil, nil
}

func (_ *Collection) Insert(_ string, _ interface{}, _ *InsertOptions) (*MutationResult, error) {
	return nil, nil
}

func (_ *Collection) List(_ string) *CouchbaseList {
	return nil
}

func (_ *Collection) LookupIn(_ string, _ []LookupInSpec, _ *LookupInOptions) (*LookupInResult, error) {
	return nil, nil
}

func (_ *Collection) Map(_ string) *CouchbaseMap {
	return nil
}

func (_ *Collection) MutateIn(_ string, _ []MutateInSpec, _ *MutateInOptions) (*MutateInResult, error) {
	return nil, nil
}

func (_ *Collection) Name() string {
	return ""
}

func (_ *Collection) Queue(_ string) *CouchbaseQueue {
	return nil
}

func (_ *Collection) Remove(_ string, _ *RemoveOptions) (*MutationResult, error) {
	return nil, nil
}

func (_ *Collection) Replace(_ string, _ interface{}, _ *ReplaceOptions) (*MutationResult, error) {
	return nil, nil
}

func (_ *Collection) ScopeName() string {
	return ""
}

func (_ *Collection) Set(_ string) *CouchbaseSet {
	return nil
}

func (_ *Collection) Touch(_ string, _ time.Duration, _ *TouchOptions) (*MutationResult, error) {
	return nil, nil
}

func (_ *Collection) Unlock(_ string, _ Cas, _ *UnlockOptions) error {
	return nil
}

func (_ *Collection) Upsert(_ string, _ interface{}, _ *UpsertOptions) (*MutationResult, error) {
	return nil, nil
}

type CollectionManager struct{}

func (_ *CollectionManager) CreateCollection(_ CollectionSpec, _ *CreateCollectionOptions) error {
	return nil
}

func (_ *CollectionManager) CreateScope(_ string, _ *CreateScopeOptions) error {
	return nil
}

func (_ *CollectionManager) DropCollection(_ CollectionSpec, _ *DropCollectionOptions) error {
	return nil
}

func (_ *CollectionManager) DropScope(_ string, _ *DropScopeOptions) error {
	return nil
}

func (_ *CollectionManager) GetAllScopes(_ *GetAllScopesOptions) ([]ScopeSpec, error) {
	return nil, nil
}

type CollectionSpec struct {
	Name      string
	ScopeName string
	MaxExpiry time.Duration
}

type CompressionMode string

type ConflictResolutionType string

type ConnectAnalyticsLinkOptions struct {
	LinkName      string
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type CouchbaseList struct{}

func (_ *CouchbaseList) Append(_ interface{}) error {
	return nil
}

func (_ *CouchbaseList) At(_ int, _ interface{}) error {
	return nil
}

func (_ *CouchbaseList) Clear() error {
	return nil
}

func (_ *CouchbaseList) IndexOf(_ interface{}) (int, error) {
	return 0, nil
}

func (_ *CouchbaseList) Iterator() ([]interface{}, error) {
	return nil, nil
}

func (_ *CouchbaseList) Prepend(_ interface{}) error {
	return nil
}

func (_ *CouchbaseList) RemoveAt(_ int) error {
	return nil
}

func (_ *CouchbaseList) Size() (int, error) {
	return 0, nil
}

type CouchbaseMap struct{}

func (_ *CouchbaseMap) Add(_ string, _ interface{}) error {
	return nil
}

func (_ *CouchbaseMap) At(_ string, _ interface{}) error {
	return nil
}

func (_ *CouchbaseMap) Clear() error {
	return nil
}

func (_ *CouchbaseMap) Exists(_ string) (bool, error) {
	return false, nil
}

func (_ *CouchbaseMap) Iterator() (map[string]interface{}, error) {
	return nil, nil
}

func (_ *CouchbaseMap) Keys() ([]string, error) {
	return nil, nil
}

func (_ *CouchbaseMap) Remove(_ string) error {
	return nil
}

func (_ *CouchbaseMap) Size() (int, error) {
	return 0, nil
}

func (_ *CouchbaseMap) Values() ([]interface{}, error) {
	return nil, nil
}

type CouchbaseQueue struct{}

func (_ *CouchbaseQueue) Clear() error {
	return nil
}

func (_ *CouchbaseQueue) Iterator() ([]interface{}, error) {
	return nil, nil
}

func (_ *CouchbaseQueue) Pop(_ interface{}) error {
	return nil
}

func (_ *CouchbaseQueue) Push(_ interface{}) error {
	return nil
}

func (_ *CouchbaseQueue) Size() (int, error) {
	return 0, nil
}

type CouchbaseSet struct{}

func (_ *CouchbaseSet) Add(_ interface{}) error {
	return nil
}

func (_ *CouchbaseSet) Clear() error {
	return nil
}

func (_ *CouchbaseSet) Contains(_ string) (bool, error) {
	return false, nil
}

func (_ *CouchbaseSet) Iterator() ([]interface{}, error) {
	return nil, nil
}

func (_ *CouchbaseSet) Remove(_ string) error {
	return nil
}

func (_ *CouchbaseSet) Size() (int, error) {
	return 0, nil
}

func (_ *CouchbaseSet) Values() ([]interface{}, error) {
	return nil, nil
}

type CounterResult struct {
	MutationResult MutationResult
}

func (_ CounterResult) Cas() Cas {
	return 0
}

func (_ CounterResult) Content() uint64 {
	return 0
}

func (_ CounterResult) MutationToken() *MutationToken {
	return nil
}

type CreateAnalyticsDatasetOptions struct {
	IgnoreIfExists bool
	Condition      string
	DataverseName  string
	Timeout        time.Duration
	RetryStrategy  RetryStrategy
}

type CreateAnalyticsDataverseOptions struct {
	IgnoreIfExists bool
	Timeout        time.Duration
	RetryStrategy  RetryStrategy
}

type CreateAnalyticsIndexOptions struct {
	IgnoreIfExists bool
	DataverseName  string
	Timeout        time.Duration
	RetryStrategy  RetryStrategy
}

type CreateBucketOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type CreateBucketSettings struct {
	BucketSettings         BucketSettings
	ConflictResolutionType ConflictResolutionType
}

type CreateCollectionOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type CreatePrimaryQueryIndexOptions struct {
	IgnoreIfExists bool
	Deferred       bool
	CustomName     string
	Timeout        time.Duration
	RetryStrategy  RetryStrategy
}

type CreateQueryIndexOptions struct {
	IgnoreIfExists bool
	Deferred       bool
	Timeout        time.Duration
	RetryStrategy  RetryStrategy
}

type CreateScopeOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type DecrementOptions struct {
	Timeout         time.Duration
	Expiry          time.Duration
	Initial         int64
	Delta           uint64
	DurabilityLevel DurabilityLevel
	PersistTo       uint
	ReplicateTo     uint
	Cas             Cas
	RetryStrategy   RetryStrategy
	Internal        struct {
		User []byte
	}
}

type DesignDocument struct {
	Name  string
	Views map[string]View
}

type DesignDocumentNamespace uint

type DiagnosticsOptions struct {
	ReportID string
}

type DiagnosticsResult struct {
	ID       string
	Services map[string][]EndPointDiagnostics
	State    ClusterState
}

func (_ *DiagnosticsResult) MarshalJSON() ([]byte, error) {
	return nil, nil
}

type DisconnectAnalyticsLinkOptions struct {
	LinkName      string
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type DropAnalyticsDatasetOptions struct {
	IgnoreIfNotExists bool
	DataverseName     string
	Timeout           time.Duration
	RetryStrategy     RetryStrategy
}

type DropAnalyticsDataverseOptions struct {
	IgnoreIfNotExists bool
	Timeout           time.Duration
	RetryStrategy     RetryStrategy
}

type DropAnalyticsIndexOptions struct {
	IgnoreIfNotExists bool
	DataverseName     string
	Timeout           time.Duration
	RetryStrategy     RetryStrategy
}

type DropBucketOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type DropCollectionOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type DropDesignDocumentOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type DropGroupOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type DropPrimaryQueryIndexOptions struct {
	IgnoreIfNotExists bool
	CustomName        string
	Timeout           time.Duration
	RetryStrategy     RetryStrategy
}

type DropQueryIndexOptions struct {
	IgnoreIfNotExists bool
	Timeout           time.Duration
	RetryStrategy     RetryStrategy
}

type DropScopeOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type DropSearchIndexOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type DropUserOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
	DomainName    string
}

type DurabilityLevel uint8

type EndPointDiagnostics struct {
	Type         ServiceType
	ID           string
	Local        string
	Remote       string
	LastActivity time.Time
	State        EndpointState
	Namespace    string
}

type EndpointPingReport struct {
	ID        string
	Local     string
	Remote    string
	State     PingState
	Error     string
	Namespace string
	Latency   time.Duration
}

type EndpointState uint

type EvictionPolicyType string

type ExistsOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
	Internal      struct {
		User []byte
	}
}

type ExistsResult struct {
	Result Result
}

func (_ *ExistsResult) Cas() Cas {
	return 0
}

func (_ *ExistsResult) Exists() bool {
	return false
}

type FlushBucketOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type GetAllAnalyticsDatasetsOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type GetAllAnalyticsIndexesOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type GetAllBucketsOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type GetAllDesignDocumentsOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type GetAllGroupsOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type GetAllQueryIndexesOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type GetAllReplicaOptions struct {
	Transcoder    Transcoder
	Timeout       time.Duration
	RetryStrategy RetryStrategy
	Internal      struct {
		User []byte
	}
}

type GetAllReplicasResult struct{}

func (_ *GetAllReplicasResult) Close() error {
	return nil
}

func (_ *GetAllReplicasResult) Next() *GetReplicaResult {
	return nil
}

type GetAllScopesOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type GetAllSearchIndexOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type GetAllUsersOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
	DomainName    string
}

type GetAndLockOptions struct {
	Transcoder    Transcoder
	Timeout       time.Duration
	RetryStrategy RetryStrategy
	Internal      struct {
		User []byte
	}
}

type GetAndTouchOptions struct {
	Transcoder    Transcoder
	Timeout       time.Duration
	RetryStrategy RetryStrategy
	Internal      struct {
		User []byte
	}
}

type GetAnyReplicaOptions struct {
	Transcoder    Transcoder
	Timeout       time.Duration
	RetryStrategy RetryStrategy
	Internal      struct {
		User []byte
	}
}

type GetBucketOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type GetDesignDocumentOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type GetGroupOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type GetIndexedDocumentsCountOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type GetOptions struct {
	WithExpiry    bool
	Project       []string
	Transcoder    Transcoder
	Timeout       time.Duration
	RetryStrategy RetryStrategy
	Internal      struct {
		User []byte
	}
}

type GetPendingMutationsAnalyticsOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type GetReplicaResult struct {
	GetResult GetResult
}

func (_ *GetReplicaResult) Cas() Cas {
	return 0
}

func (_ *GetReplicaResult) Content(_ interface{}) error {
	return nil
}

func (_ *GetReplicaResult) Expiry() *time.Duration {
	return nil
}

func (_ *GetReplicaResult) ExpiryTime() time.Time {
	return time.Time{}
}

func (_ *GetReplicaResult) IsReplica() bool {
	return false
}

type GetResult struct {
	Result Result
}

func (_ *GetResult) Cas() Cas {
	return 0
}

func (_ *GetResult) Content(_ interface{}) error {
	return nil
}

func (_ *GetResult) Expiry() *time.Duration {
	return nil
}

func (_ *GetResult) ExpiryTime() time.Time {
	return time.Time{}
}

type GetRolesOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type GetSearchIndexOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type GetUserOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
	DomainName    string
}

type Group struct {
	Name               string
	Description        string
	Roles              []Role
	LDAPGroupReference string
}

type IncrementOptions struct {
	Timeout         time.Duration
	Expiry          time.Duration
	Initial         int64
	Delta           uint64
	DurabilityLevel DurabilityLevel
	PersistTo       uint
	ReplicateTo     uint
	Cas             Cas
	RetryStrategy   RetryStrategy
	Internal        struct {
		User []byte
	}
}

type InsertOptions struct {
	Expiry          time.Duration
	PersistTo       uint
	ReplicateTo     uint
	DurabilityLevel DurabilityLevel
	Transcoder      Transcoder
	Timeout         time.Duration
	RetryStrategy   RetryStrategy
	Internal        struct {
		User []byte
	}
}

type InternalBucket struct{}

func (_ *InternalBucket) IORouter() (interface{}, error) {
	return nil, nil
}

type LookupInOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
	Internal      struct {
		AccessDeleted bool
		User          []byte
	}
}

type LookupInResult struct {
	Result Result
}

func (_ *LookupInResult) Cas() Cas {
	return 0
}

func (_ *LookupInResult) ContentAt(_ uint, _ interface{}) error {
	return nil
}

func (_ *LookupInResult) Exists(_ uint) bool {
	return false
}

type LookupInSpec struct{}

type MutateInOptions struct {
	Expiry          time.Duration
	Cas             Cas
	PersistTo       uint
	ReplicateTo     uint
	DurabilityLevel DurabilityLevel
	StoreSemantic   StoreSemantics
	Timeout         time.Duration
	RetryStrategy   RetryStrategy
	Internal        struct {
		AccessDeleted bool
		User          []byte
	}
}

type MutateInResult struct {
	MutationResult MutationResult
}

func (_ MutateInResult) ContentAt(_ uint, _ interface{}) error {
	return nil
}

func (_ MutateInResult) MutationToken() *MutationToken {
	return nil
}

func (_ *MutateInResult) Cas() Cas {
	return 0
}

type MutateInSpec struct{}

type MutationResult struct {
	Result Result
}

func (_ MutationResult) MutationToken() *MutationToken {
	return nil
}

func (_ *MutationResult) Cas() Cas {
	return 0
}

type MutationState struct{}

func (_ *MutationState) Add(_ ...MutationToken) {}

func (_ *MutationState) Internal() *MutationStateInternal {
	return nil
}

func (_ *MutationState) MarshalJSON() ([]byte, error) {
	return nil, nil
}

func (_ *MutationState) UnmarshalJSON(_ []byte) error {
	return nil
}

type MutationStateInternal struct{}

func (_ *MutationStateInternal) Add(_ string, _ ...interface{}) {}

func (_ *MutationStateInternal) Tokens() []MutationToken {
	return nil
}

type MutationToken struct{}

func (_ MutationToken) BucketName() string {
	return ""
}

func (_ MutationToken) PartitionID() uint64 {
	return 0
}

func (_ MutationToken) PartitionUUID() uint64 {
	return 0
}

func (_ MutationToken) SequenceNumber() uint64 {
	return 0
}

type Origin struct {
	Type string
	Name string
}

type PauseIngestSearchIndexOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type PingOptions struct {
	ServiceTypes []ServiceType
	ReportID     string
	Timeout      time.Duration
}

type PingResult struct {
	ID       string
	Services map[ServiceType][]EndpointPingReport
}

func (_ *PingResult) MarshalJSON() ([]byte, error) {
	return nil, nil
}

type PingState uint

type PrependOptions struct {
	Timeout         time.Duration
	DurabilityLevel DurabilityLevel
	PersistTo       uint
	ReplicateTo     uint
	Cas             Cas
	RetryStrategy   RetryStrategy
	Internal        struct {
		User []byte
	}
}

type PublishDesignDocumentOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type QueryIndex struct {
	Name      string
	IsPrimary bool
	Type      QueryIndexType
	State     string
	Keyspace  string
	Namespace string
	IndexKey  []string
	Condition string
}

type QueryIndexManager struct{}

func (_ *QueryIndexManager) BuildDeferredIndexes(_ string, _ *BuildDeferredQueryIndexOptions) ([]string, error) {
	return nil, nil
}

func (_ *QueryIndexManager) CreateIndex(_ string, _ string, _ []string, _ *CreateQueryIndexOptions) error {
	return nil
}

func (_ *QueryIndexManager) CreatePrimaryIndex(_ string, _ *CreatePrimaryQueryIndexOptions) error {
	return nil
}

func (_ *QueryIndexManager) DropIndex(_ string, _ string, _ *DropQueryIndexOptions) error {
	return nil
}

func (_ *QueryIndexManager) DropPrimaryIndex(_ string, _ *DropPrimaryQueryIndexOptions) error {
	return nil
}

func (_ *QueryIndexManager) GetAllIndexes(_ string, _ *GetAllQueryIndexesOptions) ([]QueryIndex, error) {
	return nil, nil
}

func (_ *QueryIndexManager) WatchIndexes(_ string, _ []string, _ time.Duration, _ *WatchQueryIndexOptions) error {
	return nil
}

type QueryIndexType string

type QueryMetaData struct {
	RequestID       string
	ClientContextID string
	Status          QueryStatus
	Metrics         QueryMetrics
	Signature       interface{}
	Warnings        []QueryWarning
	Profile         interface{}
}

type QueryMetrics struct {
	ElapsedTime   time.Duration
	ExecutionTime time.Duration
	ResultCount   uint64
	ResultSize    uint64
	MutationCount uint64
	SortCount     uint64
	ErrorCount    uint64
	WarningCount  uint64
}

type QueryOptions struct {
	ScanConsistency      QueryScanConsistency
	ConsistentWith       *MutationState
	Profile              QueryProfileMode
	ScanCap              uint32
	PipelineBatch        uint32
	PipelineCap          uint32
	ScanWait             time.Duration
	Readonly             bool
	MaxParallelism       uint32
	ClientContextID      string
	PositionalParameters []interface{}
	NamedParameters      map[string]interface{}
	Metrics              bool
	Raw                  map[string]interface{}
	Adhoc                bool
	Timeout              time.Duration
	RetryStrategy        RetryStrategy
	FlexIndex            bool
}

type QueryProfileMode string

type QueryResult struct{}

func (_ *QueryResult) Close() error {
	return nil
}

func (_ *QueryResult) Err() error {
	return nil
}

func (_ *QueryResult) MetaData() (*QueryMetaData, error) {
	return nil, nil
}

func (_ *QueryResult) Next() bool {
	return false
}

func (_ *QueryResult) One(_ interface{}) error {
	return nil
}

func (_ *QueryResult) Raw() *QueryResultRaw {
	return nil
}

func (_ *QueryResult) Row(_ interface{}) error {
	return nil
}

type QueryResultRaw struct{}

func (_ *QueryResultRaw) Close() error {
	return nil
}

func (_ *QueryResultRaw) Err() error {
	return nil
}

func (_ *QueryResultRaw) MetaData() ([]byte, error) {
	return nil, nil
}

func (_ *QueryResultRaw) NextBytes() []byte {
	return nil
}

type QueryScanConsistency uint

type QueryStatus string

type QueryWarning struct {
	Code    uint32
	Message string
}

type RemoveOptions struct {
	Cas             Cas
	PersistTo       uint
	ReplicateTo     uint
	DurabilityLevel DurabilityLevel
	Timeout         time.Duration
	RetryStrategy   RetryStrategy
	Internal        struct {
		User []byte
	}
}

type ReplaceOptions struct {
	Expiry          time.Duration
	Cas             Cas
	PersistTo       uint
	ReplicateTo     uint
	DurabilityLevel DurabilityLevel
	Transcoder      Transcoder
	Timeout         time.Duration
	RetryStrategy   RetryStrategy
	Internal        struct {
		User []byte
	}
}

type Result struct{}

func (_ *Result) Cas() Cas {
	return 0
}

type ResumeIngestSearchIndexOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type RetryAction interface {
	Duration() time.Duration
}

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

type RetryRequest interface {
	Idempotent() bool
	Identifier() string
	RetryAttempts() uint32
	RetryReasons() []RetryReason
}

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

type Role struct {
	Name       string
	Bucket     string
	Scope      string
	Collection string
}

type RoleAndDescription struct {
	Role        Role
	DisplayName string
	Description string
}

type RoleAndOrigins struct {
	Role    Role
	Origins []Origin
}

type Scope struct{}

func (_ *Scope) AnalyticsQuery(_ string, _ *AnalyticsOptions) (*AnalyticsResult, error) {
	return nil, nil
}

func (_ *Scope) BucketName() string {
	return ""
}

func (_ *Scope) Collection(_ string) *Collection {
	return nil
}

func (_ *Scope) Name() string {
	return ""
}

func (_ *Scope) Query(_ string, _ *QueryOptions) (*QueryResult, error) {
	return nil, nil
}

type ScopeSpec struct {
	Name        string
	Collections []CollectionSpec
}

type SearchDateRangeFacetResult struct {
	Name  string
	Start string
	End   string
	Count int
}

type SearchFacetResult struct {
	Name          string
	Field         string
	Total         uint64
	Missing       uint64
	Other         uint64
	Terms         []SearchTermFacetResult
	NumericRanges []SearchNumericRangeFacetResult
	DateRanges    []SearchDateRangeFacetResult
}

type SearchHighlightOptions struct {
	Style  SearchHighlightStyle
	Fields []string
}

type SearchHighlightStyle string

type SearchIndex struct {
	UUID         string
	Name         string
	SourceName   string
	Type         string
	Params       map[string]interface{}
	SourceUUID   string
	SourceParams map[string]interface{}
	SourceType   string
	PlanParams   map[string]interface{}
}

type SearchIndexManager struct{}

func (_ *SearchIndexManager) AllowQuerying(_ string, _ *AllowQueryingSearchIndexOptions) error {
	return nil
}

func (_ *SearchIndexManager) AnalyzeDocument(_ string, _ interface{}, _ *AnalyzeDocumentOptions) ([]interface{}, error) {
	return nil, nil
}

func (_ *SearchIndexManager) DisallowQuerying(_ string, _ *AllowQueryingSearchIndexOptions) error {
	return nil
}

func (_ *SearchIndexManager) DropIndex(_ string, _ *DropSearchIndexOptions) error {
	return nil
}

func (_ *SearchIndexManager) FreezePlan(_ string, _ *AllowQueryingSearchIndexOptions) error {
	return nil
}

func (_ *SearchIndexManager) GetAllIndexes(_ *GetAllSearchIndexOptions) ([]SearchIndex, error) {
	return nil, nil
}

func (_ *SearchIndexManager) GetIndex(_ string, _ *GetSearchIndexOptions) (*SearchIndex, error) {
	return nil, nil
}

func (_ *SearchIndexManager) GetIndexedDocumentsCount(_ string, _ *GetIndexedDocumentsCountOptions) (uint64, error) {
	return 0, nil
}

func (_ *SearchIndexManager) PauseIngest(_ string, _ *PauseIngestSearchIndexOptions) error {
	return nil
}

func (_ *SearchIndexManager) ResumeIngest(_ string, _ *ResumeIngestSearchIndexOptions) error {
	return nil
}

func (_ *SearchIndexManager) UnfreezePlan(_ string, _ *AllowQueryingSearchIndexOptions) error {
	return nil
}

func (_ *SearchIndexManager) UpsertIndex(_ SearchIndex, _ *UpsertSearchIndexOptions) error {
	return nil
}

type SearchMetaData struct {
	Metrics SearchMetrics
	Errors  map[string]string
}

type SearchMetrics struct {
	Took                  time.Duration
	TotalRows             uint64
	MaxScore              float64
	TotalPartitionCount   uint64
	SuccessPartitionCount uint64
	ErrorPartitionCount   uint64
}

type SearchNumericRangeFacetResult struct {
	Name  string
	Min   float64
	Max   float64
	Count int
}

type SearchOptions struct {
	ScanConsistency SearchScanConsistency
	Limit           uint32
	Skip            uint32
	Explain         bool
	Highlight       *SearchHighlightOptions
	Fields          []string
	Sort            []interface{}
	Facets          map[string]interface{}
	ConsistentWith  *MutationState
	Raw             map[string]interface{}
	Timeout         time.Duration
	RetryStrategy   RetryStrategy
	DisableScoring  bool
}

type SearchResult struct{}

func (_ *SearchResult) Close() error {
	return nil
}

func (_ *SearchResult) Err() error {
	return nil
}

func (_ *SearchResult) Facets() (map[string]SearchFacetResult, error) {
	return nil, nil
}

func (_ *SearchResult) MetaData() (*SearchMetaData, error) {
	return nil, nil
}

func (_ *SearchResult) Next() bool {
	return false
}

func (_ *SearchResult) Raw() *SearchResultRaw {
	return nil
}

func (_ *SearchResult) Row() SearchRow {
	return SearchRow{}
}

type SearchResultRaw struct{}

func (_ *SearchResultRaw) Close() error {
	return nil
}

func (_ *SearchResultRaw) Err() error {
	return nil
}

func (_ *SearchResultRaw) MetaData() ([]byte, error) {
	return nil, nil
}

func (_ *SearchResultRaw) NextBytes() []byte {
	return nil
}

type SearchRow struct {
	Index       string
	ID          string
	Score       float64
	Explanation interface{}
	Locations   map[string]map[string][]SearchRowLocation
	Fragments   map[string][]string
}

func (_ *SearchRow) Fields(_ interface{}) error {
	return nil
}

type SearchRowLocation struct {
	Position       uint32
	Start          uint32
	End            uint32
	ArrayPositions []uint32
}

type SearchScanConsistency uint

type SearchTermFacetResult struct {
	Term  string
	Count int
}

type ServiceType int

type StoreSemantics uint8

type TouchOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
	Internal      struct {
		User []byte
	}
}

type Transcoder interface {
	Decode(_ []byte, _ uint32, _ interface{}) error
	Encode(_ interface{}) ([]byte, uint32, error)
}

type UnlockOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
	Internal      struct {
		User []byte
	}
}

type UpdateBucketOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type UpsertDesignDocumentOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type UpsertGroupOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type UpsertOptions struct {
	Expiry          time.Duration
	PersistTo       uint
	ReplicateTo     uint
	DurabilityLevel DurabilityLevel
	Transcoder      Transcoder
	Timeout         time.Duration
	RetryStrategy   RetryStrategy
	Internal        struct {
		User []byte
	}
}

type UpsertSearchIndexOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
}

type UpsertUserOptions struct {
	Timeout       time.Duration
	RetryStrategy RetryStrategy
	DomainName    string
}

type User struct {
	Username    string
	DisplayName string
	Roles       []Role
	Groups      []string
	Password    string
}

type UserAndMetadata struct {
	User            User
	Domain          AuthDomain
	EffectiveRoles  []RoleAndOrigins
	ExternalGroups  []string
	PasswordChanged time.Time
}

type UserManager struct{}

func (_ *UserManager) DropGroup(_ string, _ *DropGroupOptions) error {
	return nil
}

func (_ *UserManager) DropUser(_ string, _ *DropUserOptions) error {
	return nil
}

func (_ *UserManager) GetAllGroups(_ *GetAllGroupsOptions) ([]Group, error) {
	return nil, nil
}

func (_ *UserManager) GetAllUsers(_ *GetAllUsersOptions) ([]UserAndMetadata, error) {
	return nil, nil
}

func (_ *UserManager) GetGroup(_ string, _ *GetGroupOptions) (*Group, error) {
	return nil, nil
}

func (_ *UserManager) GetRoles(_ *GetRolesOptions) ([]RoleAndDescription, error) {
	return nil, nil
}

func (_ *UserManager) GetUser(_ string, _ *GetUserOptions) (*UserAndMetadata, error) {
	return nil, nil
}

func (_ *UserManager) UpsertGroup(_ Group, _ *UpsertGroupOptions) error {
	return nil
}

func (_ *UserManager) UpsertUser(_ User, _ *UpsertUserOptions) error {
	return nil
}

type View struct {
	Map    string
	Reduce string
}

type ViewErrorMode uint

type ViewIndexManager struct{}

func (_ *ViewIndexManager) DropDesignDocument(_ string, _ DesignDocumentNamespace, _ *DropDesignDocumentOptions) error {
	return nil
}

func (_ *ViewIndexManager) GetAllDesignDocuments(_ DesignDocumentNamespace, _ *GetAllDesignDocumentsOptions) ([]DesignDocument, error) {
	return nil, nil
}

func (_ *ViewIndexManager) GetDesignDocument(_ string, _ DesignDocumentNamespace, _ *GetDesignDocumentOptions) (*DesignDocument, error) {
	return nil, nil
}

func (_ *ViewIndexManager) PublishDesignDocument(_ string, _ *PublishDesignDocumentOptions) error {
	return nil
}

func (_ *ViewIndexManager) UpsertDesignDocument(_ DesignDocument, _ DesignDocumentNamespace, _ *UpsertDesignDocumentOptions) error {
	return nil
}

type ViewMetaData struct {
	TotalRows uint64
	Debug     interface{}
}

type ViewOptions struct {
	ScanConsistency ViewScanConsistency
	Skip            uint32
	Limit           uint32
	Order           ViewOrdering
	Reduce          bool
	Group           bool
	GroupLevel      uint32
	Key             interface{}
	Keys            []interface{}
	StartKey        interface{}
	EndKey          interface{}
	InclusiveEnd    bool
	StartKeyDocID   string
	EndKeyDocID     string
	OnError         ViewErrorMode
	Debug           bool
	Raw             map[string]string
	Namespace       DesignDocumentNamespace
	Timeout         time.Duration
	RetryStrategy   RetryStrategy
}

type ViewOrdering uint

type ViewResult struct{}

func (_ *ViewResult) Close() error {
	return nil
}

func (_ *ViewResult) Err() error {
	return nil
}

func (_ *ViewResult) MetaData() (*ViewMetaData, error) {
	return nil, nil
}

func (_ *ViewResult) Next() bool {
	return false
}

func (_ *ViewResult) Raw() *ViewResultRaw {
	return nil
}

func (_ *ViewResult) Row() ViewRow {
	return ViewRow{}
}

type ViewResultRaw struct{}

func (_ *ViewResultRaw) Close() error {
	return nil
}

func (_ *ViewResultRaw) Err() error {
	return nil
}

func (_ *ViewResultRaw) MetaData() ([]byte, error) {
	return nil, nil
}

func (_ *ViewResultRaw) NextBytes() []byte {
	return nil
}

type ViewRow struct {
	ID string
}

func (_ *ViewRow) Key(_ interface{}) error {
	return nil
}

func (_ *ViewRow) Value(_ interface{}) error {
	return nil
}

type ViewScanConsistency uint

type WaitUntilReadyOptions struct {
	DesiredState ClusterState
	ServiceTypes []ServiceType
}

type WatchQueryIndexOptions struct {
	WatchPrimary  bool
	RetryStrategy RetryStrategy
}
