// Code generated by MockGen. DO NOT EDIT.
// Source: k8s.io/client-go/util/workqueue (interfaces: TypedRateLimitingInterface)
//
// Generated by this command:
//
//	mockgen -typed -destination workqueue.go -package mock_k8s -mock_names TypedRateLimitingInterface=MockRateLimitingWorkqueue k8s.io/client-go/util/workqueue TypedRateLimitingInterface
//

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

import (
	reflect "reflect"
	time "time"

	gomock "go.uber.org/mock/gomock"
)

// MockRateLimitingWorkqueue is a mock of TypedRateLimitingInterface interface.
type MockRateLimitingWorkqueue[T comparable] struct {
	ctrl     *gomock.Controller
	recorder *MockRateLimitingWorkqueueMockRecorder[T]
	isgomock struct{}
}

// MockRateLimitingWorkqueueMockRecorder is the mock recorder for MockRateLimitingWorkqueue.
type MockRateLimitingWorkqueueMockRecorder[T comparable] struct {
	mock *MockRateLimitingWorkqueue[T]
}

// NewMockRateLimitingWorkqueue creates a new mock instance.
func NewMockRateLimitingWorkqueue[T comparable](ctrl *gomock.Controller) *MockRateLimitingWorkqueue[T] {
	mock := &MockRateLimitingWorkqueue[T]{ctrl: ctrl}
	mock.recorder = &MockRateLimitingWorkqueueMockRecorder[T]{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockRateLimitingWorkqueue[T]) EXPECT() *MockRateLimitingWorkqueueMockRecorder[T] {
	return m.recorder
}

// Add mocks base method.
func (m *MockRateLimitingWorkqueue[T]) Add(item T) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Add", item)
}

// Add indicates an expected call of Add.
func (mr *MockRateLimitingWorkqueueMockRecorder[T]) Add(item any) *MockRateLimitingWorkqueueAddCall[T] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Add", reflect.TypeOf((*MockRateLimitingWorkqueue[T])(nil).Add), item)
	return &MockRateLimitingWorkqueueAddCall[T]{Call: call}
}

// MockRateLimitingWorkqueueAddCall wrap *gomock.Call
type MockRateLimitingWorkqueueAddCall[T comparable] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockRateLimitingWorkqueueAddCall[T]) Return() *MockRateLimitingWorkqueueAddCall[T] {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRateLimitingWorkqueueAddCall[T]) Do(f func(T)) *MockRateLimitingWorkqueueAddCall[T] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRateLimitingWorkqueueAddCall[T]) DoAndReturn(f func(T)) *MockRateLimitingWorkqueueAddCall[T] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// AddAfter mocks base method.
func (m *MockRateLimitingWorkqueue[T]) AddAfter(item T, duration time.Duration) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddAfter", item, duration)
}

// AddAfter indicates an expected call of AddAfter.
func (mr *MockRateLimitingWorkqueueMockRecorder[T]) AddAfter(item, duration any) *MockRateLimitingWorkqueueAddAfterCall[T] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddAfter", reflect.TypeOf((*MockRateLimitingWorkqueue[T])(nil).AddAfter), item, duration)
	return &MockRateLimitingWorkqueueAddAfterCall[T]{Call: call}
}

// MockRateLimitingWorkqueueAddAfterCall wrap *gomock.Call
type MockRateLimitingWorkqueueAddAfterCall[T comparable] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockRateLimitingWorkqueueAddAfterCall[T]) Return() *MockRateLimitingWorkqueueAddAfterCall[T] {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRateLimitingWorkqueueAddAfterCall[T]) Do(f func(T, time.Duration)) *MockRateLimitingWorkqueueAddAfterCall[T] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRateLimitingWorkqueueAddAfterCall[T]) DoAndReturn(f func(T, time.Duration)) *MockRateLimitingWorkqueueAddAfterCall[T] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// AddRateLimited mocks base method.
func (m *MockRateLimitingWorkqueue[T]) AddRateLimited(item T) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AddRateLimited", item)
}

// AddRateLimited indicates an expected call of AddRateLimited.
func (mr *MockRateLimitingWorkqueueMockRecorder[T]) AddRateLimited(item any) *MockRateLimitingWorkqueueAddRateLimitedCall[T] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddRateLimited", reflect.TypeOf((*MockRateLimitingWorkqueue[T])(nil).AddRateLimited), item)
	return &MockRateLimitingWorkqueueAddRateLimitedCall[T]{Call: call}
}

// MockRateLimitingWorkqueueAddRateLimitedCall wrap *gomock.Call
type MockRateLimitingWorkqueueAddRateLimitedCall[T comparable] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockRateLimitingWorkqueueAddRateLimitedCall[T]) Return() *MockRateLimitingWorkqueueAddRateLimitedCall[T] {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRateLimitingWorkqueueAddRateLimitedCall[T]) Do(f func(T)) *MockRateLimitingWorkqueueAddRateLimitedCall[T] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRateLimitingWorkqueueAddRateLimitedCall[T]) DoAndReturn(f func(T)) *MockRateLimitingWorkqueueAddRateLimitedCall[T] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Done mocks base method.
func (m *MockRateLimitingWorkqueue[T]) Done(item T) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Done", item)
}

// Done indicates an expected call of Done.
func (mr *MockRateLimitingWorkqueueMockRecorder[T]) Done(item any) *MockRateLimitingWorkqueueDoneCall[T] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Done", reflect.TypeOf((*MockRateLimitingWorkqueue[T])(nil).Done), item)
	return &MockRateLimitingWorkqueueDoneCall[T]{Call: call}
}

// MockRateLimitingWorkqueueDoneCall wrap *gomock.Call
type MockRateLimitingWorkqueueDoneCall[T comparable] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockRateLimitingWorkqueueDoneCall[T]) Return() *MockRateLimitingWorkqueueDoneCall[T] {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRateLimitingWorkqueueDoneCall[T]) Do(f func(T)) *MockRateLimitingWorkqueueDoneCall[T] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRateLimitingWorkqueueDoneCall[T]) DoAndReturn(f func(T)) *MockRateLimitingWorkqueueDoneCall[T] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Forget mocks base method.
func (m *MockRateLimitingWorkqueue[T]) Forget(item T) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Forget", item)
}

// Forget indicates an expected call of Forget.
func (mr *MockRateLimitingWorkqueueMockRecorder[T]) Forget(item any) *MockRateLimitingWorkqueueForgetCall[T] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Forget", reflect.TypeOf((*MockRateLimitingWorkqueue[T])(nil).Forget), item)
	return &MockRateLimitingWorkqueueForgetCall[T]{Call: call}
}

// MockRateLimitingWorkqueueForgetCall wrap *gomock.Call
type MockRateLimitingWorkqueueForgetCall[T comparable] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockRateLimitingWorkqueueForgetCall[T]) Return() *MockRateLimitingWorkqueueForgetCall[T] {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRateLimitingWorkqueueForgetCall[T]) Do(f func(T)) *MockRateLimitingWorkqueueForgetCall[T] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRateLimitingWorkqueueForgetCall[T]) DoAndReturn(f func(T)) *MockRateLimitingWorkqueueForgetCall[T] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// Get mocks base method.
func (m *MockRateLimitingWorkqueue[T]) Get() (T, bool) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Get")
	ret0, _ := ret[0].(T)
	ret1, _ := ret[1].(bool)
	return ret0, ret1
}

// Get indicates an expected call of Get.
func (mr *MockRateLimitingWorkqueueMockRecorder[T]) Get() *MockRateLimitingWorkqueueGetCall[T] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockRateLimitingWorkqueue[T])(nil).Get))
	return &MockRateLimitingWorkqueueGetCall[T]{Call: call}
}

// MockRateLimitingWorkqueueGetCall wrap *gomock.Call
type MockRateLimitingWorkqueueGetCall[T comparable] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockRateLimitingWorkqueueGetCall[T]) Return(item T, shutdown bool) *MockRateLimitingWorkqueueGetCall[T] {
	c.Call = c.Call.Return(item, shutdown)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRateLimitingWorkqueueGetCall[T]) Do(f func() (T, bool)) *MockRateLimitingWorkqueueGetCall[T] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRateLimitingWorkqueueGetCall[T]) DoAndReturn(f func() (T, bool)) *MockRateLimitingWorkqueueGetCall[T] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// Len indicates an expected call of Len.
func (mr *MockRateLimitingWorkqueueMockRecorder[T]) Len() *MockRateLimitingWorkqueueLenCall[T] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Len", reflect.TypeOf((*MockRateLimitingWorkqueue[T])(nil).Len))
	return &MockRateLimitingWorkqueueLenCall[T]{Call: call}
}

// MockRateLimitingWorkqueueLenCall wrap *gomock.Call
type MockRateLimitingWorkqueueLenCall[T comparable] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockRateLimitingWorkqueueLenCall[T]) Return(arg0 int) *MockRateLimitingWorkqueueLenCall[T] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRateLimitingWorkqueueLenCall[T]) Do(f func() int) *MockRateLimitingWorkqueueLenCall[T] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRateLimitingWorkqueueLenCall[T]) DoAndReturn(f func() int) *MockRateLimitingWorkqueueLenCall[T] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// NumRequeues mocks base method.
func (m *MockRateLimitingWorkqueue[T]) NumRequeues(item T) int {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NumRequeues", item)
	ret0, _ := ret[0].(int)
	return ret0
}

// NumRequeues indicates an expected call of NumRequeues.
func (mr *MockRateLimitingWorkqueueMockRecorder[T]) NumRequeues(item any) *MockRateLimitingWorkqueueNumRequeuesCall[T] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NumRequeues", reflect.TypeOf((*MockRateLimitingWorkqueue[T])(nil).NumRequeues), item)
	return &MockRateLimitingWorkqueueNumRequeuesCall[T]{Call: call}
}

// MockRateLimitingWorkqueueNumRequeuesCall wrap *gomock.Call
type MockRateLimitingWorkqueueNumRequeuesCall[T comparable] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockRateLimitingWorkqueueNumRequeuesCall[T]) Return(arg0 int) *MockRateLimitingWorkqueueNumRequeuesCall[T] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRateLimitingWorkqueueNumRequeuesCall[T]) Do(f func(T) int) *MockRateLimitingWorkqueueNumRequeuesCall[T] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRateLimitingWorkqueueNumRequeuesCall[T]) DoAndReturn(f func(T) int) *MockRateLimitingWorkqueueNumRequeuesCall[T] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ShutDown mocks base method.
func (m *MockRateLimitingWorkqueue[T]) ShutDown() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ShutDown")
}

// ShutDown indicates an expected call of ShutDown.
func (mr *MockRateLimitingWorkqueueMockRecorder[T]) ShutDown() *MockRateLimitingWorkqueueShutDownCall[T] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutDown", reflect.TypeOf((*MockRateLimitingWorkqueue[T])(nil).ShutDown))
	return &MockRateLimitingWorkqueueShutDownCall[T]{Call: call}
}

// MockRateLimitingWorkqueueShutDownCall wrap *gomock.Call
type MockRateLimitingWorkqueueShutDownCall[T comparable] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockRateLimitingWorkqueueShutDownCall[T]) Return() *MockRateLimitingWorkqueueShutDownCall[T] {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRateLimitingWorkqueueShutDownCall[T]) Do(f func()) *MockRateLimitingWorkqueueShutDownCall[T] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRateLimitingWorkqueueShutDownCall[T]) DoAndReturn(f func()) *MockRateLimitingWorkqueueShutDownCall[T] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

// ShutDownWithDrain mocks base method.
func (m *MockRateLimitingWorkqueue[T]) ShutDownWithDrain() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "ShutDownWithDrain")
}

// ShutDownWithDrain indicates an expected call of ShutDownWithDrain.
func (mr *MockRateLimitingWorkqueueMockRecorder[T]) ShutDownWithDrain() *MockRateLimitingWorkqueueShutDownWithDrainCall[T] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShutDownWithDrain", reflect.TypeOf((*MockRateLimitingWorkqueue[T])(nil).ShutDownWithDrain))
	return &MockRateLimitingWorkqueueShutDownWithDrainCall[T]{Call: call}
}

// MockRateLimitingWorkqueueShutDownWithDrainCall wrap *gomock.Call
type MockRateLimitingWorkqueueShutDownWithDrainCall[T comparable] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockRateLimitingWorkqueueShutDownWithDrainCall[T]) Return() *MockRateLimitingWorkqueueShutDownWithDrainCall[T] {
	c.Call = c.Call.Return()
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRateLimitingWorkqueueShutDownWithDrainCall[T]) Do(f func()) *MockRateLimitingWorkqueueShutDownWithDrainCall[T] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRateLimitingWorkqueueShutDownWithDrainCall[T]) DoAndReturn(f func()) *MockRateLimitingWorkqueueShutDownWithDrainCall[T] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}

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

// ShuttingDown indicates an expected call of ShuttingDown.
func (mr *MockRateLimitingWorkqueueMockRecorder[T]) ShuttingDown() *MockRateLimitingWorkqueueShuttingDownCall[T] {
	mr.mock.ctrl.T.Helper()
	call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ShuttingDown", reflect.TypeOf((*MockRateLimitingWorkqueue[T])(nil).ShuttingDown))
	return &MockRateLimitingWorkqueueShuttingDownCall[T]{Call: call}
}

// MockRateLimitingWorkqueueShuttingDownCall wrap *gomock.Call
type MockRateLimitingWorkqueueShuttingDownCall[T comparable] struct {
	*gomock.Call
}

// Return rewrite *gomock.Call.Return
func (c *MockRateLimitingWorkqueueShuttingDownCall[T]) Return(arg0 bool) *MockRateLimitingWorkqueueShuttingDownCall[T] {
	c.Call = c.Call.Return(arg0)
	return c
}

// Do rewrite *gomock.Call.Do
func (c *MockRateLimitingWorkqueueShuttingDownCall[T]) Do(f func() bool) *MockRateLimitingWorkqueueShuttingDownCall[T] {
	c.Call = c.Call.Do(f)
	return c
}

// DoAndReturn rewrite *gomock.Call.DoAndReturn
func (c *MockRateLimitingWorkqueueShuttingDownCall[T]) DoAndReturn(f func() bool) *MockRateLimitingWorkqueueShuttingDownCall[T] {
	c.Call = c.Call.DoAndReturn(f)
	return c
}
