// 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"

	types "github.com/oapi-codegen/runtime/types"
	generated "github.com/openshift-kni/oran-o2ims/internal/service/alarms/internal/infrastructure/resourceserver/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...)
}

// GetCloudInfo mocks base method.
func (m *MockClientInterface) GetCloudInfo(ctx context.Context, params *generated.GetCloudInfoParams, 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, "GetCloudInfo", varargs...)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetCloudInfo indicates an expected call of GetCloudInfo.
func (mr *MockClientInterfaceMockRecorder) GetCloudInfo(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, "GetCloudInfo", reflect.TypeOf((*MockClientInterface)(nil).GetCloudInfo), varargs...)
}

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

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

// GetDeploymentManagers mocks base method.
func (m *MockClientInterface) GetDeploymentManagers(ctx context.Context, params *generated.GetDeploymentManagersParams, 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, "GetDeploymentManagers", varargs...)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetDeploymentManagers indicates an expected call of GetDeploymentManagers.
func (mr *MockClientInterfaceMockRecorder) GetDeploymentManagers(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, "GetDeploymentManagers", reflect.TypeOf((*MockClientInterface)(nil).GetDeploymentManagers), varargs...)
}

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

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

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

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

// GetLocations mocks base method.
func (m *MockClientInterface) GetLocations(ctx context.Context, params *generated.GetLocationsParams, 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, "GetLocations", varargs...)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetLocations indicates an expected call of GetLocations.
func (mr *MockClientInterfaceMockRecorder) GetLocations(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, "GetLocations", reflect.TypeOf((*MockClientInterface)(nil).GetLocations), 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...)
}

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

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

// GetOCloudSites mocks base method.
func (m *MockClientInterface) GetOCloudSites(ctx context.Context, params *generated.GetOCloudSitesParams, 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, "GetOCloudSites", varargs...)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetOCloudSites indicates an expected call of GetOCloudSites.
func (mr *MockClientInterfaceMockRecorder) GetOCloudSites(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, "GetOCloudSites", reflect.TypeOf((*MockClientInterface)(nil).GetOCloudSites), varargs...)
}

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

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

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

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

// GetResourcePools mocks base method.
func (m *MockClientInterface) GetResourcePools(ctx context.Context, params *generated.GetResourcePoolsParams, 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, "GetResourcePools", varargs...)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetResourcePools indicates an expected call of GetResourcePools.
func (mr *MockClientInterfaceMockRecorder) GetResourcePools(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, "GetResourcePools", reflect.TypeOf((*MockClientInterface)(nil).GetResourcePools), varargs...)
}

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

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

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

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

// GetResourceTypes mocks base method.
func (m *MockClientInterface) GetResourceTypes(ctx context.Context, params *generated.GetResourceTypesParams, 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, "GetResourceTypes", varargs...)
	ret0, _ := ret[0].(*http.Response)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetResourceTypes indicates an expected call of GetResourceTypes.
func (mr *MockClientInterfaceMockRecorder) GetResourceTypes(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, "GetResourceTypes", reflect.TypeOf((*MockClientInterface)(nil).GetResourceTypes), varargs...)
}

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

// GetResources indicates an expected call of GetResources.
func (mr *MockClientInterfaceMockRecorder) GetResources(ctx, resourcePoolId, params any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, resourcePoolId, params}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResources", reflect.TypeOf((*MockClientInterface)(nil).GetResources), 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...)
}

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

// GetCloudInfoWithResponse indicates an expected call of GetCloudInfoWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetCloudInfoWithResponse(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, "GetCloudInfoWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetCloudInfoWithResponse), varargs...)
}

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

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

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

// GetDeploymentManagersWithResponse indicates an expected call of GetDeploymentManagersWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetDeploymentManagersWithResponse(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, "GetDeploymentManagersWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetDeploymentManagersWithResponse), varargs...)
}

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

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

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

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

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

// GetLocationsWithResponse indicates an expected call of GetLocationsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetLocationsWithResponse(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, "GetLocationsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetLocationsWithResponse), 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...)
}

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

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

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

// GetOCloudSitesWithResponse indicates an expected call of GetOCloudSitesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetOCloudSitesWithResponse(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, "GetOCloudSitesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetOCloudSitesWithResponse), varargs...)
}

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

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

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

// GetResourcePoolsWithResponse indicates an expected call of GetResourcePoolsWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetResourcePoolsWithResponse(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, "GetResourcePoolsWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetResourcePoolsWithResponse), varargs...)
}

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

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

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

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

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

// GetResourceTypesWithResponse indicates an expected call of GetResourceTypesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetResourceTypesWithResponse(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, "GetResourceTypesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetResourceTypesWithResponse), varargs...)
}

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

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

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

// GetResourcesWithResponse indicates an expected call of GetResourcesWithResponse.
func (mr *MockClientWithResponsesInterfaceMockRecorder) GetResourcesWithResponse(ctx, resourcePoolId, params any, reqEditors ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{ctx, resourcePoolId, params}, reqEditors...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourcesWithResponse", reflect.TypeOf((*MockClientWithResponsesInterface)(nil).GetResourcesWithResponse), 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...)
}
