// Code generated by MockGen. DO NOT EDIT.
// Source: ./pkg/cloud/aws/client.go
//
// Generated by this command:
//
//	mockgen -destination ./pkg/cloud/aws/client_mock.go -package aws -source ./pkg/cloud/aws/client.go
//

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

import (
	reflect "reflect"

	autoscaling "github.com/aws/aws-sdk-go-v2/service/autoscaling"
	ec2 "github.com/aws/aws-sdk-go-v2/service/ec2"
	eks "github.com/aws/aws-sdk-go-v2/service/eks"
	elasticloadbalancingv2 "github.com/aws/aws-sdk-go-v2/service/elasticloadbalancingv2"
	iam "github.com/aws/aws-sdk-go-v2/service/iam"
	kafka "github.com/aws/aws-sdk-go-v2/service/kafka"
	resourcegroupstaggingapi "github.com/aws/aws-sdk-go-v2/service/resourcegroupstaggingapi"
	s3 "github.com/aws/aws-sdk-go-v2/service/s3"
	servicequotas "github.com/aws/aws-sdk-go-v2/service/servicequotas"
	ssm "github.com/aws/aws-sdk-go-v2/service/ssm"
	support "github.com/aws/aws-sdk-go-v2/service/support"
	gomock "go.uber.org/mock/gomock"
)

// MockClient is a mock of Client interface.
type MockClient struct {
	ctrl     *gomock.Controller
	recorder *MockClientMockRecorder
}

// MockClientMockRecorder is the mock recorder for MockClient.
type MockClientMockRecorder struct {
	mock *MockClient
}

// NewMockClient creates a new mock instance.
func NewMockClient(ctrl *gomock.Controller) *MockClient {
	mock := &MockClient{ctrl: ctrl}
	mock.recorder = &MockClientMockRecorder{mock}
	return mock
}

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

// AUTOSCALE mocks base method.
func (m *MockClient) AUTOSCALE(arg0 *AssumedRole, arg1 ...Option) *autoscaling.Client {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AUTOSCALE", varargs...)
	ret0, _ := ret[0].(*autoscaling.Client)
	return ret0
}

// AUTOSCALE indicates an expected call of AUTOSCALE.
func (mr *MockClientMockRecorder) AUTOSCALE(arg0 any, arg1 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AUTOSCALE", reflect.TypeOf((*MockClient)(nil).AUTOSCALE), varargs...)
}

// EC2 mocks base method.
func (m *MockClient) EC2(arg0 *AssumedRole, arg1 ...Option) *ec2.Client {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EC2", varargs...)
	ret0, _ := ret[0].(*ec2.Client)
	return ret0
}

// EC2 indicates an expected call of EC2.
func (mr *MockClientMockRecorder) EC2(arg0 any, arg1 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EC2", reflect.TypeOf((*MockClient)(nil).EC2), varargs...)
}

// EKS mocks base method.
func (m *MockClient) EKS(arg0 *AssumedRole, arg1 ...Option) *eks.Client {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "EKS", varargs...)
	ret0, _ := ret[0].(*eks.Client)
	return ret0
}

// EKS indicates an expected call of EKS.
func (mr *MockClientMockRecorder) EKS(arg0 any, arg1 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EKS", reflect.TypeOf((*MockClient)(nil).EKS), varargs...)
}

// ELBV2 mocks base method.
func (m *MockClient) ELBV2(arg0 *AssumedRole, arg1 ...Option) *elasticloadbalancingv2.Client {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ELBV2", varargs...)
	ret0, _ := ret[0].(*elasticloadbalancingv2.Client)
	return ret0
}

// ELBV2 indicates an expected call of ELBV2.
func (mr *MockClientMockRecorder) ELBV2(arg0 any, arg1 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ELBV2", reflect.TypeOf((*MockClient)(nil).ELBV2), varargs...)
}

// IAM mocks base method.
func (m *MockClient) IAM(arg0 *AssumedRole, arg1 ...Option) *iam.Client {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "IAM", varargs...)
	ret0, _ := ret[0].(*iam.Client)
	return ret0
}

// IAM indicates an expected call of IAM.
func (mr *MockClientMockRecorder) IAM(arg0 any, arg1 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IAM", reflect.TypeOf((*MockClient)(nil).IAM), varargs...)
}

// Kafka mocks base method.
func (m *MockClient) Kafka(arg0 *AssumedRole, arg1 ...Option) *kafka.Client {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Kafka", varargs...)
	ret0, _ := ret[0].(*kafka.Client)
	return ret0
}

// Kafka indicates an expected call of Kafka.
func (mr *MockClientMockRecorder) Kafka(arg0 any, arg1 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Kafka", reflect.TypeOf((*MockClient)(nil).Kafka), varargs...)
}

// ResourceGroupsTagging mocks base method.
func (m *MockClient) ResourceGroupsTagging(arg0 *AssumedRole, arg1 ...Option) *resourcegroupstaggingapi.Client {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ResourceGroupsTagging", varargs...)
	ret0, _ := ret[0].(*resourcegroupstaggingapi.Client)
	return ret0
}

// ResourceGroupsTagging indicates an expected call of ResourceGroupsTagging.
func (mr *MockClientMockRecorder) ResourceGroupsTagging(arg0 any, arg1 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResourceGroupsTagging", reflect.TypeOf((*MockClient)(nil).ResourceGroupsTagging), varargs...)
}

// S3 mocks base method.
func (m *MockClient) S3(arg0 *AssumedRole, arg1 ...Option) *s3.Client {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "S3", varargs...)
	ret0, _ := ret[0].(*s3.Client)
	return ret0
}

// S3 indicates an expected call of S3.
func (mr *MockClientMockRecorder) S3(arg0 any, arg1 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "S3", reflect.TypeOf((*MockClient)(nil).S3), varargs...)
}

// SSM mocks base method.
func (m *MockClient) SSM(arg0 *AssumedRole, arg1 ...Option) *ssm.Client {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SSM", varargs...)
	ret0, _ := ret[0].(*ssm.Client)
	return ret0
}

// SSM indicates an expected call of SSM.
func (mr *MockClientMockRecorder) SSM(arg0 any, arg1 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SSM", reflect.TypeOf((*MockClient)(nil).SSM), varargs...)
}

// ServiceQuotas mocks base method.
func (m *MockClient) ServiceQuotas(arg0 *AssumedRole, arg1 ...Option) *servicequotas.Client {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "ServiceQuotas", varargs...)
	ret0, _ := ret[0].(*servicequotas.Client)
	return ret0
}

// ServiceQuotas indicates an expected call of ServiceQuotas.
func (mr *MockClientMockRecorder) ServiceQuotas(arg0 any, arg1 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ServiceQuotas", reflect.TypeOf((*MockClient)(nil).ServiceQuotas), varargs...)
}

// Support mocks base method.
func (m *MockClient) Support(arg0 *AssumedRole, arg1 ...Option) *support.Client {
	m.ctrl.T.Helper()
	varargs := []any{arg0}
	for _, a := range arg1 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Support", varargs...)
	ret0, _ := ret[0].(*support.Client)
	return ret0
}

// Support indicates an expected call of Support.
func (mr *MockClientMockRecorder) Support(arg0 any, arg1 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]any{arg0}, arg1...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Support", reflect.TypeOf((*MockClient)(nil).Support), varargs...)
}