func NewMockresponseHelper(ctrl *gomock.Controller) *MockresponseHelper {
	mock := &MockresponseHelper{ctrl: ctrl}
	mock.recorder = &MockresponseHelperMockRecorder{mock}
	return mock
}
NewMockresponseHelper creates a new mock instance
package mocks
import (
	gomock "github.com/golang/mock/gomock"
	http "net/http"
	reflect "reflect"
)
type MockRestHelper struct {
	ctrl     *gomock.Controller
	recorder *MockRestHelperMockRecorder
}
type MockRestHelperMockRecorder struct {
	mock *MockRestHelper
}
func NewMockRestHelper(ctrl *gomock.Controller) *MockRestHelper {
	mock := &MockRestHelper{ctrl: ctrl}
	mock.recorder = &MockRestHelperMockRecorder{mock}
	return mock
}
func (m *MockRestHelper) EXPECT() *MockRestHelperMockRecorder {
	return m.recorder
}
func (m *MockRestHelper) MakeTargetURL(target string, port int, restapi string) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MakeTargetURL", target, port, restapi)
	ret0, _ := ret[0].(string)
	return ret0
}
func (mr *MockRestHelperMockRecorder) MakeTargetURL(target, port, restapi interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MakeTargetURL", reflect.TypeOf((*MockRestHelper)(nil).MakeTargetURL), target, port, restapi)
}
func (m *MockRestHelper) DoGet(targetURL string) ([]byte, int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DoGet", targetURL)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}
func (mr *MockRestHelperMockRecorder) DoGet(targetURL interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DoGet", reflect.TypeOf((*MockRestHelper)(nil).DoGet), targetURL)
}
func (m *MockRestHelper) DoGetWithBody(targetURL string, bodybytes []byte) ([]byte, int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DoGetWithBody", targetURL, bodybytes)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}
func (mr *MockRestHelperMockRecorder) DoGetWithBody(targetURL, bodybytes interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DoGetWithBody", reflect.TypeOf((*MockRestHelper)(nil).DoGetWithBody), targetURL, bodybytes)
}
func (m *MockRestHelper) DoPost(targetURL string, bodybytes []byte) ([]byte, int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DoPost", targetURL, bodybytes)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}
func (mr *MockRestHelperMockRecorder) DoPost(targetURL, bodybytes interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DoPost", reflect.TypeOf((*MockRestHelper)(nil).DoPost), targetURL, bodybytes)
}
func (m *MockRestHelper) DoDelete(targetURL string) ([]byte, int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DoDelete", targetURL)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}
func (mr *MockRestHelperMockRecorder) DoDelete(targetURL interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DoDelete", reflect.TypeOf((*MockRestHelper)(nil).DoDelete), targetURL)
}
func (m *MockRestHelper) Response(w http.ResponseWriter, bytes []byte, httpStatus int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Response", w, bytes, httpStatus)
}
func (mr *MockRestHelperMockRecorder) Response(w, bytes, httpStatus interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Response", reflect.TypeOf((*MockRestHelper)(nil).Response), w, bytes, httpStatus)
}
type MockRestHelperWithCertificateSetter struct {
	ctrl     *gomock.Controller
	recorder *MockRestHelperWithCertificateSetterMockRecorder
}
type MockRestHelperWithCertificateSetterMockRecorder struct {
	mock *MockRestHelperWithCertificateSetter
}
func NewMockRestHelperWithCertificateSetter(ctrl *gomock.Controller) *MockRestHelperWithCertificateSetter {
	mock := &MockRestHelperWithCertificateSetter{ctrl: ctrl}
	mock.recorder = &MockRestHelperWithCertificateSetterMockRecorder{mock}
	return mock
}
func (m *MockRestHelperWithCertificateSetter) EXPECT() *MockRestHelperWithCertificateSetterMockRecorder {
	return m.recorder
}
func (m *MockRestHelperWithCertificateSetter) MakeTargetURL(target string, port int, restapi string) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MakeTargetURL", target, port, restapi)
	ret0, _ := ret[0].(string)
	return ret0
}
func (mr *MockRestHelperWithCertificateSetterMockRecorder) MakeTargetURL(target, port, restapi interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MakeTargetURL", reflect.TypeOf((*MockRestHelperWithCertificateSetter)(nil).MakeTargetURL), target, port, restapi)
}
func (m *MockRestHelperWithCertificateSetter) DoGet(targetURL string) ([]byte, int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DoGet", targetURL)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}
func (mr *MockRestHelperWithCertificateSetterMockRecorder) DoGet(targetURL interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DoGet", reflect.TypeOf((*MockRestHelperWithCertificateSetter)(nil).DoGet), targetURL)
}
func (m *MockRestHelperWithCertificateSetter) DoGetWithBody(targetURL string, bodybytes []byte) ([]byte, int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DoGetWithBody", targetURL, bodybytes)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}
func (mr *MockRestHelperWithCertificateSetterMockRecorder) DoGetWithBody(targetURL, bodybytes interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DoGetWithBody", reflect.TypeOf((*MockRestHelperWithCertificateSetter)(nil).DoGetWithBody), targetURL, bodybytes)
}
func (m *MockRestHelperWithCertificateSetter) DoPost(targetURL string, bodybytes []byte) ([]byte, int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DoPost", targetURL, bodybytes)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}
func (mr *MockRestHelperWithCertificateSetterMockRecorder) DoPost(targetURL, bodybytes interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DoPost", reflect.TypeOf((*MockRestHelperWithCertificateSetter)(nil).DoPost), targetURL, bodybytes)
}
func (m *MockRestHelperWithCertificateSetter) DoDelete(targetURL string) ([]byte, int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DoDelete", targetURL)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}
func (mr *MockRestHelperWithCertificateSetterMockRecorder) DoDelete(targetURL interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DoDelete", reflect.TypeOf((*MockRestHelperWithCertificateSetter)(nil).DoDelete), targetURL)
}
func (m *MockRestHelperWithCertificateSetter) Response(w http.ResponseWriter, bytes []byte, httpStatus int) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Response", w, bytes, httpStatus)
}
func (mr *MockRestHelperWithCertificateSetterMockRecorder) Response(w, bytes, httpStatus interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Response", reflect.TypeOf((*MockRestHelperWithCertificateSetter)(nil).Response), w, bytes, httpStatus)
}
func (m *MockRestHelperWithCertificateSetter) SetCertificateFilePath(path string) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "SetCertificateFilePath", path)
}
func (mr *MockRestHelperWithCertificateSetterMockRecorder) SetCertificateFilePath(path interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCertificateFilePath", reflect.TypeOf((*MockRestHelperWithCertificateSetter)(nil).SetCertificateFilePath), path)
}
type MockurlHelper struct {
	ctrl     *gomock.Controller
	recorder *MockurlHelperMockRecorder
}
type MockurlHelperMockRecorder struct {
	mock *MockurlHelper
}
func NewMockurlHelper(ctrl *gomock.Controller) *MockurlHelper {
	mock := &MockurlHelper{ctrl: ctrl}
	mock.recorder = &MockurlHelperMockRecorder{mock}
	return mock
}
func (m *MockurlHelper) EXPECT() *MockurlHelperMockRecorder {
	return m.recorder
}
func (m *MockurlHelper) MakeTargetURL(target string, port int, restapi string) string {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "MakeTargetURL", target, port, restapi)
	ret0, _ := ret[0].(string)
	return ret0
}
func (mr *MockurlHelperMockRecorder) MakeTargetURL(target, port, restapi interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MakeTargetURL", reflect.TypeOf((*MockurlHelper)(nil).MakeTargetURL), target, port, restapi)
}
type MockrequestHelper struct {
	ctrl     *gomock.Controller
	recorder *MockrequestHelperMockRecorder
}
type MockrequestHelperMockRecorder struct {
	mock *MockrequestHelper
}
func NewMockrequestHelper(ctrl *gomock.Controller) *MockrequestHelper {
	mock := &MockrequestHelper{ctrl: ctrl}
	mock.recorder = &MockrequestHelperMockRecorder{mock}
	return mock
}
func (m *MockrequestHelper) EXPECT() *MockrequestHelperMockRecorder {
	return m.recorder
}
func (m *MockrequestHelper) DoGet(targetURL string) ([]byte, int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DoGet", targetURL)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}
func (mr *MockrequestHelperMockRecorder) DoGet(targetURL interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DoGet", reflect.TypeOf((*MockrequestHelper)(nil).DoGet), targetURL)
}
func (m *MockrequestHelper) DoGetWithBody(targetURL string, bodybytes []byte) ([]byte, int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DoGetWithBody", targetURL, bodybytes)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}
func (mr *MockrequestHelperMockRecorder) DoGetWithBody(targetURL, bodybytes interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DoGetWithBody", reflect.TypeOf((*MockrequestHelper)(nil).DoGetWithBody), targetURL, bodybytes)
}
func (m *MockrequestHelper) DoPost(targetURL string, bodybytes []byte) ([]byte, int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DoPost", targetURL, bodybytes)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}
func (mr *MockrequestHelperMockRecorder) DoPost(targetURL, bodybytes interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DoPost", reflect.TypeOf((*MockrequestHelper)(nil).DoPost), targetURL, bodybytes)
}
func (m *MockrequestHelper) DoDelete(targetURL string) ([]byte, int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DoDelete", targetURL)
	ret0, _ := ret[0].([]byte)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}
func (mr *MockrequestHelperMockRecorder) DoDelete(targetURL interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DoDelete", reflect.TypeOf((*MockrequestHelper)(nil).DoDelete), targetURL)
}
type MockresponseHelper struct {
	ctrl     *gomock.Controller
	recorder *MockresponseHelperMockRecorder
}
type MockresponseHelperMockRecorder struct {
	mock *MockresponseHelper
}