// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/nats-io/nats.go (interfaces: KeyValue,KeyValueEntry)
//
// Generated by this command:
//
//	mockgen -write_generate_directive -package kvwatcher -destination aagent/watchers/kvwatcher/kv_mock_test.go github.com/nats-io/nats.go KeyValue,KeyValueEntry
//

// Package kvwatcher is a generated GoMock package.
package kvwatcher

import (
	reflect "reflect"
	time "time"

	nats "github.com/nats-io/nats.go"
	gomock "go.uber.org/mock/gomock"
)

//go:generate mockgen -write_generate_directive -package kvwatcher -destination aagent/watchers/kvwatcher/kv_mock_test.go github.com/nats-io/nats.go KeyValue,KeyValueEntry

// MockKeyValue is a mock of KeyValue interface.
type MockKeyValue struct {
	ctrl     *gomock.Controller
	recorder *MockKeyValueMockRecorder
	isgomock struct{}
}

// MockKeyValueMockRecorder is the mock recorder for MockKeyValue.
type MockKeyValueMockRecorder struct {
	mock *MockKeyValue
}

// NewMockKeyValue creates a new mock instance.
func NewMockKeyValue(ctrl *gomock.Controller) *MockKeyValue {
	mock := &MockKeyValue{ctrl: ctrl}
	mock.recorder = &MockKeyValueMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockKeyValue) EXPECT() *MockKeyValueMockRecorder {
	return m.recorder
}

// Bucket mocks base method.
func (m *MockKeyValue) Bucket() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Bucket")
	ret0, _ := ret[0].(string)
	return ret0
}

// Bucket indicates an expected call of Bucket.
func (mr *MockKeyValueMockRecorder) Bucket() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bucket", reflect.TypeOf((*MockKeyValue)(nil).Bucket))
}

// Create mocks base method.
func (m *MockKeyValue) Create(key string, value []byte) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Create", key, value)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Create indicates an expected call of Create.
func (mr *MockKeyValueMockRecorder) Create(key, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockKeyValue)(nil).Create), key, value)
}

// Delete mocks base method.
func (m *MockKeyValue) Delete(key string, opts ...nats.DeleteOpt) error {
	m.ctrl.T.Helper()
	varargs := []any{key}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Delete", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Delete indicates an expected call of Delete.
func (mr *MockKeyValueMockRecorder) Delete(key any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{key}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockKeyValue)(nil).Delete), varargs...)
}

// Get mocks base method.
func (m *MockKeyValue) Get(key string) (nats.KeyValueEntry, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get", key)
	ret0, _ := ret[0].(nats.KeyValueEntry)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockKeyValueMockRecorder) Get(key any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockKeyValue)(nil).Get), key)
}

// GetRevision mocks base method.
func (m *MockKeyValue) GetRevision(key string, revision uint64) (nats.KeyValueEntry, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRevision", key, revision)
	ret0, _ := ret[0].(nats.KeyValueEntry)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetRevision indicates an expected call of GetRevision.
func (mr *MockKeyValueMockRecorder) GetRevision(key, revision any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRevision", reflect.TypeOf((*MockKeyValue)(nil).GetRevision), key, revision)
}

// History mocks base method.
func (m *MockKeyValue) History(key string, opts ...nats.WatchOpt) ([]nats.KeyValueEntry, error) {
	m.ctrl.T.Helper()
	varargs := []any{key}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "History", varargs...)
	ret0, _ := ret[0].([]nats.KeyValueEntry)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// History indicates an expected call of History.
func (mr *MockKeyValueMockRecorder) History(key any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{key}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "History", reflect.TypeOf((*MockKeyValue)(nil).History), varargs...)
}

// Keys mocks base method.
func (m *MockKeyValue) Keys(opts ...nats.WatchOpt) ([]string, error) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Keys", varargs...)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Keys indicates an expected call of Keys.
func (mr *MockKeyValueMockRecorder) Keys(opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Keys", reflect.TypeOf((*MockKeyValue)(nil).Keys), opts...)
}

// ListKeys mocks base method.
func (m *MockKeyValue) ListKeys(opts ...nats.WatchOpt) (nats.KeyLister, error) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ListKeys", varargs...)
	ret0, _ := ret[0].(nats.KeyLister)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListKeys indicates an expected call of ListKeys.
func (mr *MockKeyValueMockRecorder) ListKeys(opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKeys", reflect.TypeOf((*MockKeyValue)(nil).ListKeys), opts...)
}

// Purge mocks base method.
func (m *MockKeyValue) Purge(key string, opts ...nats.DeleteOpt) error {
	m.ctrl.T.Helper()
	varargs := []any{key}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Purge", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// Purge indicates an expected call of Purge.
func (mr *MockKeyValueMockRecorder) Purge(key any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{key}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Purge", reflect.TypeOf((*MockKeyValue)(nil).Purge), varargs...)
}

// PurgeDeletes mocks base method.
func (m *MockKeyValue) PurgeDeletes(opts ...nats.PurgeOpt) error {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "PurgeDeletes", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

// PurgeDeletes indicates an expected call of PurgeDeletes.
func (mr *MockKeyValueMockRecorder) PurgeDeletes(opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PurgeDeletes", reflect.TypeOf((*MockKeyValue)(nil).PurgeDeletes), opts...)
}

// Put mocks base method.
func (m *MockKeyValue) Put(key string, value []byte) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Put", key, value)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Put indicates an expected call of Put.
func (mr *MockKeyValueMockRecorder) Put(key, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockKeyValue)(nil).Put), key, value)
}

// PutString mocks base method.
func (m *MockKeyValue) PutString(key, value string) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PutString", key, value)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// PutString indicates an expected call of PutString.
func (mr *MockKeyValueMockRecorder) PutString(key, value any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutString", reflect.TypeOf((*MockKeyValue)(nil).PutString), key, value)
}

// Status mocks base method.
func (m *MockKeyValue) Status() (nats.KeyValueStatus, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Status")
	ret0, _ := ret[0].(nats.KeyValueStatus)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Status indicates an expected call of Status.
func (mr *MockKeyValueMockRecorder) Status() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Status", reflect.TypeOf((*MockKeyValue)(nil).Status))
}

// Update mocks base method.
func (m *MockKeyValue) Update(key string, value []byte, last uint64) (uint64, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Update", key, value, last)
	ret0, _ := ret[0].(uint64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Update indicates an expected call of Update.
func (mr *MockKeyValueMockRecorder) Update(key, value, last any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockKeyValue)(nil).Update), key, value, last)
}

// Watch mocks base method.
func (m *MockKeyValue) Watch(keys string, opts ...nats.WatchOpt) (nats.KeyWatcher, error) {
	m.ctrl.T.Helper()
	varargs := []any{keys}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Watch", varargs...)
	ret0, _ := ret[0].(nats.KeyWatcher)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Watch indicates an expected call of Watch.
func (mr *MockKeyValueMockRecorder) Watch(keys any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{keys}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Watch", reflect.TypeOf((*MockKeyValue)(nil).Watch), varargs...)
}

// WatchAll mocks base method.
func (m *MockKeyValue) WatchAll(opts ...nats.WatchOpt) (nats.KeyWatcher, error) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WatchAll", varargs...)
	ret0, _ := ret[0].(nats.KeyWatcher)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WatchAll indicates an expected call of WatchAll.
func (mr *MockKeyValueMockRecorder) WatchAll(opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchAll", reflect.TypeOf((*MockKeyValue)(nil).WatchAll), opts...)
}

// WatchFiltered mocks base method.
func (m *MockKeyValue) WatchFiltered(keys []string, opts ...nats.WatchOpt) (nats.KeyWatcher, error) {
	m.ctrl.T.Helper()
	varargs := []any{keys}
	for _, a := range opts {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "WatchFiltered", varargs...)
	ret0, _ := ret[0].(nats.KeyWatcher)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WatchFiltered indicates an expected call of WatchFiltered.
func (mr *MockKeyValueMockRecorder) WatchFiltered(keys any, opts ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{keys}, opts...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchFiltered", reflect.TypeOf((*MockKeyValue)(nil).WatchFiltered), varargs...)
}

// MockKeyValueEntry is a mock of KeyValueEntry interface.
type MockKeyValueEntry struct {
	ctrl     *gomock.Controller
	recorder *MockKeyValueEntryMockRecorder
	isgomock struct{}
}

// MockKeyValueEntryMockRecorder is the mock recorder for MockKeyValueEntry.
type MockKeyValueEntryMockRecorder struct {
	mock *MockKeyValueEntry
}

// NewMockKeyValueEntry creates a new mock instance.
func NewMockKeyValueEntry(ctrl *gomock.Controller) *MockKeyValueEntry {
	mock := &MockKeyValueEntry{ctrl: ctrl}
	mock.recorder = &MockKeyValueEntryMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockKeyValueEntry) EXPECT() *MockKeyValueEntryMockRecorder {
	return m.recorder
}

// Bucket mocks base method.
func (m *MockKeyValueEntry) Bucket() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Bucket")
	ret0, _ := ret[0].(string)
	return ret0
}

// Bucket indicates an expected call of Bucket.
func (mr *MockKeyValueEntryMockRecorder) Bucket() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bucket", reflect.TypeOf((*MockKeyValueEntry)(nil).Bucket))
}

// Created mocks base method.
func (m *MockKeyValueEntry) Created() time.Time {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Created")
	ret0, _ := ret[0].(time.Time)
	return ret0
}

// Created indicates an expected call of Created.
func (mr *MockKeyValueEntryMockRecorder) Created() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Created", reflect.TypeOf((*MockKeyValueEntry)(nil).Created))
}

// Delta mocks base method.
func (m *MockKeyValueEntry) Delta() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delta")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// Delta indicates an expected call of Delta.
func (mr *MockKeyValueEntryMockRecorder) Delta() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delta", reflect.TypeOf((*MockKeyValueEntry)(nil).Delta))
}

// Key mocks base method.
func (m *MockKeyValueEntry) Key() string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Key")
	ret0, _ := ret[0].(string)
	return ret0
}

// Key indicates an expected call of Key.
func (mr *MockKeyValueEntryMockRecorder) Key() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Key", reflect.TypeOf((*MockKeyValueEntry)(nil).Key))
}

// Operation mocks base method.
func (m *MockKeyValueEntry) Operation() nats.KeyValueOp {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Operation")
	ret0, _ := ret[0].(nats.KeyValueOp)
	return ret0
}

// Operation indicates an expected call of Operation.
func (mr *MockKeyValueEntryMockRecorder) Operation() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Operation", reflect.TypeOf((*MockKeyValueEntry)(nil).Operation))
}

// Revision mocks base method.
func (m *MockKeyValueEntry) Revision() uint64 {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Revision")
	ret0, _ := ret[0].(uint64)
	return ret0
}

// Revision indicates an expected call of Revision.
func (mr *MockKeyValueEntryMockRecorder) Revision() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Revision", reflect.TypeOf((*MockKeyValueEntry)(nil).Revision))
}

// Value mocks base method.
func (m *MockKeyValueEntry) Value() []byte {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Value")
	ret0, _ := ret[0].([]byte)
	return ret0
}

// Value indicates an expected call of Value.
func (mr *MockKeyValueEntryMockRecorder) Value() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Value", reflect.TypeOf((*MockKeyValueEntry)(nil).Value))
}
