// Code generated by MockGen. DO NOT EDIT.
// Source: client.gen.go
//
// Generated by this command:
//
//	mockgen -source=client.gen.go -destination=mock_generated/mock_client.gen.go -package=mock_generated
//
// Package mock_generated is a generated GoMock package.
package mock_generated

import (
	context "context"
	io "io"
	http "net/http"
	reflect "reflect"

	generated "github.com/openshift-kni/oran-o2ims/internal/service/alarms/internal/infrastructure/clusterserver/generated"
	generated0 "github.com/openshift-kni/oran-o2ims/internal/service/common/api/generated"
	gomock "go.uber.org/mock/gomock"
)

// MockHttpRequestDoer is a mock of HttpRequestDoer interface.
type MockHttpRequestDoer struct {
	ctrl     *gomock.Controller
	recorder *MockHttpRequestDoerMockRecorder
}

// MockHttpRequestDoerMockRecorder is the mock recorder for MockHttpRequestDoer.
type MockHttpRequestDoerMockRecorder struct {
	mock *MockHttpRequestDoer
}

// NewMockHttpRequestDoer creates a new mock instance.
func NewMockHttpRequestDoer(ctrl *gomock.Controller) *MockHttpRequestDoer {
	mock := &MockHttpRequestDoer{ctrl: ctrl}
	mock.recorder = &MockHttpRequestDoerMockRecorder{mock}
	return mock
}

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

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

// Do indicates an expected call of Do.
func (mr *MockHttpRequestDoerMockRecorder) Do(req any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Do", reflect.TypeOf((*MockHttpRequestDoer)(nil).Do), req)
}

// MockClientInterface is a mock of ClientInterface interface.
type MockClientInterface struct {
	ctrl     *gomock.Controller
	recorder *MockClientInterfaceMockRecorder
}

// MockClientInterfaceMockRecorder is the mock recorder for MockClientInterface.
type MockClientInterfaceMockRecorder struct {
	mock *MockClientInterface
}

// NewMockClientInterface creates a new mock instance.
func NewMockClientInterface(ctrl *gomock.Controller) *MockClientInterface {
	mock := &MockClientInterface{ctrl: ctrl}
	mock.recorder = &MockClientInterfaceMockRecorder{mock}
	return mock
}

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

// CreateSubscription mocks base method.
func (m *MockClientInterface) CreateSubscription(ctx context.Context, body generated.CreateSubscriptionJSONRequestBody, reqEditors ...generated.RequestEditorFn) (*http.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, body}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateSubscription", varargs...)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateSubscription indicates an expected call of CreateSubscription.
func (mr *MockClientInterfaceMockRecorder) CreateSubscription(ctx, body any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, body}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubscription", reflect.TypeOf((*MockClientInterface)(nil).CreateSubscription), varargs...)
}

// CreateSubscriptionWithBody mocks base method.
func (m *MockClientInterface) CreateSubscriptionWithBody(ctx context.Context, contentType string, body io.Reader, reqEditors ...generated.RequestEditorFn) (*http.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, contentType, body}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateSubscriptionWithBody", varargs...)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateSubscriptionWithBody indicates an expected call of CreateSubscriptionWithBody.
func (mr *MockClientInterfaceMockRecorder) CreateSubscriptionWithBody(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, contentType, body}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubscriptionWithBody", reflect.TypeOf((*MockClientInterface)(nil).CreateSubscriptionWithBody), varargs...)
}

// DeleteSubscription mocks base method.
func (m *MockClientInterface) DeleteSubscription(ctx context.Context, subscriptionId generated.SubscriptionId, reqEditors ...generated.RequestEditorFn) (*http.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, subscriptionId}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteSubscription", varargs...)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteSubscription indicates an expected call of DeleteSubscription.
func (mr *MockClientInterfaceMockRecorder) DeleteSubscription(ctx, subscriptionId any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, subscriptionId}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubscription", reflect.TypeOf((*MockClientInterface)(nil).DeleteSubscription), varargs...)
}

// GetAlarmDictionaries mocks base method.
func (m *MockClientInterface) GetAlarmDictionaries(ctx context.Context, params *generated.GetAlarmDictionariesParams, reqEditors ...generated.RequestEditorFn) (*http.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, params}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAlarmDictionaries", varargs...)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAlarmDictionaries indicates an expected call of GetAlarmDictionaries.
func (mr *MockClientInterfaceMockRecorder) GetAlarmDictionaries(ctx, params any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, params}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAlarmDictionaries", reflect.TypeOf((*MockClientInterface)(nil).GetAlarmDictionaries), varargs...)
}

// GetAlarmDictionary mocks base method.
func (m *MockClientInterface) GetAlarmDictionary(ctx context.Context, alarmDictionaryId generated0.AlarmDictionaryId, reqEditors ...generated.RequestEditorFn) (*http.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, alarmDictionaryId}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAlarmDictionary", varargs...)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAlarmDictionary indicates an expected call of GetAlarmDictionary.
func (mr *MockClientInterfaceMockRecorder) GetAlarmDictionary(ctx, alarmDictionaryId any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, alarmDictionaryId}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAlarmDictionary", reflect.TypeOf((*MockClientInterface)(nil).GetAlarmDictionary), varargs...)
}

// GetAllVersions mocks base method.
func (m *MockClientInterface) GetAllVersions(ctx context.Context, reqEditors ...generated.RequestEditorFn) (*http.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAllVersions", varargs...)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAllVersions indicates an expected call of GetAllVersions.
func (mr *MockClientInterfaceMockRecorder) GetAllVersions(ctx any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllVersions", reflect.TypeOf((*MockClientInterface)(nil).GetAllVersions), varargs...)
}

// GetClusterResource mocks base method.
func (m *MockClientInterface) GetClusterResource(ctx context.Context, clusterResourceId generated.ClusterResourceId, reqEditors ...generated.RequestEditorFn) (*http.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, clusterResourceId}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetClusterResource", varargs...)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterResource indicates an expected call of GetClusterResource.
func (mr *MockClientInterfaceMockRecorder) GetClusterResource(ctx, clusterResourceId any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, clusterResourceId}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterResource", reflect.TypeOf((*MockClientInterface)(nil).GetClusterResource), varargs...)
}

// GetClusterResourceType mocks base method.
func (m *MockClientInterface) GetClusterResourceType(ctx context.Context, clusterResourceTypeId generated.ClusterResourceTypeId, reqEditors ...generated.RequestEditorFn) (*http.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, clusterResourceTypeId}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetClusterResourceType", varargs...)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterResourceType indicates an expected call of GetClusterResourceType.
func (mr *MockClientInterfaceMockRecorder) GetClusterResourceType(ctx, clusterResourceTypeId any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, clusterResourceTypeId}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterResourceType", reflect.TypeOf((*MockClientInterface)(nil).GetClusterResourceType), varargs...)
}

// GetClusterResourceTypes mocks base method.
func (m *MockClientInterface) GetClusterResourceTypes(ctx context.Context, params *generated.GetClusterResourceTypesParams, reqEditors ...generated.RequestEditorFn) (*http.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, params}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetClusterResourceTypes", varargs...)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterResourceTypes indicates an expected call of GetClusterResourceTypes.
func (mr *MockClientInterfaceMockRecorder) GetClusterResourceTypes(ctx, params any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, params}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterResourceTypes", reflect.TypeOf((*MockClientInterface)(nil).GetClusterResourceTypes), varargs...)
}

// GetClusterResources mocks base method.
func (m *MockClientInterface) GetClusterResources(ctx context.Context, params *generated.GetClusterResourcesParams, reqEditors ...generated.RequestEditorFn) (*http.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, params}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetClusterResources", varargs...)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterResources indicates an expected call of GetClusterResources.
func (mr *MockClientInterfaceMockRecorder) GetClusterResources(ctx, params any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, params}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterResources", reflect.TypeOf((*MockClientInterface)(nil).GetClusterResources), varargs...)
}

// GetMinorVersions mocks base method.
func (m *MockClientInterface) GetMinorVersions(ctx context.Context, reqEditors ...generated.RequestEditorFn) (*http.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMinorVersions", varargs...)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMinorVersions indicates an expected call of GetMinorVersions.
func (mr *MockClientInterfaceMockRecorder) GetMinorVersions(ctx any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMinorVersions", reflect.TypeOf((*MockClientInterface)(nil).GetMinorVersions), varargs...)
}

// GetNodeCluster mocks base method.
func (m *MockClientInterface) GetNodeCluster(ctx context.Context, nodeClusterId generated.NodeClusterId, reqEditors ...generated.RequestEditorFn) (*http.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, nodeClusterId}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetNodeCluster", varargs...)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNodeCluster indicates an expected call of GetNodeCluster.
func (mr *MockClientInterfaceMockRecorder) GetNodeCluster(ctx, nodeClusterId any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, nodeClusterId}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeCluster", reflect.TypeOf((*MockClientInterface)(nil).GetNodeCluster), varargs...)
}

// GetNodeClusterType mocks base method.
func (m *MockClientInterface) GetNodeClusterType(ctx context.Context, nodeClusterTypeId generated.NodeClusterTypeId, reqEditors ...generated.RequestEditorFn) (*http.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, nodeClusterTypeId}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetNodeClusterType", varargs...)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNodeClusterType indicates an expected call of GetNodeClusterType.
func (mr *MockClientInterfaceMockRecorder) GetNodeClusterType(ctx, nodeClusterTypeId any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, nodeClusterTypeId}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeClusterType", reflect.TypeOf((*MockClientInterface)(nil).GetNodeClusterType), varargs...)
}

// GetNodeClusterTypeAlarmDictionary mocks base method.
func (m *MockClientInterface) GetNodeClusterTypeAlarmDictionary(ctx context.Context, nodeClusterTypeId generated.NodeClusterTypeId, reqEditors ...generated.RequestEditorFn) (*http.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, nodeClusterTypeId}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetNodeClusterTypeAlarmDictionary", varargs...)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNodeClusterTypeAlarmDictionary indicates an expected call of GetNodeClusterTypeAlarmDictionary.
func (mr *MockClientInterfaceMockRecorder) GetNodeClusterTypeAlarmDictionary(ctx, nodeClusterTypeId any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, nodeClusterTypeId}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeClusterTypeAlarmDictionary", reflect.TypeOf((*MockClientInterface)(nil).GetNodeClusterTypeAlarmDictionary), varargs...)
}

// GetNodeClusterTypes mocks base method.
func (m *MockClientInterface) GetNodeClusterTypes(ctx context.Context, params *generated.GetNodeClusterTypesParams, reqEditors ...generated.RequestEditorFn) (*http.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, params}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetNodeClusterTypes", varargs...)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNodeClusterTypes indicates an expected call of GetNodeClusterTypes.
func (mr *MockClientInterfaceMockRecorder) GetNodeClusterTypes(ctx, params any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, params}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeClusterTypes", reflect.TypeOf((*MockClientInterface)(nil).GetNodeClusterTypes), varargs...)
}

// GetNodeClusters mocks base method.
func (m *MockClientInterface) GetNodeClusters(ctx context.Context, params *generated.GetNodeClustersParams, reqEditors ...generated.RequestEditorFn) (*http.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, params}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetNodeClusters", varargs...)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNodeClusters indicates an expected call of GetNodeClusters.
func (mr *MockClientInterfaceMockRecorder) GetNodeClusters(ctx, params any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, params}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeClusters", reflect.TypeOf((*MockClientInterface)(nil).GetNodeClusters), varargs...)
}

// GetSubscription mocks base method.
func (m *MockClientInterface) GetSubscription(ctx context.Context, subscriptionId generated.SubscriptionId, reqEditors ...generated.RequestEditorFn) (*http.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, subscriptionId}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSubscription", varargs...)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSubscription indicates an expected call of GetSubscription.
func (mr *MockClientInterfaceMockRecorder) GetSubscription(ctx, subscriptionId any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, subscriptionId}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubscription", reflect.TypeOf((*MockClientInterface)(nil).GetSubscription), varargs...)
}

// GetSubscriptions mocks base method.
func (m *MockClientInterface) GetSubscriptions(ctx context.Context, params *generated.GetSubscriptionsParams, reqEditors ...generated.RequestEditorFn) (*http.Response, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, params}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSubscriptions", varargs...)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSubscriptions indicates an expected call of GetSubscriptions.
func (mr *MockClientInterfaceMockRecorder) GetSubscriptions(ctx, params any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, params}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubscriptions", reflect.TypeOf((*MockClientInterface)(nil).GetSubscriptions), varargs...)
}

// MockClientWithResponsesInterface is a mock of ClientWithResponsesInterface interface.
type MockClientWithResponsesInterface struct {
	ctrl     *gomock.Controller
	recorder *MockClientWithResponsesInterfaceMockRecorder
}

// MockClientWithResponsesInterfaceMockRecorder is the mock recorder for MockClientWithResponsesInterface.
type MockClientWithResponsesInterfaceMockRecorder struct {
	mock *MockClientWithResponsesInterface
}

// NewMockClientWithResponsesInterface creates a new mock instance.
func NewMockClientWithResponsesInterface(ctrl *gomock.Controller) *MockClientWithResponsesInterface {
	mock := &MockClientWithResponsesInterface{ctrl: ctrl}
	mock.recorder = &MockClientWithResponsesInterfaceMockRecorder{mock}
	return mock
}

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

// CreateSubscriptionWithBodyWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) CreateSubscriptionWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...generated.RequestEditorFn) (*generated.CreateSubscriptionResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, contentType, body}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateSubscriptionWithBodyWithResponse", varargs...)
	ret0, _ := ret[0].(*generated.CreateSubscriptionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateSubscriptionWithBodyWithResponse indicates an expected call of CreateSubscriptionWithBodyWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) CreateSubscriptionWithBodyWithResponse(ctx, contentType, body any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, contentType, body}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubscriptionWithBodyWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).CreateSubscriptionWithBodyWithResponse), varargs...)
}

// CreateSubscriptionWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) CreateSubscriptionWithResponse(ctx context.Context, body generated.CreateSubscriptionJSONRequestBody, reqEditors ...generated.RequestEditorFn) (*generated.CreateSubscriptionResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, body}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateSubscriptionWithResponse", varargs...)
	ret0, _ := ret[0].(*generated.CreateSubscriptionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateSubscriptionWithResponse indicates an expected call of CreateSubscriptionWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) CreateSubscriptionWithResponse(ctx, body any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, body}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSubscriptionWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).CreateSubscriptionWithResponse), varargs...)
}

// DeleteSubscriptionWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) DeleteSubscriptionWithResponse(ctx context.Context, subscriptionId generated.SubscriptionId, reqEditors ...generated.RequestEditorFn) (*generated.DeleteSubscriptionResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, subscriptionId}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "DeleteSubscriptionWithResponse", varargs...)
	ret0, _ := ret[0].(*generated.DeleteSubscriptionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeleteSubscriptionWithResponse indicates an expected call of DeleteSubscriptionWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) DeleteSubscriptionWithResponse(ctx, subscriptionId any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, subscriptionId}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteSubscriptionWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).DeleteSubscriptionWithResponse), varargs...)
}

// GetAlarmDictionariesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetAlarmDictionariesWithResponse(ctx context.Context, params *generated.GetAlarmDictionariesParams, reqEditors ...generated.RequestEditorFn) (*generated.GetAlarmDictionariesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, params}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAlarmDictionariesWithResponse", varargs...)
	ret0, _ := ret[0].(*generated.GetAlarmDictionariesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAlarmDictionariesWithResponse indicates an expected call of GetAlarmDictionariesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetAlarmDictionariesWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, params}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAlarmDictionariesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetAlarmDictionariesWithResponse), varargs...)
}

// GetAlarmDictionaryWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetAlarmDictionaryWithResponse(ctx context.Context, alarmDictionaryId generated0.AlarmDictionaryId, reqEditors ...generated.RequestEditorFn) (*generated.GetAlarmDictionaryResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, alarmDictionaryId}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAlarmDictionaryWithResponse", varargs...)
	ret0, _ := ret[0].(*generated.GetAlarmDictionaryResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAlarmDictionaryWithResponse indicates an expected call of GetAlarmDictionaryWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetAlarmDictionaryWithResponse(ctx, alarmDictionaryId any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, alarmDictionaryId}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAlarmDictionaryWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetAlarmDictionaryWithResponse), varargs...)
}

// GetAllVersionsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetAllVersionsWithResponse(ctx context.Context, reqEditors ...generated.RequestEditorFn) (*generated.GetAllVersionsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetAllVersionsWithResponse", varargs...)
	ret0, _ := ret[0].(*generated.GetAllVersionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAllVersionsWithResponse indicates an expected call of GetAllVersionsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetAllVersionsWithResponse(ctx any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllVersionsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetAllVersionsWithResponse), varargs...)
}

// GetClusterResourceTypeWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetClusterResourceTypeWithResponse(ctx context.Context, clusterResourceTypeId generated.ClusterResourceTypeId, reqEditors ...generated.RequestEditorFn) (*generated.GetClusterResourceTypeResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, clusterResourceTypeId}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetClusterResourceTypeWithResponse", varargs...)
	ret0, _ := ret[0].(*generated.GetClusterResourceTypeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterResourceTypeWithResponse indicates an expected call of GetClusterResourceTypeWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetClusterResourceTypeWithResponse(ctx, clusterResourceTypeId any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, clusterResourceTypeId}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterResourceTypeWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetClusterResourceTypeWithResponse), varargs...)
}

// GetClusterResourceTypesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetClusterResourceTypesWithResponse(ctx context.Context, params *generated.GetClusterResourceTypesParams, reqEditors ...generated.RequestEditorFn) (*generated.GetClusterResourceTypesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, params}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetClusterResourceTypesWithResponse", varargs...)
	ret0, _ := ret[0].(*generated.GetClusterResourceTypesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterResourceTypesWithResponse indicates an expected call of GetClusterResourceTypesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetClusterResourceTypesWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, params}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterResourceTypesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetClusterResourceTypesWithResponse), varargs...)
}

// GetClusterResourceWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetClusterResourceWithResponse(ctx context.Context, clusterResourceId generated.ClusterResourceId, reqEditors ...generated.RequestEditorFn) (*generated.GetClusterResourceResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, clusterResourceId}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetClusterResourceWithResponse", varargs...)
	ret0, _ := ret[0].(*generated.GetClusterResourceResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterResourceWithResponse indicates an expected call of GetClusterResourceWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetClusterResourceWithResponse(ctx, clusterResourceId any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, clusterResourceId}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterResourceWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetClusterResourceWithResponse), varargs...)
}

// GetClusterResourcesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetClusterResourcesWithResponse(ctx context.Context, params *generated.GetClusterResourcesParams, reqEditors ...generated.RequestEditorFn) (*generated.GetClusterResourcesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, params}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetClusterResourcesWithResponse", varargs...)
	ret0, _ := ret[0].(*generated.GetClusterResourcesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetClusterResourcesWithResponse indicates an expected call of GetClusterResourcesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetClusterResourcesWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, params}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetClusterResourcesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetClusterResourcesWithResponse), varargs...)
}

// GetMinorVersionsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetMinorVersionsWithResponse(ctx context.Context, reqEditors ...generated.RequestEditorFn) (*generated.GetMinorVersionsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetMinorVersionsWithResponse", varargs...)
	ret0, _ := ret[0].(*generated.GetMinorVersionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetMinorVersionsWithResponse indicates an expected call of GetMinorVersionsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetMinorVersionsWithResponse(ctx any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetMinorVersionsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetMinorVersionsWithResponse), varargs...)
}

// GetNodeClusterTypeAlarmDictionaryWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetNodeClusterTypeAlarmDictionaryWithResponse(ctx context.Context, nodeClusterTypeId generated.NodeClusterTypeId, reqEditors ...generated.RequestEditorFn) (*generated.GetNodeClusterTypeAlarmDictionaryResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, nodeClusterTypeId}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetNodeClusterTypeAlarmDictionaryWithResponse", varargs...)
	ret0, _ := ret[0].(*generated.GetNodeClusterTypeAlarmDictionaryResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNodeClusterTypeAlarmDictionaryWithResponse indicates an expected call of GetNodeClusterTypeAlarmDictionaryWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetNodeClusterTypeAlarmDictionaryWithResponse(ctx, nodeClusterTypeId any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, nodeClusterTypeId}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeClusterTypeAlarmDictionaryWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetNodeClusterTypeAlarmDictionaryWithResponse), varargs...)
}

// GetNodeClusterTypeWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetNodeClusterTypeWithResponse(ctx context.Context, nodeClusterTypeId generated.NodeClusterTypeId, reqEditors ...generated.RequestEditorFn) (*generated.GetNodeClusterTypeResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, nodeClusterTypeId}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetNodeClusterTypeWithResponse", varargs...)
	ret0, _ := ret[0].(*generated.GetNodeClusterTypeResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNodeClusterTypeWithResponse indicates an expected call of GetNodeClusterTypeWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetNodeClusterTypeWithResponse(ctx, nodeClusterTypeId any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, nodeClusterTypeId}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeClusterTypeWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetNodeClusterTypeWithResponse), varargs...)
}

// GetNodeClusterTypesWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetNodeClusterTypesWithResponse(ctx context.Context, params *generated.GetNodeClusterTypesParams, reqEditors ...generated.RequestEditorFn) (*generated.GetNodeClusterTypesResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, params}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetNodeClusterTypesWithResponse", varargs...)
	ret0, _ := ret[0].(*generated.GetNodeClusterTypesResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNodeClusterTypesWithResponse indicates an expected call of GetNodeClusterTypesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetNodeClusterTypesWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, params}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeClusterTypesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetNodeClusterTypesWithResponse), varargs...)
}

// GetNodeClusterWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetNodeClusterWithResponse(ctx context.Context, nodeClusterId generated.NodeClusterId, reqEditors ...generated.RequestEditorFn) (*generated.GetNodeClusterResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, nodeClusterId}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetNodeClusterWithResponse", varargs...)
	ret0, _ := ret[0].(*generated.GetNodeClusterResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNodeClusterWithResponse indicates an expected call of GetNodeClusterWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetNodeClusterWithResponse(ctx, nodeClusterId any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, nodeClusterId}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeClusterWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetNodeClusterWithResponse), varargs...)
}

// GetNodeClustersWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetNodeClustersWithResponse(ctx context.Context, params *generated.GetNodeClustersParams, reqEditors ...generated.RequestEditorFn) (*generated.GetNodeClustersResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, params}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetNodeClustersWithResponse", varargs...)
	ret0, _ := ret[0].(*generated.GetNodeClustersResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetNodeClustersWithResponse indicates an expected call of GetNodeClustersWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetNodeClustersWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, params}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNodeClustersWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetNodeClustersWithResponse), varargs...)
}

// GetSubscriptionWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetSubscriptionWithResponse(ctx context.Context, subscriptionId generated.SubscriptionId, reqEditors ...generated.RequestEditorFn) (*generated.GetSubscriptionResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, subscriptionId}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSubscriptionWithResponse", varargs...)
	ret0, _ := ret[0].(*generated.GetSubscriptionResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSubscriptionWithResponse indicates an expected call of GetSubscriptionWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetSubscriptionWithResponse(ctx, subscriptionId any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, subscriptionId}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubscriptionWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetSubscriptionWithResponse), varargs...)
}

// GetSubscriptionsWithResponse mocks base method.
func (m *MockClientWithResponsesInterface) GetSubscriptionsWithResponse(ctx context.Context, params *generated.GetSubscriptionsParams, reqEditors ...generated.RequestEditorFn) (*generated.GetSubscriptionsResponse, error) {
	m.ctrl.T.Helper()
	varargs := []any{ctx, params}
	for _, a := range reqEditors {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetSubscriptionsWithResponse", varargs...)
	ret0, _ := ret[0].(*generated.GetSubscriptionsResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSubscriptionsWithResponse indicates an expected call of GetSubscriptionsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetSubscriptionsWithResponse(ctx, params any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, params}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubscriptionsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetSubscriptionsWithResponse), varargs...)
}
