// Code generated by MockGen. DO NOT EDIT.
// Source: k8s.io/client-go/rest (interfaces: HTTPClient,Interface)

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

import (
	http "net/http"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	schema "k8s.io/apimachinery/pkg/runtime/schema"
	types "k8s.io/apimachinery/pkg/types"
	rest "k8s.io/client-go/rest"
	flowcontrol "k8s.io/client-go/util/flowcontrol"
)

// MockHTTPClient is a mock of HTTPClient interface.
type MockHTTPClient struct {
	ctrl     *gomock.Controller
	recorder *MockHTTPClientMockRecorder
}

// MockHTTPClientMockRecorder is the mock recorder for MockHTTPClient.
type MockHTTPClientMockRecorder struct {
	mock *MockHTTPClient
}

// NewMockHTTPClient creates a new mock instance.
func NewMockHTTPClient(ctrl *gomock.Controller) *MockHTTPClient {
	mock := &MockHTTPClient{ctrl: ctrl}
	mock.recorder = &MockHTTPClientMockRecorder{mock}
	return mock
}

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

// Do mocks base method.
func (m *MockHTTPClient) Do(arg0 *http.Request) (*http.Response, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Do", arg0)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Do indicates an expected call of Do.
func (mr *MockHTTPClientMockRecorder) Do(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Do", reflect.TypeOf((*MockHTTPClient)(nil).Do), arg0)
}

// MockInterface is a mock of Interface interface.
type MockInterface struct {
	ctrl     *gomock.Controller
	recorder *MockInterfaceMockRecorder
}

// MockInterfaceMockRecorder is the mock recorder for MockInterface.
type MockInterfaceMockRecorder struct {
	mock *MockInterface
}

// NewMockInterface creates a new mock instance.
func NewMockInterface(ctrl *gomock.Controller) *MockInterface {
	mock := &MockInterface{ctrl: ctrl}
	mock.recorder = &MockInterfaceMockRecorder{mock}
	return mock
}

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

// APIVersion mocks base method.
func (m *MockInterface) APIVersion() schema.GroupVersion {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "APIVersion")
	ret0, _ := ret[0].(schema.GroupVersion)
	return ret0
}

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

// Delete mocks base method.
func (m *MockInterface) Delete() *rest.Request {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Delete")
	ret0, _ := ret[0].(*rest.Request)
	return ret0
}

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

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

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

// GetRateLimiter mocks base method.
func (m *MockInterface) GetRateLimiter() flowcontrol.RateLimiter {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetRateLimiter")
	ret0, _ := ret[0].(flowcontrol.RateLimiter)
	return ret0
}

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

// Patch mocks base method.
func (m *MockInterface) Patch(arg0 types.PatchType) *rest.Request {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Patch", arg0)
	ret0, _ := ret[0].(*rest.Request)
	return ret0
}

// Patch indicates an expected call of Patch.
func (mr *MockInterfaceMockRecorder) Patch(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Patch", reflect.TypeOf((*MockInterface)(nil).Patch), arg0)
}

// Post mocks base method.
func (m *MockInterface) Post() *rest.Request {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Post")
	ret0, _ := ret[0].(*rest.Request)
	return ret0
}

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

// Put mocks base method.
func (m *MockInterface) Put() *rest.Request {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Put")
	ret0, _ := ret[0].(*rest.Request)
	return ret0
}

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

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

// Verb indicates an expected call of Verb.
func (mr *MockInterfaceMockRecorder) Verb(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Verb", reflect.TypeOf((*MockInterface)(nil).Verb), arg0)
}
